Python kursi24.2-dars: NumPy — amallar va broadcasting
Python kursi · Malumot tahlili

24.2-dars: NumPy — amallar va broadcasting

16 daqiqa2/18-dars

24-QISM — MA'LUMOT TAHLILI · 2-dars


1. Kirish va motivatsiya

24.1 da vektorlangan amalni ko'rdik: a + 10 — bir xil shakldagi massivlar (yoki massiv + skalyar). Lekin real tahlilda ko'pincha har xil shakldagi massivlar bilan ishlash kerak: 2D jadvalning har qatoriga bir 1D qatorni qo'shish (har ustunga tuzatish), har ustunga alohida ko'paytiruvchi. Har safar shaklni moslash (nusxa, sikl) noqulay.

Broadcasting — NumPy'ning kuchli mexanizmi: har xil shakldagi massivlar ustida amalni avtomatik moslab bajaradi (kichik massivni "cho'zib" kattasiga moslaydi) — nusxasiz, siklsiz. Bunga qo'shimcha, NumPy matematik funksiyalar (sqrt, exp, log, sin) va foydali amallar (where, clip, cumsum, dot) — hammasi vektorlangan (butun massiv). Bular ma'lumot tahlilida kundalik ishlatiladi.

Real vaziyat. Bir tahlilda har mahsulot narxiga (2D: mahsulot × oy) oylik inflyatsiya koeffitsienti (1D: oylar) ko'paytirish kerak edi. Sikl bilan: ikki ichma-ich for, sekin va chalkash. Broadcasting bilan: narxlar * koef (bir qator) — NumPy koef'ni har qatorga avtomatik mosladi. Kod qisqa, tez, tushunarli bo'ldi. Broadcasting'ni tushunish — NumPy ustasi bo'lishning kaliti.

Bu darsda broadcasting va NumPy amallarini o'rganamiz.

Bu darsda:

  • Broadcasting nima
  • Broadcasting qoidalari
  • Matematik funksiyalar (sqrt, exp, log)
  • Foydali amallar (where, clip)
  • To'plovchi amallar (cumsum, dot)
  • axis bilan agregat
  • Broadcasting xatolari
  • Amaliy: jadval hisoblash

ℹ Misollarda NumPy (import numpy as np) bilan sinaladi.


2. Nazariya — chuqur tushuntirish

2.1. Broadcasting nima

Broadcasting — har xil shakldagi massivlar bilan amal:

python
a = np.array([[1, 2, 3],
              [4, 5, 6]])       # shakl (2, 3)
qator = np.array([10, 20, 30])  # shakl (3,)
a + qator                       # har qatorga qator qo'shiladi
# [[11 22 33]
#  [14 25 36]]

Broadcasting — NumPy har xil shakldagi massivlar ustida amalni avtomatik moslab bajaradi: kichik massivni (qator) katta massivga (a) "cho'zib" moslaydi (nusxasiz — mantiqan takrorlanadi). Bu sikl va qo'lda nusxasiz. a + 10 (skalyar) — broadcasting'ning oddiy holi. Kuchli, lekin qoidalarni bilish kerak.

2.2. Broadcasting qoidalari

Broadcasting ikki massiv shaklini o'ngdan solishtiradi:

Qoida: har o'lchamda — teng YOKI bittasi 1 bo'lsin
(2, 3) + (3,)   → (3,) → (1, 3) → mos (qator takror)
(2, 3) + (2, 1) → mos (ustun takror)
(2, 3) + (2,)   → XATO (o'ng o'lcham 3 ≠ 2)

Broadcasting qoidasi: shakllar o'ngdan chapga solishtiriladi; har o'lchamda o'lchamlar teng yoki bittasi 1 bo'lsa — mos (1 bo'lgan tomon takrorlanadi). Aks holda xato. (3,) → (1, 3) (chapga 1 qo'shiladi). Skalyar — har shaklga mos. Bu qoida broadcasting'ning yuragi.

2.3. Matematik funksiyalar

NumPy vektorlangan matematik funksiyalar:

python
np.sqrt(x)          # kvadrat ildiz (har element)
np.exp(x)           # e^x
np.log(x)           # natural log
np.sin(x); np.cos(x)  # trigonometriya
np.abs(x)           # modul
np.round(x, 2)      # yaxlitlash

NumPy matematik funksiyalar (ufunc — universal funksiya) butun massivga vektorlangan: np.sqrt (ildiz), np.exp (eksponenta), np.log (logarifm), np.sin/np.cos (trigonometriya), np.abs, np.round. Har biri har elementga qo'llanadi (siklsiz). Bu ilmiy hisoblash, statistika, ML uchun asosiy.

2.4. Foydali amallar (where, clip)

Shartli va cheklovchi amallar:

python
np.where(x > 0, 1, -1)       # shart: True→1, False→-1
np.clip(x, 0, 100)           # 0–100 oraliqda chekla
np.maximum(a, b)             # element-element max
np.minimum(a, 100)           # 100 dan oshmasin
np.abs(x)                    # manfiyni musbatga

Foydali amallar: np.where(shart, a, b) (shart bo'yicha tanla — a agar True, b agar False), np.clip(x, min, max) (oraliqda chekla — kichik→min, katta→max), np.maximum/np.minimum (element-element). Bular ma'lumot tozalash 24.8-bob, cheklash, shartli o'zgartirishda juda foydali.

2.5. To'plovchi amallar (cumsum, dot)

Yig'uvchi va ko'paytiruvchi:

python
np.array([1, 2, 3, 4]).cumsum()   # [1 3 6 10] (jamlanma)
np.array([1, 2, 3, 4]).cumprod()  # [1 2 6 24]
a.dot(b)                          # skalyar ko'paytma (yoki @)
np.diff(x)                        # ketma-ket farq

To'plovchi amallar: .cumsum() (jamlanma yig'indi — [1, 3, 6, 10]), .cumprod() (jamlanma ko'paytma), .dot()/@ (skalyar/matritsa ko'paytma — ML asosi), np.diff() (ketma-ket farq). Bu vaqt qatorlari 24.11-bob, moliya (jamlanma), chiziqli algebra (matritsa) da kerak.

2.6. axis bilan agregat (2D)

2D massivda yo'nalish bo'yicha:

python
m = np.array([[1, 2, 3], [4, 5, 6]])
m.sum()             # 21 (hammasi)
m.sum(axis=0)       # [5 7 9] (ustunlar — pastga)
m.sum(axis=1)       # [6 15] (qatorlar — o'ngga)
m.mean(axis=0)      # ustun o'rtacha

2D agregat axis bilan: axis=0 — ustunlar bo'yicha (pastga yig'adi, natija har ustun uchun), axis=1 — qatorlar bo'yicha (o'ngga, natija har qator uchun). axissiz — butun massiv. Bu jadval tahlilida muhim: ustun bo'yicha (masalan, har mahsulot jami) yoki qator bo'yicha (har oy jami). 24.9 (pandas guruhlash) shunga o'xshaydi.

2.7. Broadcasting xatolari

Shakllar Natija
(3,) + (3,) Mos (teng)
(2,3) + (3,) Mos (qator takror)
(2,3) + (2,1) Mos (ustun takror)
(2,3) + (2,) xato (o'ng 3≠2)
(2,3) + (3,1) xato (2≠3)

Broadcasting xato: o'ngdan solishtirganda o'lchamlar teng emas va 1 ham emas. (2,3) + (2,) — o'ng o'lcham 3 ≠ 2 (xato). Yechim: shaklni to'g'rilash — (2,) → (2,1) (reshape(2,1) yoki [:, None]) → ustun sifatida broadcast. Xato xabari: "operands could not be broadcast together". Shaklni tekshirish muhim.

2.8. Broadcasting nega foydali

Broadcasting xotira va vaqt tejaydi: kichik massivni jismonan nusxalamaydi (mantiqan takrorlanadi — xotira kam), amal C darajasida (tez). Masalan, (1000, 1000) jadvalga (1000,) qatorni qo'shish — qatorni 1000 marta nusxalamasdan. Bu "hisoblashni ma'lumotga moslash, ma'lumotni ko'chirmaslik" tamoyili. Broadcasting — NumPy'ning eng nafis va foydali imkoniyati.


3. Tez ma'lumotnoma

python
import numpy as np

# broadcasting (avtomatik shakl moslash):
a + 10                       # skalyar (har element)
a2d + qator1d                # har qatorga qator (shakl mos)
a2d + ustun.reshape(-1, 1)   # har ustunga

# matematik funksiyalar:
np.sqrt(x); np.exp(x); np.log(x); np.sin(x)
np.abs(x); np.round(x, 2)

# foydali:
np.where(x > 0, 1, -1)       # shart
np.clip(x, 0, 100)           # chekla
np.maximum(a, b); np.minimum(a, 100)

# to'plovchi:
x.cumsum(); x.cumprod(); a.dot(b); np.diff(x)

# axis (2D):
m.sum(axis=0)  # ustun · m.sum(axis=1)  # qator

Broadcasting xulosasi

Broadcasting: shakl o'ngdan mos (teng yoki 1) · nusxasiz, siklsiz
ufunc: sqrt/exp/log/sin (vektorlangan) · where/clip: shartli/cheklov
axis=0 ustun, axis=1 qator

4. Batafsil misollar

Misollarda NumPy (import numpy as np) bilan sinaladi.

Misol 1 — Broadcasting

python
"""broadcasting: skalyar, qator (axis=0), ustun (reshape) — har xil shakl avtomatik moslanadi."""

import numpy as np


def main() -> None:
    a = np.array([[1, 2, 3], [4, 5, 6]])   # shakl (2, 3)

    print("=== 1. Skalyar broadcasting ===")
    print(f"  a + 100 = {(a + 100).tolist()}")

    print("\n=== 2. Qator broadcasting (2,3)+(3,) ===")
    qator = np.array([10, 20, 30])
    print(f"  a + {qator} =")
    print(f"    {(a + qator).tolist()}")

    print("\n=== 3. Ustun broadcasting (2,3)+(2,1) ===")
    ustun = np.array([[100], [200]])
    print(f"  a + ustun =")
    print(f"    {(a + ustun).tolist()}")

    print("\n=== 4. Amaliy: har ustunni koeffitsientga ko'paytirish ===")
    koef = np.array([1, 10, 100])
    print(f"  a * koef = {(a * koef).tolist()}")
    print("  ⭐ broadcasting — kichik massiv kattasiga moslanadi (nusxasiz)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Skalyar broadcasting ===
  a + 100 = [[101, 102, 103], [104, 105, 106]]

=== 2. Qator broadcasting (2,3)+(3,) ===
  a + [10 20 30] =
    [[11, 22, 33], [14, 25, 36]]

=== 3. Ustun broadcasting (2,3)+(2,1) ===
  a + ustun =
    [[101, 102, 103], [204, 205, 206]]

=== 4. Amaliy: har ustunni koeffitsientga ko'paytirish ===
  a * koef = [[1, 20, 300], [4, 50, 600]]
  ⭐ broadcasting — kichik massiv kattasiga moslanadi (nusxasiz)

Nima ko'rsatdi: 2.1, 2.2-bo'limlar.

Misol 2 — Matematik funksiyalar

python
"""matematik ufunc: sqrt/exp/log/sin — har elementga vektorlangan; round/abs."""

import numpy as np


def main() -> None:
    print("=== 1. sqrt (kvadrat ildiz) ===")
    x = np.array([1, 4, 9, 16, 25])
    print(f"  sqrt({x.tolist()}) = {np.sqrt(x).tolist()}")

    print("\n=== 2. exp / log ===")
    print(f"  exp([0,1,2]) = {np.round(np.exp(np.array([0, 1, 2])), 4).tolist()}")
    print(f"  log([1,e,e^2]) = {np.round(np.log(np.array([1.0, np.e, np.e**2])), 4).tolist()}")

    print("\n=== 3. Trigonometriya (sin, cos) ===")
    burchak = np.array([0, np.pi / 2, np.pi])
    print(f"  sin = {np.round(np.sin(burchak), 4).tolist()}")
    print(f"  cos = {np.round(np.cos(burchak), 4).tolist()}")

    print("\n=== 4. abs / round ===")
    y = np.array([-1.567, 2.891, -3.234])
    print(f"  abs = {np.abs(y).tolist()}")
    print(f"  round(1) = {np.round(y, 1).tolist()}")
    print("  ⭐ ufunc — matematik funksiya butun massivga (vektorlangan)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. sqrt (kvadrat ildiz) ===
  sqrt([1, 4, 9, 16, 25]) = [1.0, 2.0, 3.0, 4.0, 5.0]

=== 2. exp / log ===
  exp([0,1,2]) = [1.0, 2.7183, 7.3891]
  log([1,e,e^2]) = [0.0, 1.0, 2.0]

=== 3. Trigonometriya (sin, cos) ===
  sin = [0.0, 1.0, 0.0]
  cos = [1.0, 0.0, -1.0]

=== 4. abs / round ===
  abs = [1.567, 2.891, 3.234]
  round(1) = [-1.6, 2.9, -3.2]
  ⭐ ufunc — matematik funksiya butun massivga (vektorlangan)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — where, clip, to'plovchi amallar

python
"""where (shartli tanlash); clip (cheklash); cumsum (jamlanma); dot (skalyar ko'paytma)."""

import numpy as np


def main() -> None:
    print("=== 1. where (shartli tanlash) ===")
    x = np.array([-2, 5, -8, 3, -1])
    print(f"  x = {x.tolist()}")
    print(f"  where(x>0, x, 0) = {np.where(x > 0, x, 0).tolist()}")
    print(f"  where(x>0, 'musbat', 'manfiy') = {np.where(x > 0, 1, -1).tolist()}")

    print("\n=== 2. clip (oraliqda cheklash) ===")
    baholar = np.array([45, 105, 88, -10, 72])
    print(f"  clip(0, 100) = {np.clip(baholar, 0, 100).tolist()}")

    print("\n=== 3. cumsum / cumprod (jamlanma) ===")
    a = np.array([1, 2, 3, 4, 5])
    print(f"  cumsum = {a.cumsum().tolist()}")
    print(f"  cumprod = {a.cumprod().tolist()}")

    print("\n=== 4. dot (skalyar ko'paytma) ===")
    narx = np.array([100, 50, 200])
    soni = np.array([2, 3, 1])
    print(f"  narx·soni (jami) = {narx.dot(soni)}")
    print("  ⭐ where/clip/cumsum/dot — vektorlangan foydali amallar")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. where (shartli tanlash) ===
  x = [-2, 5, -8, 3, -1]
  where(x>0, x, 0) = [0, 5, 0, 3, 0]
  where(x>0, 'musbat', 'manfiy') = [-1, 1, -1, 1, -1]

=== 2. clip (oraliqda cheklash) ===
  clip(0, 100) = [45, 100, 88, 0, 72]

=== 3. cumsum / cumprod (jamlanma) ===
  cumsum = [1, 3, 6, 10, 15]
  cumprod = [1, 2, 6, 24, 120]

=== 4. dot (skalyar ko'paytma) ===
  narx·soni (jami) = 550
  ⭐ where/clip/cumsum/dot — vektorlangan foydali amallar

Nima ko'rsatdi: 2.4, 2.5-bo'limlar.

Misol 4 — Amaliy: sotuv jadvali tahlili

Real misol: 3 mahsulot × 4 oy sotuv jadvali — broadcasting (narx qo'llash), axis agregat (jami), statistika. Bu — jadval hisoblashning namunasi.

python
"""to'liq jadval tahlil: 2D sotuv, broadcasting (narx), axis agregat (oy/mahsulot jami), where."""

import numpy as np


def main() -> None:
    # 3 mahsulot (qator) × 4 oy (ustun) — sotilgan dona
    sotuv = np.array([
        [10, 15, 12, 20],    # Python kursi
        [5, 8, 6, 10],       # Kitob
        [20, 25, 22, 30],    # Video
    ])
    narx = np.array([[100], [50], [30]])   # har mahsulot narxi (ustun)

    print("=== 1. Daromad (broadcasting: dona × narx) ===")
    daromad = sotuv * narx
    print(f"  {daromad.tolist()}")

    print("\n=== 2. Har mahsulot jami (axis=1 — qatorlar) ===")
    mahsulot_jami = daromad.sum(axis=1)
    print(f"  mahsulot bo'yicha: {mahsulot_jami.tolist()}")

    print("\n=== 3. Har oy jami (axis=0 — ustunlar) ===")
    oy_jami = daromad.sum(axis=0)
    print(f"  oy bo'yicha: {oy_jami.tolist()}")

    print("\n=== 4. Statistika va eng yaxshi oy ===")
    print(f"  umumiy daromad: {daromad.sum()}")
    print(f"  o'rtacha oylik: {oy_jami.mean()}")
    print(f"  eng yaxshi oy (indeks): {int(oy_jami.argmax())}, qiymat: {oy_jami.max()}")
    print("  ⭐ broadcasting + axis — jadval tahlilining asosi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Daromad (broadcasting: dona × narx) ===
  [[1000, 1500, 1200, 2000], [250, 400, 300, 500], [600, 750, 660, 900]]

=== 2. Har mahsulot jami (axis=1 — qatorlar) ===
  mahsulot bo'yicha: [5700, 1450, 2910]

=== 3. Har oy jami (axis=0 — ustunlar) ===
  oy bo'yicha: [1850, 2650, 2160, 3400]

=== 4. Statistika va eng yaxshi oy ===
  umumiy daromad: 10060
  o'rtacha oylik: 2515.0
  eng yaxshi oy (indeks): 3, qiymat: 3400
  ⭐ broadcasting + axis — jadval tahlilining asosi

Nima ko'rsatdi: 2.1–2.8-bo'limlar.


5. To'g'ri va noto'g'ri tushunishlar

Noto'g'ri fikr To'g'risi
"Har xil shaklda amal xato" Broadcasting (mos bo'lsa)
"Broadcasting nusxalaydi" Mantiqan (xotira kam)
"Shakl har doim teng bo'lsin" Teng yoki 1 (broadcasting)
"sqrt bir songa" Butun massivga (ufunc)
"where — sikl" Vektorlangan shart
"axis=0 qatorlar" Ustunlar (pastga)
"dot — element ko'paytma" Skalyar/matritsa ko'paytma
"Broadcasting sekin" Tez (nusxasiz)

6. Keng tarqalgan xatolar va yechimlari

1. Mos kelmaydigan shakl (broadcast xato)

python
np.array([[1,2,3]]) + np.array([1,2])   # ⚠️ (1,3)+(2,) xato
# shaklni to'g'rila (reshape yoki mos)    # ✅

2. Ustun broadcast uchun shakl

python
a + np.array([1, 2])                     # ⚠️ (2,3)+(2,) xato
a + np.array([[1], [2]])                 # ✅ (2,1) ustun

3. axis chalkashtirish

python
m.sum(axis=0)  # ustunlar (pastga)
m.sum(axis=1)  # qatorlar (o'ngga)       # ✅ ehtiyot

4. log(0) yoki manfiy ildiz

python
np.log(np.array([0, -1]))                # ⚠️ -inf, nan
# musbat qiymat yoki clip                 # ✅

5. dot shakl mos emas

python
np.array([1,2,3]).dot(np.array([1,2]))   # ⚠️ 3≠2
# ichki o'lcham mos bo'lsin                # ✅

6. whereda massiv shakl mos emas

python
np.where(shart, a, b)  # a, b, shart mos shaklda bo'lsin (yoki broadcast)

7. Butun massivda sqrt (float natija kutmaslik)

python
np.sqrt(np.array([2, 3]))   # float natija (1.41..)  — normal

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 24.1-dars (o'tilgan): NumPy massiv — asos
  • 24.3-dars: Indeks va shakl — kesish
  • 24.4-dars: Unumdorlik — vektorlangan tezlik
  • 24.5-dars: pandas — broadcasting DataFrame'da
  • 25-qism: ML — matritsa amallari (dot)

8. Eng yaxshi amaliyotlar

  1. Har xil shaklda — broadcasting (sikl emas).

  2. Broadcasting qoidasini bil (o'ngdan mos).

  3. Matematik funksiya — np. (butun massiv).

  4. Shartli — np.where (sikl emas).

  5. Cheklov — np.clip.

  6. axisni to'g'ri tanla (0 ustun, 1 qator).

  7. Shakl xatosida reshape bilan to'g'rila.

  8. dot/@ — matritsa ko'paytma (ML).


9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # Broadcasting nima?
2.  # broadcasting qoidasi?
3.  # (2,3)+(3,) — mosmi?
4.  # (2,3)+(2,) — mosmi?
5.  # np.sqrt nima?
6.  # ufunc nima?
7.  # np.where nima?
8.  # np.clip nima?
9.  # cumsum nima?
10. # dot nima?
11. # axis=0 nima?
12. # broadcasting nusxalaydimi?
Javoblar
  1. Har xil shaklda amal (avtomatik moslash)
  2. O'ngdan — teng yoki 1
  3. Ha (qator takror)
  4. Yo'q (o'ng 3≠2)
  5. Kvadrat ildiz (har element)
  6. Universal funksiya (vektorlangan)
  7. Shartli tanlash
  8. Oraliqda cheklash
  9. Jamlanma yig'indi
  10. Skalyar/matritsa ko'paytma
  11. Ustunlar bo'yicha (pastga)
  12. Yo'q (mantiqan — xotira kam)

Vazifa 2: Xatolarni tuzating

python
1.  a + np.array([1, 2])      # (2,3)+(2,)  → ustun

2.  np.log(np.array([0]))     # musbat

3.  # shartli sikl             # np.where

4.  m.sum(axis=1)  # ustun kerak  → axis=0

5.  # har xil shaklda sikl      # broadcasting
Javoblar
python
1.  a + np.array([[1], [2]])   # (2,1)

2.  np.log(np.array([1]))      # musbat

3.  np.where(shart, a, b)

4.  m.sum(axis=0)  # ustunlar

5.  a2d + b1d  # broadcasting

Vazifa 3: Broadcasting

Amal:

  1. Skalyar
  2. Qator (2,3)+(3,)
  3. Ustun (2,3)+(2,1)
  4. Xato holi

Vazifa 4: Matematik funksiyalar

ufunc:

  1. sqrt, exp, log
  2. sin, cos
  3. abs, round
  4. Butun massiv

Vazifa 5: Foydali amallar

Amal:

  1. where (shart)
  2. clip (cheklov)
  3. cumsum
  4. dot

Vazifa 6: Jadval tahlil

2D:

  1. Broadcasting (narx)
  2. axis=0 (ustun)
  3. axis=1 (qator)
  4. Statistika

Vazifa 7: O'ylash

Broadcasting kichik massivni katta massivga avtomatik moslaydi — jismoniy nusxalamasdan (mantiqan takrorlanadi). Bu "hisoblashni ma'lumotga moslash, ma'lumotni ko'chirmaslik" tamoyili. Nima uchun "ortiqcha nusxa yaratmaslik" muhim (xotira va tezlik), va bu vektorlangan fikrlash (sikl o'rniga massiv amali) bilan qanday bog'liq — nega broadcasting kod'ni ham qisqaroq, ham tezroq qiladi?

Javob

Qisqa javob: Broadcasting kichik massivni (masalan, (1000,) qator) katta massivga ((1000, 1000)) jismoniy nusxalamasdan moslaydi — mantiqan takrorlanadi, lekin xotirada bir nusxa. Bu xotira tejaydi (nusxa yo'q — million element takror emas) va tezroq (nusxa ko'chirish vaqti yo'q, amal C darajasida). "Ma'lumotni ko'chirmaslik" muhim, chunki nusxa — xotira (RAM to'lishi) va vaqt (ko'chirish) isrofi. Vektorlangan fikrlash bilan bog'liq: sikl o'rniga butun massiv amali — broadcasting shu fikrning davomi (har xil shakl ham). Kod qisqa (bir qator — a * koef, sikl yo'q) va tez (C, nusxasiz). "Nima qilish kerakligini ayt, qanday emas" (deklarativ).

1. Nusxasiz moslash

Broadcasting mantiqan takrorlaydi (qator har qatorda), lekin jismoniy nusxa yo'q (xotirada bir marta). (1000, 1000) jadvalga (1000,) qator — qatorni 1000 marta nusxalamasdan.

2. Nega nusxa yomon

Nusxa bilan Broadcasting
Xotira: N marta Xotira: 1 marta
Vaqt: ko'chirish Vaqt: yo'q
RAM to'lishi mumkin Kam xotira

3. Vektorlangan fikrlash

Sikl (imperativ — "har element uchun...") o'rniga massiv amali (deklarativ — "butun massivga..."). Broadcasting bu fikrni kengaytiradi (har xil shakl ham). Kod qisqa, niyat aniq.

4. Qisqa + tez

  • Qisqa: a * koef (bir qator) vs ikki ichma-ich sikl
  • Tez: C darajasida, nusxasiz
  • Aniq: niyat ko'rinadi (sikl mexanikasi yashirin)

5. Muhandislik saboqlari

  1. Ortiqcha nusxa — xotira va vaqt isrofi
  2. Broadcasting — nusxasiz moslash
  3. Vektorlangan — sikl o'rniga massiv amali
  4. Deklarativ — qisqa, tez, aniq

6. Xulosa

  1. Broadcasting nusxasiz moslaydi (xotira tejaydi)
  2. Tez (ko'chirish yo'q, C daraja)
  3. Vektorlangan fikrlash davomi
  4. Kod qisqa va tez

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.


Xulosa

Bu darsda broadcasting va NumPy amallarini o'rgandik.

Eng muhim uch fikr:

  1. Broadcasting — har xil shaklda amal. Broadcasting — NumPy har xil shakldagi massivlar ustida amalni avtomatik moslab bajaradi: kichik massivni kattasiga "cho'zib" (jismoniy nusxasiz — xotira kam, tez). Qoida: shakllar o'ngdan chapga solishtiriladi; har o'lchamda o'lchamlar teng yoki bittasi 1 bo'lsa mos (1 bo'lgan tomon takrorlanadi), aks holda xato. a + 10 (skalyar), a2d + qator1d (har qatorga), a2d + ustun.reshape(-1, 1) (har ustunga). Shakl xatosida: "operands could not be broadcast together" — reshape bilan to'g'rila.

  2. Vektorlangan funksiyalar va amallar. Matematik ufunc (universal funksiya) butun massivga: np.sqrt, np.exp, np.log, np.sin/np.cos, np.abs, np.round (har elementga, siklsiz). Foydali amallar: np.where(shart, a, b) (shartli tanlash — sikl o'rniga), np.clip(x, min, max) (oraliqda cheklash), np.maximum/np.minimum. To'plovchi: .cumsum() (jamlanma), .cumprod(), .dot()/@ (skalyar/matritsa ko'paytma — ML), np.diff(). Bular ma'lumot tozalash, statistika, ML da kundalik.

  3. axis va broadcasting foydasi. 2D agregat axis bilan: axis=0 (ustunlar bo'yicha — pastga, har ustun uchun natija), axis=1 (qatorlar bo'yicha — o'ngga, har qator uchun). Broadcasting xotira va vaqt tejaydi: kichik massivni jismoniy nusxalamasdan (mantiqan takror) — "hisoblashni ma'lumotga moslash, ma'lumotni ko'chirmaslik" tamoyili. Kod qisqa (bir qator, sikl yo'q) va tez (C darajasi, nusxasiz). Broadcasting va vektorlangan fikrlash — NumPy ustasi bo'lishning kaliti.

Keyingi darsda NumPy indeks va shakl ni o'rganamiz: massivni kesish (slicing), bool indeks, fancy indeks — ma'lumotning kerakli qismini tanlash.

Malumot tahlili · 2-dars yakunlandi

24.2-dars: NumPy — amallar va broadcasting

16 daqvaqt
0belgi
Keyingi dars: 24.3-dars: NumPy — indeks va shakl
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0