2.5-dars: Vektorlashtirilgan amallar

2-QISM — NUMPY · 5-dars

1. Kirish va motivatsiya

Endi NumPy'ning eng kuchli qismiga yetdik: vektorlashtirilgan amallar. Oddiy Python'da 1000 ta sonni 2 ga ko'paytirish uchun sikl yozasiz (for son in ro'yxat: ...). NumPy'da esa faqat a * 2 — butun massiv bir vaqtda ko'payadi, siklsiz. Bu — vektorlashtirish (vectorization): amalni har elementga alohida emas, butun massivga birdaniga qo'llash. Nega muhim? (1) Tezlik — NumPy amallari C tilida bajariladi, Python siklidan 10-100 barobar tez; (2) Soddalik — a + b bitta qator, sikl esa 4 qator; (3) Data Science asosi — million qatorli ma'lumotni sikl bilan ishlab bo'lmaydi (sekin), vektorlashtirish shart. Bu dars vektorlashtirishni chuqur o'rgatadi — NumPy tezligining asosi va Data Science ishining yuragi.

Vektorlashtirilgan amallar — butun massivga bir vaqtda amal (siklsiz): element-wise (har element — a + b, a * 2, a ** 2), skalyar (massiv × son — a * 2 har elementni), massiv × massiv (a + b — mos elementlar), matematik funksiyalar (np.sqrt, np.exp, np.log — butun massivga), taqqoslash (a > 5 — bool massiv), tezlik (C tilida — sikldan 10-100x). Foydalanish: tez hisob, sodda kod, katta ma'lumot. Bu 2.1 (ndarray), 2.12 (tezlik) bilan bog'liq. Vektorlashtirish — siklsiz, butun massiv. Tez. Sodda.

Real vaziyat. Data Scientist 1 million narxni 20% chegirma qilmoqchi edi. Oddiy Python: for i in range(len(narx)): natija.append(narx[i] * 0.8) — sikl, sekin (bir necha soniya). NumPy: natija = narx * 0.8 — bir qator, siklsiz, C tilida (bir zumda — 50x tez). Keyin ikki ustunni qo'shdi (jami = narx + soliq) — element-wise (mos elementlar). Kvadrat ildiz (np.sqrt(qiymatlar)) — butun massivga. Vektorlashtirish tez va sodda (sikl yo'q, C tezligi). Bu — NumPy'ning asosiy sababi (nega NumPy — 2.1). Vektorlashtirish — Data Science yuragi.

Bu darsda vektorlashtirilgan amallarni o'rganamiz.

Bu darsda:

• Element-wise amallar
• Skalyar amallar (massiv × son)
• Massiv × massiv
• Matematik funksiyalar
• Taqqoslash (bool massiv)
• Vektorlashtirish tezligi
• Vektorlashtirish tuzoqlari
• Amaliy: vektor modeli

ℹ Misollar real numpy bilan (deterministik) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. Element-wise amallar

Har elementga bir vaqtda:

import numpy as np

a = np.array([1, 2, 3, 4])

a + 10      # [11 12 13 14] (har elementga +10)
a * 2       # [2 4 6 8] (har element × 2)
a ** 2      # [1 4 9 16] (har element kvadrat)
a - 1       # [0 1 2 3]
a / 2       # [0.5 1.  1.5 2. ]

Element-wise amallar — har elementga bir vaqtda (siklsiz): a + 10 (har elementga +10), a * 2 (har × 2), a ** 2 (har kvadrat). Sabab: amalni butun massivga birdaniga (element-wise — har element mustaqil, lekin bir buyruq); Python sikl kerak emas (for yo'q — NumPy avtomatik har elementga); C tilida (tez). "Element-wise" = element-bo'yicha (har element alohida, lekin bir amal). Bu vektorlashtirish yuragi. Element-wise — har elementga bir vaqtda (siklsiz). Tez. Sodda.

2.2. Skalyar amallar (massiv × son)

Massiv va bitta son:

narx = np.array([100, 200, 300])

narx * 0.8    # [ 80. 160. 240.] (20% chegirma)
narx + 50     # [150 250 350] (har biriga +50)
narx / 100    # [1. 2. 3.]

# har elementga BIR xil son qo'llanadi

Skalyar amallar (massiv × son) — massiv va bitta son (skalyar): narx * 0.8 (har elementni 0.8 ga — 20% chegirma), narx + 50 (har biriga +50). Sabab: ko'pincha bir xil amal butun massivga (barcha narxga chegirma, barcha qiymatga o'lchov); son har elementga qo'llanadi (narx * 0.8 = har narx × 0.8). "Skalyar" = bitta son (massiv emas). Bu broadcastingning oddiy holati 2.6-bob. Skalyar — massiv × son (har elementga). Bir xil. Qulay.

2.3. Massiv × massiv

Ikki massiv (mos elementlar):

a = np.array([1, 2, 3])
b = np.array([10, 20, 30])

a + b      # [11 22 33] (mos elementlar: 1+10, 2+20, 3+30)
a * b      # [10 40 90] (1*10, 2*20, 3*30)
a - b      # [-9 -18 -27]

# SHART: bir xil shakl (yoki broadcasting — 2.6)

Massiv × massiv — ikki massiv (mos elementlar): a + b (mos: a[0]+b[0], a[1]+b[1], ...), a * b (mos ko'paytma). Sabab: ikki ustunni birlashtirish (narx + soliq = jami; miqdor × narx = summa); amal mos elementlar orasida (bir pozitsiya — a[i] va b[i]). SHART: bir xil shakl (a va b bir o'lcham — aks holda xato yoki broadcasting 2.6). Massiv × massiv — mos elementlar (a[i] va b[i]). Bir xil shakl. Element-wise.

2.4. Matematik funksiyalar

Butun massivga funksiya:

a = np.array([1, 4, 9, 16])

np.sqrt(a)     # [1. 2. 3. 4.] (kvadrat ildiz — har element)
np.exp(a)      # e^x (har element)
np.log(a)      # ln(x) (har element)
np.abs(np.array([-1, -2, 3]))   # [1 2 3] (modul)
np.round(np.array([1.7, 2.3]))  # [2. 2.] (yaxlitlash)

Matematik funksiyalar — butun massivga funksiya (vektorlashtirgan): np.sqrt (kvadrat ildiz — har element), np.exp (e^x), np.log (ln), np.abs (modul), np.round (yaxlitlash); barchasi har elementga (siklsiz). Sabab: matematik amal ko'pincha butun massivga (barcha qiymat ildizi, log — ma'lumot o'zgartirish, ML tayyorgarlik); NumPy funksiyalari (np.*) vektorlashtirilgan (har elementga — tez, siklsiz). Python math.sqrt — bitta son (massivga ishlamaydi); np.sqrt — butun massiv. Matematik funksiyalar — butun massivga (np.sqrt, np.exp). Vektorlashtirilgan. Har element.

2.5. Taqqoslash (bool massiv)

Shart — bool massiv:

a = np.array([1, 5, 3, 8, 2])

a > 3       # [False True False True False] (har element > 3?)
a == 5      # [False True False False False]
a <= 2      # [ True False False False  True]

(a > 3).sum()   # 2 (nechta True — shart bajarganlar soni)

Taqqoslash (bool massiv) — shart har elementga: a > 3 (har element 3 dan katta-mi — bool massiv [False, True, ...]), a == 5, a <= 2. Sabab: shartni butun massivga (qaysi elementlar shart bajaradi — filtr, tanlash); natija bool massiv (har element uchun True/False). .sum() bool massivda = True soni ((a > 3).sum() = shart bajarganlar soni — True=1). Bu boolean indekslashga zamin (2.9 — a[a > 3] shart bo'yicha tanlash). Taqqoslash — bool massiv (a > 3). Har element. Filtrga zamin.

2.6. Vektorlashtirish tezligi

Vektorlashtirish tezligi — nega tez: (1) C tilida — NumPy amallari C tilida bajariladi (Python emas — C tez, mashinaga yaqin); Python sikl sekin (interpretator — har qadam tekshirish); (2) siklsiz — a * 2 bir buyruq (C ichida sikl — tez), Python for million marta (sekin); (3) 10-100x tez — vektorlashtirilgan amal Python sikldan o'nlab-yuzlab marta tez (katta massivda farq katta); (4) xotira ketma-ket — ndarray uzluksiz (2.1 — kesh do'st, tez o'qish). Sabab: NumPy tezlik uchun yaratilgan (2.1 — nega NumPy); vektorlashtirish bu tezlikni ochadi (sikl — sekin, vektor — tez). Data Science'da million qator — sikl mumkin emas (sekin), vektorlashtirish shart. Tezlik — C tilida, siklsiz (10-100x). Katta ma'lumot. Shart.

2.7. Vektorlashtirish tuzoqlari

Vektorlashtirish asosiy tuzoqlari: sikl ishlatish (for bilan har element — sekin; vektorlashtir — a * 2); shakl mos emas (a + b turli shakl — xato yoki kutilmagan broadcasting; tekshir 2.3); np. unutish (math.sqrt(massiv) xato — Python math bitta son; np.sqrt butun massiv); butun bo'lish (int massiv / — float natija, // butun); skalyar chalkash (a * b element-wise, matritsa ko'paytmasi emas — u @ yoki np.dot, 2.11); bool arifmetika ((a > 3) bool, .sum() True soni — foydali lekin bilish kerak); element-wise deb o'ylash (a * b element-wise — ba'zan matritsa kutiladi, xato natija). Sabab: vektorlashtirish kuchli lekin nozik (shakl, np., element-wise — xato jim). Yechim: siklsiz, np. funksiya, shakl tekshir, element-wise vs matritsa bil. Tuzoqlar — sikl, shakl, np., element-wise.

2.8. Vektorlashtirish — NumPy yuragi

Vektorlashtirish asosiy g'oyasi — NumPy yuragi: amalni har elementga alohida (sikl) emas, butun massivga bir vaqtda (siklsiz — a * 2, a + b); bu NumPy'ning asosiy kuchi (nega NumPy — 2.1). Ikki foyda: tezlik (C tilida — Python sikldan 10-100x tez; million qator — sikl mumkin emas, vektor shart) va soddalik (a + b bir qator, sikl 4 qator — o'qilishli). Element-wise (har element), skalyar (massiv × son), massiv × massiv (mos elementlar), matematik funksiyalar (np.sqrt — butun massivga), taqqoslash (a > 3 — bool massiv). Data Science yuragi — ma'lumot doim vektorlashtirilgan (million qatorga amal — tez, sodda). "Sikl yozmang, vektorlashtiring" — NumPy qoidasi. Bu 2.1 (ndarray) kuchi va butun Data Science asosi (Pandas, ML — vektorlashtirilgan). Vektorlashtirish — NumPy yuragi (siklsiz, butun massiv, tez, sodda). Data Science asosi.

3. Tez ma'lumotnoma

import numpy as np
a = np.array([1, 2, 3, 4])
b = np.array([10, 20, 30, 40])

# ELEMENT-WISE (har element, siklsiz):
a + 10       # [11 12 13 14]
a * 2        # [2 4 6 8]
a ** 2       # [1 4 9 16]

# SKALYAR (massiv × son):
a * 0.8      # har elementni 0.8 ga

# MASSIV × MASSIV (mos elementlar, bir xil shakl):
a + b        # [11 22 33 44] (a[i]+b[i])
a * b        # [10 40 90 160]

# MATEMATIK FUNKSIYALAR (np. — butun massiv):
np.sqrt(a)   # kvadrat ildiz (har element)
np.exp(a)    # e^x · np.log(a) — ln · np.abs — modul

# TAQQOSLASH (bool massiv):
a > 2        # [False False True True]
(a > 2).sum()  # 2 (True soni)

QOIDA: siklsiz (a*2) · np.sqrt (math emas) · bir xil shakl

Vektorlashtirish xulosasi

Vektorlashtirish — NumPy yuragi (siklsiz, butun massiv)
Element-wise — har elementga bir vaqtda (a * 2)
Skalyar — massiv × son (narx * 0.8)
Massiv × massiv — mos elementlar (a + b, bir xil shakl)
Tezlik — C tilida (sikldan 10-100x) · sodda (bir qator)

4. Batafsil misollar

Misollar real numpy bilan (deterministik) ishlaydi.

Misol 1 — Element-wise va skalyar

"""Element-wise va skalyar amallar (real numpy)."""

import numpy as np


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

    print("=== 1. Element-wise ===")
    print(f"  a + 10: {a + 10}")
    print(f"  a * 2: {a * 2}")
    print(f"  a ** 2: {a ** 2}")

    print("\n=== 2. Skalyar (chegirma) ===")
    narx = np.array([100, 200, 300])
    print(f"  narx * 0.8: {narx * 0.8} (20% chegirma)")

    print("\n=== 3. Bo'lish ===")
    print(f"  a / 2: {a / 2}")

    print("\n=== 4. Tushuntirish ===")
    print("  har elementga bir vaqtda (siklsiz)")
    print("  ⭐ Element-wise — NumPy yuragi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Element-wise ===
  a + 10: [11 12 13 14]
  a * 2: [2 4 6 8]
  a ** 2: [ 1  4  9 16]

=== 2. Skalyar (chegirma) ===
  narx * 0.8: [ 80. 160. 240.] (20% chegirma)

=== 3. Bo'lish ===
  a / 2: [0.5 1.  1.5 2. ]

=== 4. Tushuntirish ===
  har elementga bir vaqtda (siklsiz)
  ⭐ Element-wise — NumPy yuragi

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

Misol 2 — Massiv × massiv

"""Massiv × massiv: mos elementlar (real numpy)."""

import numpy as np


def main() -> None:
    a = np.array([1, 2, 3])
    b = np.array([10, 20, 30])

    print("=== 1. Qo'shish ===")
    print(f"  a + b: {a + b} (mos: 1+10, 2+20, 3+30)")

    print("\n=== 2. Ko'paytirish ===")
    print(f"  a * b: {a * b} (mos ko'paytma)")

    print("\n=== 3. Real: jami narx ===")
    narx = np.array([100, 200, 300])
    soliq = np.array([12, 24, 36])
    print(f"  narx + soliq: {narx + soliq} (jami)")

    print("\n=== 4. Real: summa ===")
    miqdor = np.array([2, 3, 1])
    print(f"  miqdor * narx: {miqdor * narx} (summa)")
    print("  ⭐ Massiv × massiv — mos elementlar")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Qo'shish ===
  a + b: [11 22 33] (mos: 1+10, 2+20, 3+30)

=== 2. Ko'paytirish ===
  a * b: [10 40 90] (mos ko'paytma)

=== 3. Real: jami narx ===
  narx + soliq: [112 224 336] (jami)

=== 4. Real: summa ===
  miqdor * narx: [200 600 300] (summa)
  ⭐ Massiv × massiv — mos elementlar

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — Matematik funksiyalar

"""Matematik funksiyalar: butun massivga (real numpy)."""

import numpy as np


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

    print("\n=== 2. Modul ===")
    b = np.array([-1, -2, 3, -4])
    print(f"  np.abs(b): {np.abs(b)}")

    print("\n=== 3. Yaxlitlash ===")
    c = np.array([1.7, 2.3, 3.5])
    print(f"  np.round(c): {np.round(c)}")

    print("\n=== 4. Logarifm ===")
    d = np.array([1.0, np.e, np.e ** 2])
    print(f"  np.log(d): {np.round(np.log(d), 1)}")
    print("  ⭐ Matematik funksiyalar — butun massivga (np.)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Kvadrat ildiz ===
  np.sqrt(a): [1. 2. 3. 4.]

=== 2. Modul ===
  np.abs(b): [1 2 3 4]

=== 3. Yaxlitlash ===
  np.round(c): [2. 2. 4.]

=== 4. Logarifm ===
  np.log(d): [0. 1. 2.]
  ⭐ Matematik funksiyalar — butun massivga (np.)

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — Taqqoslash (bool massiv)

"""Taqqoslash: bool massiv (real numpy)."""

import numpy as np


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

    print("=== 1. Taqqoslash ===")
    print(f"  a > 3: {a > 3}")
    print(f"  a == 5: {a == 5}")

    print("\n=== 2. Shart bajarganlar soni ===")
    print(f"  (a > 3).sum(): {(a > 3).sum()} (True soni)")

    print("\n=== 3. Barchasi / birortasi ===")
    print(f"  (a > 0).all(): {(a > 0).all()} (barchasi > 0?)")
    print(f"  (a > 7).any(): {(a > 7).any()} (birortasi > 7?)")

    print("\n=== 4. Tushuntirish ===")
    print("  taqqoslash → bool massiv (har element)")
    print("  ⭐ Taqqoslash — filtrga zamin 2.9-bob")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Taqqoslash ===
  a > 3: [False  True False  True False]
  a == 5: [False  True False False False]

=== 2. Shart bajarganlar soni ===
  (a > 3).sum(): 2 (True soni)

=== 3. Barchasi / birortasi ===
  (a > 0).all(): True (barchasi > 0?)
  (a > 7).any(): True (birortasi > 7?)

=== 4. Tushuntirish ===
  taqqoslash → bool massiv (har element)
  ⭐ Taqqoslash — filtrga zamin (2.9)

Nima ko'rsatdi: 2.5-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. Sikl ishlatish

for i in range(len(a)): natija[i] = a[i] * 2   # sekin      # ⚠️
natija = a * 2   # vektorlashtir (tez, sodda)                 # ✅

2. math funksiyasi

import math; math.sqrt(massiv)   # xato (bitta son)          # ⚠️
np.sqrt(massiv)   # butun massiv                              # ✅

3. Shakl mos emas

np.array([1,2,3]) + np.array([1,2])   # xato (turli shakl)   # ⚠️
# bir xil shakl (yoki broadcasting 2.6)                        # ✅

4. Element-wise vs matritsa

a * b   # element-wise (mos elementlar)                      # ⚠️
a @ b   # matritsa ko'paytmasi 2.11-bob                          # ✅

5. Butun bo'lish

np.array([1,2,3]) / 2   # float [0.5 1. 1.5]                 # ⚠️
np.array([1,2,3]) // 2  # butun [0 1 1]                        # ✅

6. Bool tushunmaslik

a > 3   # bool massiv (bitta javob emas)                     # ⚠️
(a > 3).sum()   # True soni                                    # ✅

7. Natijani saqlamaslik

a * 2   # a o'zgarmaydi (yangi qaytadi)                       # ⚠️
a = a * 2   # natijani saqla                                   # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 2.1-dars (o'tilgan): ndarray
• 2.6-dars: Broadcasting (turli shakl)
• 2.9-dars: Shart va tanlash (bool indeks)
• 3-qism: Pandas (ustun amallari — vektorlashtirilgan)
• 20-qism: ML (xususiyat muhandisligi — vektor amallar)

8. Eng yaxshi amaliyotlar

1. Siklsiz (a * 2, a + b) — vektorlashtir.

2. np. funksiyalar (math emas — butun massiv).

3. Bir xil shakl (massiv × massiv).

4. Element-wise vs matritsa (* vs @).

5. Natijani saqla (a = a * 2).

6. Taqqoslash → bool massiv (.sum() True soni).

7. Katta ma'lumot — vektor (sikl mumkin emas).

8. Vektorlashtirish — NumPy yuragi (tez, sodda).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # a * 2 nima?
2.  # sikl kerakmi?
3.  # vektor tez yoki sekin?
4.  # nega tez?
5.  # narx * 0.8 nima?
6.  # a + b sharti?
7.  # a * b element-wise yoki matritsa?
8.  # np.sqrt vs math.sqrt?
9.  # a > 3 natijasi?
10. # (a > 3).sum() nima?
11. # a * 2 asl o'zgartiradimi?
12. # nega vektor sodda?

Vazifa 2: Xatolarni tuzating

1.  for i in range(len(a)): b[i] = a[i]*2   # sikl

2.  math.sqrt(massiv)   # bitta son

3.  a + b   # turli shakl

4.  a * b   # matritsa kutish

5.  a * 2   # asl o'zgaradi deb

1.  b = a * 2   # vektorlashtir

2.  np.sqrt(massiv)

3.  bir xil shakl (yoki broadcasting)

4.  a @ b   # matritsa (2.11)

5.  a = a * 2   # natijani saqla

Vazifa 3: Element-wise

Modellang:

1. Skalyar
2. Massiv×massiv
3. Siklsiz
4. Har element

Vazifa 4: Funksiyalar

Modellang:

1. sqrt
2. exp
3. np. usuli
4. Butun massiv

Vazifa 5: Taqqoslash

Modellang:

1. Bool massiv
2. sum
3. all/any
4. Filtrga zamin

Vazifa 6: Tezlik

Modellang:

1. C tilida
2. Siklsiz
3. 10-100x
4. Katta ma'lumot

Vazifa 7: O'ylash

Vektorlashtirish (a * 2) Python siklidan (for son in a) 10-100 barobar tez, garchi ikkalasi ham "har elementni 2 ga ko'paytiradi". Nima uchun aynan C tilida bajarilishi va "sikl NumPy ichida" bo'lishi bunday katta tezlik farqini beradi, va nega bu Data Science uchun "sikl yozmaslik" qoidasini muhim qiladi?

Nimani mustahkamlaydi: 2.6, 2.7-bo'limlar.

Xulosa

Bu darsda vektorlashtirilgan amallarni o'rgandik.

Eng muhim uch fikr:

1. Element-wise va skalyar. Element-wise — amal har elementga bir vaqtda (siklsiz): a + 10, a * 2, a ** 2 (har element mustaqil, bir buyruq — C tilida). Skalyar (massiv × son) — bitta son har elementga (narx * 0.8 = 20% chegirma — har narxga). Python sikl kerak emas (NumPy avtomatik har elementga — tez, sodda).

2. Massiv × massiv va funksiyalar. Massiv × massiv — mos elementlar (a + b = a[i]+b[i], a * b = mos ko'paytma); SHART bir xil shakl (yoki broadcasting 2.6); a * b element-wise (matritsa emas — u @, 2.11). Matematik funksiyalar — np.sqrt, np.exp, np.log, np.abs (butun massivga — vektorlashtirilgan; np. — Python math bitta son). Taqqoslash — a > 3 (bool massiv — har element), (a > 3).sum() (True soni); boolean indeksga zamin 2.9-bob.

3. NumPy yuragi. Tezlik — vektorlashtirish C tilida (Python sikldan 10-100x tez — interpretator, obyekt, overhead siklda; C, xom son, uzluksiz xotira vektorda); million qator — sikl mumkin emas, vektor shart. Soddalik — a + b bir qator (sikl 4 qator). Vektorlashtirish — NumPy yuragi (siklsiz, butun massivga bir vaqtda — tez va sodda); Data Science asosi ("sikl yozmang, vektorlashtiring"); butun ekotizim (Pandas, sklearn) vektorlashtirilgan.

Keyingi darsda broadcastingni o'rganamiz: turli shakldagi massivlar qanday birlashadi — NumPy'ning eng chiroyli va kuchli mexanizmi.