2.1-dars: NumPy nima va massiv (ndarray)

2-QISM — NUMPY · 1-dars

1. Kirish va motivatsiya

Kirish qismini tugatdik — endi amaliy Data Science boshlanadi. Va u NumPy dan boshlanadi. NumPy (Numerical Python) — Data Science'ning sonli poydevori: pandas, scikit-learn, torch — hammasi NumPy ustiga qurilgan. Uning yuragi — ndarray (N-o'lchamli massiv): bir turdagi sonlarning tez, ixcham to'plami. Nega oddiy Python ro'yxati (list) yetmaydi? Chunki NumPy massivi 100 barobar tezroq va kam xotira ishlatadi — million sonni qo'shishni Python sikli 1 soniyada, NumPy 0.01 soniyada bajaradi. Bu tezlik sirri — vektorlashtirish (butun massivga bir amal, sikl yo'q). Bu dars NumPy nima ekanini, ndarray ni va u nega Python ro'yxatidan yaxshiroq ekanini ko'rsatadi. NumPy — Data Science tezligining asosi.

NumPy (Numerical Python) — sonli hisoblash uchun asosiy kutubxona: ndarray (N-o'lchamli massiv — bir turdagi sonlar to'plami, ixcham va tez), vektorlashtirilgan amallar (butun massivga bir amal — sikl yo'q, tez), kam xotira (list'dan ixcham), tezlik (C darajasida — Python sikldan 100x), poydevor (pandas, sklearn, torch — hammasi NumPy ustiga). Foydalanish: ma'lumot hisobi, matritsa, ML asosi. Bu Data Science yadrosi. Bu 1.2 (kutubxonalar), 3-qism (Pandas) uchun poydevor. NumPy — ndarray, vektorlashtirish. Tez, ixcham. Poydevor.

Real vaziyat. Data Scientist million sonli narxi 20% oshirishi kerak edi. Oddiy Python bilan: for narx in narxlar: yangi.append(narx * 1.2) — sikl, sekin (1 soniya), ko'p xotira. NumPy bilan: narxlar * 1.2 — butun massivga bir amal (sikl yo'q), tez (0.01 soniya — 100x tez), kam xotira. Kod ham soddaroq (bir qator). Million emas, milliardda farq keskin. Data Scientist NumPy ishlatdi — tez, sodda, samarali. NumPy — vektorlashtirish (sikl o'rniga).

Bu darsda NumPy va ndarray ni o'rganamiz.

Bu darsda:

• NumPy nima
• ndarray (massiv)
• Massiv vs Python ro'yxati
• Vektorlashtirish (sikl yo'q)
• Nega NumPy tez
• NumPy amaliyoti
• NumPy tuzoqlari
• Amaliy: NumPy modeli

ℹ Misollar real numpy bilan (deterministik) ishlaydi. numpy import qilinadi: import numpy as np.

2. Nazariya — chuqur tushuntirish

2.1. NumPy nima

Sonli hisoblash poydevori:

import numpy as np           # standart nom: np

# ndarray yaratish
a = np.array([1, 2, 3, 4, 5])
print(a)                     # [1 2 3 4 5]
print(type(a))               # <class 'numpy.ndarray'>

# vektorlashtirilgan amal (butun massivga)
print(a * 2)                 # [2 4 6 8 10] — sikl yo'q!

NumPy (Numerical Python) — sonli hisoblash uchun asosiy kutubxona (import numpy as np — standart nom): ndarray (massiv — 2.2), vektorlashtirilgan amallar (butun massivga — 2.4), tez (C darajasida — 2.5). Sabab: Data Science ko'p son bilan ishlaydi (million narx, piksel, o'lchov); oddiy Python sekin (sikl — har son alohida); NumPy tez (vektorlashtirish — butun massivga bir amal, C da). NumPy poydevor (pandas DataFrame — NumPy massiv ustiga, sklearn/torch — NumPy). Har Data Scientist NumPy biladi (asos). np konvensiya (hamma ishlatadi). NumPy — sonli hisoblash. Massiv, vektorlashtirish. Poydevor.

2.2. ndarray (massiv)

Bir turdagi sonlar to'plami:

# 1-o'lchamli (vektor)
a = np.array([1, 2, 3])

# 2-o'lchamli (matritsa)
b = np.array([[1, 2, 3],
              [4, 5, 6]])

# atributlar
b.shape      # (2, 3) — 2 qator, 3 ustun
b.ndim       # 2 — o'lchamlar soni
b.dtype      # int64 — element turi
b.size       # 6 — jami elementlar

ndarray (N-dimensional array — massiv) — NumPy'ning yuragi: bir turdagi sonlar to'plami (hammasi int yoki hammasi float — list'dan farqi), N-o'lchamli (1D — vektor, 2D — matritsa, 3D+ — tensor). Atributlar: shape (o'lcham — (2, 3) = 2 qator × 3 ustun), ndim (o'lchamlar soni), dtype (element turi — int64, float64), size (jami element). Sabab: bir tur — ixcham, tez (aralash emas — bir xil xotira); N-o'lcham — ma'lumot tabiiy (rasm — 2D piksel, video — 3D). Data Science ma'lumoti ndarray (jadval — 2D, rasm — 3D). ndarray — bir tur, N-o'lcham. shape, dtype. Yurak.

2.3. Massiv vs Python ro'yxati

Nega ro'yxat yetmaydi:

PYTHON RO'YXATI (list):          NUMPY MASSIVI (ndarray):
   [1, 2, "matn", 3.5]              [1, 2, 3, 4] (bir tur)
   turli tur (moslashuvchan)         bir tur (tez, ixcham)
   sikl kerak (for)                  vektorlashtirish (sikl yo'q)
   ko'p xotira                       kam xotira (ixcham)
   sekin                             100x tez (C)

   → son hisoblash uchun: NumPy massivi

Massiv vs Python ro'yxati — nega ndarray yaxshiroq (son uchun): list (turli tur — [1, "matn", 3.5], moslashuvchan; lekin sekin — har element obyekt, sikl kerak, ko'p xotira), ndarray (bir tur — [1,2,3,4], tez/ixcham; vektorlashtirish — sikl yo'q; 100x tez — C). Sabab: list umumiy (har narsa — moslashuvchan, lekin sekin); ndarray son uchun (bir tur — ixcham, C da tez). Data Science son bilan (million — tezlik muhim) → ndarray (list emas). Farq: list — moslashuvchan/sekin, ndarray — bir tur/tez. Son hisoblash → NumPy. Massiv vs list — bir tur vs aralash. Tez vs sekin.

2.4. Vektorlashtirish (sikl yo'q)

Butun massivga bir amal:

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

# VEKTORLASHTIRISH (sikl yo'q):
yangi = narxlar * 1.2           # [120. 240. 360.] — butun massivga

# oddiy Python (sikl — sekin):
# yangi = [narx * 1.2 for narx in narxlar]

# element-wise (har element bilan):
a = np.array([1, 2, 3])
b = np.array([10, 20, 30])
print(a + b)                     # [11 22 33]
print(a * b)                     # [10 40 90]

Vektorlashtirish (vectorization) — NumPy'ning kuchi: butun massivga bir amal (sikl yo'q — narxlar * 1.2 barcha narxga), element-wise (har element bilan — a + b = har juftlik yig'indisi). Sabab: oddiy Python sikl (har element alohida — sekin, ko'p kod); vektorlashtirish butun massivga (bir amal — tez, sodda kod); ichda C sikl (mashina daraja — 100x tez, 2.5). Kod ham sodda (narxlar * 1.2 — bir qator vs sikl). Bu NumPy'ning asosiy g'oyasi (sikl o'rniga — massiv amal). Element-wise (bir xil shakl — har juftlik). Vektorlashtirish — butun massiv, sikl yo'q. Tez, sodda. Element-wise.

2.5. Nega NumPy tez

Ichkarida C:

NEGA NUMPY TEZ:
   1. BIR TUR — bir xil xotira (int64 — 8 bayt har biri)
      → ixcham, tez kirish (Python obyekt emas)
   2. C DA — amal C sikli (mashina kodi, Python emas)
      → 100x tez (Python sikl sekin)
   3. VEKTORLASHTIRISH — bir amal butun massivga
      → sikl yo'q (C ichida)

   million son: Python sikl 1s, NumPy 0.01s

Nega NumPy tez — uch sabab: (1) bir tur (int64 — har biri 8 bayt, bir xil xotira — ixcham, tez kirish; Python obyekt emas — 11-qism Python kursi), (2) C da (amal C sikli — mashina kodi, Python interpretator emas — 100x tez), (3) vektorlashtirish (bir amal butun massivga — sikl C ichida, Python sikl yo'q). Sabab: Python sekin (har son obyekt, sikl interpretatsiya); NumPy tez (bir tur + C + vektorlashtirish). Million son: Python sikl 1s, NumPy 0.01s (100x). Bu Data Science uchun kritik (katta ma'lumot — tezlik). NumPy tez — bir tur, C, vektorlashtirish. 100x. Kritik.

2.6. NumPy amaliyoti

NumPy amaliyoti: import numpy as np (standart nom); ndarray (bir tur — son uchun, list emas); vektorlashtirish (sikl o'rniga — narxlar * 1.2, tez/sodda); shape/dtype tekshir (o'lcham, tur — xato oldini); element-wise (bir xil shakl — a + b); sikl yozma (NumPy amal — sikl sekin); dtype tanla (int64/float64 — xotira/aniqlik); poydevor (pandas/sklearn NumPy ustiga). Tuzoqlar: sikl ishlatish (NumPy borda — sekin; vektorlashtir), aralash tur (bir tur — ndarray), shape mos emas (element-wise — bir xil shakl kerak), Python list bilan aralashtirish (ndarray amallar). Amaliyot — vektorlashtir, shape tekshir, sikl yozma. Tez, sodda.

2.7. NumPy tuzoqlari

NumPy asosiy tuzoqlari: sikl ishlatish (NumPy borda for — sekin, NumPy foydasi yo'q; vektorlashtir); aralash tur (np.array([1, "matn"]) — hammasi satr bo'ladi yoki xato; bir tur); shape mos emas (a + b turli shakl — xato yoki broadcasting; shape tekshir — 2.6-dars); copy vs view (slice — nusxa emas, ko'rinish; o'zgartirsang asl o'zgaradi — 13-dars); integer bo'lish (int massiv — a / 2 float, a // 2 int; ehtiyot); dtype to'lib ketish (int8 — kichik diapazon, katta son buziladi; mos dtype); Python list deb (ndarray — NumPy amallar, list emas). Sabab: NumPy o'ziga xos (list emas — bir tur, vektorlashtirish, C); noto'g'ri ishlatish (sikl, aralash) — sekin yoki xato. Yechim: vektorlashtir, bir tur, shape tekshir. Tuzoqlar — sikl, aralash tur, shape, copy/view.

2.8. NumPy — Data Science tezligining poydevori

NumPy asosiy g'oyasi — Data Science tezligining poydevori: Data Science ko'p son bilan (million ma'lumot, piksel, o'lchov); oddiy Python sekin (sikl); NumPy tez (ndarray + vektorlashtirish + C — 100x). Bu tezlik kritik (katta ma'lumot — Python sikl daqiqalar, NumPy soniyalar). NumPy butun ekotizim poydevori: pandas (DataFrame — NumPy massiv ustiga), scikit-learn (ML — NumPy), torch (tensor — NumPy'ga o'xshash). NumPy'ni bilmasdan Data Science yo'q (asos). Bu 3-qism (Pandas) uchun bevosita poydevor (DataFrame ichida NumPy) va butun kurs uchun (ML — massiv amallar). Vektorlashtirish tafakkuri (sikl o'rniga massiv) — Data Science kaliti. NumPy — tezlik poydevori. ndarray, vektorlashtirish. Ekotizim asosi.

3. Tez ma'lumotnoma

import numpy as np              # standart nom

# NDARRAY YARATISH:
a = np.array([1, 2, 3])         # 1D (vektor)
b = np.array([[1, 2], [3, 4]])  # 2D (matritsa)

# ATRIBUTLAR:
a.shape      # (3,) — o'lcham
a.ndim       # 1 — o'lchamlar soni
a.dtype      # int64 — element turi
a.size       # 3 — jami elementlar

# VEKTORLASHTIRISH (sikl yo'q):
a * 2                # [2 4 6] — butun massivga
a + b                # element-wise (bir xil shakl)

# MASSIV vs LIST:
#   list — turli tur, sekin, sikl
#   ndarray — bir tur, tez (100x), vektorlashtirish

# NEGA TEZ: bir tur + C + vektorlashtirish (100x)

QOIDA: vektorlashtir (siklsiz) · bir tur · shape/dtype tekshir

NumPy xulosasi

NumPy — sonli hisoblash poydevori (Data Science tezligi)
ndarray — bir turdagi sonlar, N-o'lchamli (shape, dtype)
Massiv vs list — bir tur/tez vs aralash/sekin (son uchun NumPy)
Vektorlashtirish — butun massivga bir amal (sikl yo'q, tez, sodda)
Nega tez — bir tur + C + vektorlashtirish (100x) · ekotizim poydevori

4. Batafsil misollar

Misollar real numpy bilan (deterministik) ishlaydi.

Misol 1 — ndarray yaratish va atributlar

"""ndarray: yaratish va atributlar (real numpy)."""

import numpy as np


def main() -> None:
    print("=== 1. 1D massiv (vektor) ===")
    a = np.array([1, 2, 3, 4, 5])
    print(f"  massiv: {a}")
    print(f"  shape: {a.shape}, ndim: {a.ndim}, dtype: {a.dtype}")

    print("\n=== 2. 2D massiv (matritsa) ===")
    b = np.array([[1, 2, 3], [4, 5, 6]])
    print(f"  massiv:\n{b}")
    print(f"  shape: {b.shape} (2 qator, 3 ustun)")

    print("\n=== 3. Atributlar ===")
    print(f"  b.ndim: {b.ndim} (o'lchamlar)")
    print(f"  b.size: {b.size} (jami element)")

    print("\n=== 4. Bir tur ===")
    print(f"  dtype: {b.dtype} (hammasi int64 — ixcham)")
    print("  ⭐ ndarray — bir tur, N-o'lchamli")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. 1D massiv (vektor) ===
  massiv: [1 2 3 4 5]
  shape: (5,), ndim: 1, dtype: int64

=== 2. 2D massiv (matritsa) ===
  massiv:
[[1 2 3]
 [4 5 6]]
  shape: (2, 3) (2 qator, 3 ustun)

=== 3. Atributlar ===
  b.ndim: 2 (o'lchamlar)
  b.size: 6 (jami element)

=== 4. Bir tur ===
  dtype: int64 (hammasi int64 — ixcham)
  ⭐ ndarray — bir tur, N-o'lchamli

Nima ko'rsatdi: 2.2-bo'lim.

Misol 2 — Vektorlashtirish (sikl yo'q)

"""Vektorlashtirish: butun massivga bir amal (real numpy)."""

import numpy as np


def main() -> None:
    narxlar = np.array([100, 200, 300, 400])

    print("=== 1. 20% oshirish (vektorlashtirish) ===")
    yangi = narxlar * 1.2
    print(f"  {narxlar} * 1.2 = {yangi}")

    print("\n=== 2. Element-wise (ikki massiv) ===")
    a = np.array([1, 2, 3])
    b = np.array([10, 20, 30])
    print(f"  a + b = {a + b}")
    print(f"  a * b = {a * b}")

    print("\n=== 3. Boshqa amallar ===")
    print(f"  a ** 2 = {a ** 2} (kvadrat)")
    print(f"  a > 2 = {a > 2} (shart)")

    print("\n=== 4. Sikl yo'q ===")
    print("  butun massivga bir amal (Python sikl o'rniga)")
    print("  ⭐ Vektorlashtirish — sikl yo'q (tez, sodda)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. 20% oshirish (vektorlashtirish) ===
  [100 200 300 400] * 1.2 = [120. 240. 360. 480.]

=== 2. Element-wise (ikki massiv) ===
  a + b = [11 22 33]
  a * b = [10 40 90]

=== 3. Boshqa amallar ===
  a ** 2 = [1 4 9] (kvadrat)
  a > 2 = [False False  True] (shart)

=== 4. Sikl yo'q ===
  butun massivga bir amal (Python sikl o'rniga)
  ⭐ Vektorlashtirish — sikl yo'q (tez, sodda)

Nima ko'rsatdi: 2.4-bo'lim.

Misol 3 — Massiv vs list (tezlik)

"""Massiv vs list: amal soni (tezlik modeli)."""

import numpy as np


def main() -> None:
    n = 1000

    print("=== 1. Python list (sikl) ===")
    ro_yxat = list(range(n))
    natija_list = [x * 2 for x in ro_yxat]   # sikl (har element)
    print(f"  {n} element, sikl bilan (har element alohida)")
    print(f"  dastlabki: {natija_list[:5]}")

    print("\n=== 2. NumPy massiv (vektorlashtirish) ===")
    massiv = np.arange(n)
    natija_np = massiv * 2                     # bir amal (butun massivga)
    print(f"  {n} element, bir amal (sikl yo'q)")
    print(f"  dastlabki: {natija_np[:5].tolist()}")

    print("\n=== 3. Tezlik (nazariy) ===")
    print("  list: har element sikl (sekin)")
    print("  NumPy: C ichida vektor (100x tez)")

    print("\n=== 4. Xulosa ===")
    print("  son hisoblash → NumPy (list emas)")
    print("  ⭐ NumPy — 100x tez (bir tur + C + vektor)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Python list (sikl) ===
  1000 element, sikl bilan (har element alohida)
  dastlabki: [0, 2, 4, 6, 8]

=== 2. NumPy massiv (vektorlashtirish) ===
  1000 element, bir amal (sikl yo'q)
  dastlabki: [0, 2, 4, 6, 8]

=== 3. Tezlik (nazariy) ===
  list: har element sikl (sekin)
  NumPy: C ichida vektor (100x tez)

=== 4. Xulosa ===
  son hisoblash → NumPy (list emas)
  ⭐ NumPy — 100x tez (bir tur + C + vektor)

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

Misol 4 — dtype (element turi)

"""dtype: element turi va ta'siri (real numpy)."""

import numpy as np


def main() -> None:
    print("=== 1. Butun (int) ===")
    a = np.array([1, 2, 3])
    print(f"  {a}, dtype: {a.dtype}")

    print("\n=== 2. Kasr (float) ===")
    b = np.array([1.5, 2.5, 3.5])
    print(f"  {b}, dtype: {b.dtype}")

    print("\n=== 3. Aralash → bir turga ===")
    c = np.array([1, 2, 3.5])   # int + float → hammasi float
    print(f"  [1, 2, 3.5] → {c}, dtype: {c.dtype}")

    print("\n=== 4. dtype belgilash ===")
    d = np.array([1, 2, 3], dtype=np.float64)
    print(f"  float64: {d}")
    print("  ⭐ dtype — bir tur (aralash bo'lmaydi)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Butun (int) ===
  [1 2 3], dtype: int64

=== 2. Kasr (float) ===
  [1.5 2.5 3.5], dtype: float64

=== 3. Aralash → bir turga ===
  [1, 2, 3.5] → [1.  2.  3.5], dtype: float64

=== 4. dtype belgilash ===
  float64: [1. 2. 3.]
  ⭐ dtype — bir tur (aralash bo'lmaydi)

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

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

6. Keng tarqalgan xatolar va yechimlari

1. Sikl ishlatish

for x in massiv: yangi.append(x * 2)   # sekin (sikl)          # ⚠️
yangi = massiv * 2   # vektorlashtirish (tez)                    # ✅

2. Aralash tur

np.array([1, "matn", 3])   # hammasi satr bo'ladi              # ⚠️
np.array([1, 2, 3])   # bir tur (int)                           # ✅

3. Shape mos emas

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

4. Python list amallari

massiv.append(5)   # ndarray'da append yo'q (xato)             # ⚠️
np.append(massiv, 5)   # yoki oldindan hajm                     # ✅

5. Integer bo'lish

np.array([5, 10]) // 3   # int bo'lish (1, 3)                  # ⚠️
np.array([5, 10]) / 3   # float (kerak bo'lsa)                  # ✅

6. dtype to'lib ketish

np.array([200], dtype=np.int8) + 100   # int8 to'ladi (buziladi) # ⚠️
np.array([200], dtype=np.int64)   # katta diapazon               # ✅

7. shape tekshirmaslik

# xato tur/o'lcham (kutilmagan natija)                         # ⚠️
massiv.shape; massiv.dtype   # avval tekshir                    # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 2.2-dars: Massiv yaratish (usullar)
• 2.4-dars: Indekslash va slicing
• 3-qism: Pandas — DataFrame (NumPy ustiga)
• 14-qism: Machine Learning (NumPy massiv)
• 22-qism: Deep Learning (tensor — NumPy'ga o'xshash)

8. Eng yaxshi amaliyotlar

1. import numpy as np (standart nom).

2. Vektorlashtir (sikl o'rniga — tez, sodda).

3. Bir tur (ndarray — son uchun).

4. shape/dtype tekshir (xato oldini).

5. Element-wise (bir xil shakl).

6. dtype tanla (xotira/aniqlik).

7. Sikl yozma (NumPy amal bor).

8. NumPy — poydevor (pandas/sklearn asosi).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # NumPy nima?
2.  # standart nomi?
3.  # ndarray nima?
4.  # shape nima?
5.  # dtype nima?
6.  # massiv vs list?
7.  # vektorlashtirish nima?
8.  # element-wise nima?
9.  # nega NumPy tez?
10. # necha marta tez?
11. # aralash tur mumkinmi?
12. # NumPy poydevormi?

Vazifa 2: Xatolarni tuzating

1.  for x in massiv: yangi.append(x*2)

2.  np.array([1, "matn", 3])

3.  massiv.append(5)

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

5.  # shape tekshirmasdan

1.  yangi = massiv * 2 (vektorlashtir)

2.  np.array([1, 2, 3]) (bir tur)

3.  np.append(massiv, 5)

4.  bir xil shakl (yoki broadcasting)

5.  massiv.shape (avval tekshir)

Vazifa 3: ndarray

Modellang:

1. 1D
2. 2D
3. shape
4. dtype

Vazifa 4: Vektorlashtirish

Modellang:

1. Sikl yo'q
2. Butun massiv
3. Element-wise
4. Tez

Vazifa 5: Massiv vs list

Modellang:

1. Bir tur
2. Vektorlashtirish
3. Tezlik
4. Son uchun

Vazifa 6: Nega tez

Modellang:

1. Bir tur
2. C
3. Vektorlashtirish
4. 100x

Vazifa 7: O'ylash

NumPy tezligi "vektorlashtirish" (butun massivga bir amal, sikl o'rniga) tufayli — bu nafaqat tez, balki kod ham soddaroq. Nima uchun "vektorlashtirilgan fikrlash" (sikl o'rniga massiv amal) Data Science'da yangi tafakkur talab qiladi, va nega bu "massiv sifatida o'ylash" oddiy dasturlashdan (element-element) farq qiladi?

Nimani mustahkamlaydi: 2.4, 2.8-bo'limlar.

Xulosa

Bu darsda NumPy va ndarray ni o'rgandik.

Eng muhim uch fikr:

1. NumPy va ndarray. NumPy (Numerical Python) — sonli hisoblash uchun asosiy kutubxona (import numpy as np): ndarray, vektorlashtirilgan amallar, tez (C daraja); Data Science ko'p son bilan (million) — Python sekin, NumPy tez; poydevor (pandas, sklearn, torch NumPy ustiga). ndarray (N-dimensional array) — NumPy yuragi: bir turdagi sonlar to'plami (list farqi), N-o'lchamli (1D vektor, 2D matritsa, 3D+ tensor); atributlar shape (o'lcham), ndim, dtype (tur), size.

2. Massiv vs list va vektorlashtirish. Massiv vs list: list (turli tur — moslashuvchan, lekin sekin, sikl, ko'p xotira), ndarray (bir tur — tez/ixcham, vektorlashtirish, 100x tez); son hisoblash uchun NumPy (list emas). Vektorlashtirish — NumPy kuchi: butun massivga bir amal (sikl yo'q — narxlar * 1.2), element-wise (a + b — har juftlik); oddiy Python sikl (sekin), vektorlashtirish butun massivga (tez, sodda kod — bir qator); NumPy asosiy g'oyasi (sikl o'rniga massiv amal).

3. Nega tez va poydevor. Nega NumPy tez — uch sabab: bir tur (int64 — bir xil xotira, ixcham), C da (amal C sikli — mashina kodi, 100x), vektorlashtirish (bir amal butun massivga — sikl C ichida); million son Python 1s, NumPy 0.01s. NumPy — Data Science tezligining poydevori: ko'p son (million) — tezlik kritik; butun ekotizim asosi (pandas DataFrame, sklearn, torch — NumPy ustiga). Vektorlashtirilgan fikrlash (sikl o'rniga massiv amal) yangi tafakkur talab qiladi (element-element → butun massiv, imperativ → deklarativ) — Data Science kaliti (ma'lumot massiv/jadval, massiv fikrlash tez va sodda).

Keyingi darsda massiv yaratish usullarini o'rganamiz: array, zeros, ones, arange, linspace va boshqa — turli holatda massiv yaratishning tez usullari.