IlmHamroh
Python kursi/Malumot tahlili1/18-dars16 daqiqa
Mundarija (22)

24.1-dars: NumPy — massiv

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

1. Kirish va motivatsiya

Shu paytgacha ma'lumotni Python ro'yxatlari (list) bilan saqladik. Ro'yxat moslashuvchan, lekin son bilan ishlashda sekin va noqulay: million sonni qo'shish uchun for sikl, har element alohida obyekt (xotira ko'p). Ilmiy hisoblash, ma'lumot tahlili, mashinaviy o'qitish (25-qism) — bularda katta son massivlari ustida tez amal kerak.

NumPy (Numerical Python) — Python'ning ilmiy hisoblash poydevori: ndarray (n-o'lchamli massiv) — bir xil turdagi sonlarni ixcham, tez saqlaydi. Amal vektorlangan (butun massiv birdaniga — a + 10, siklsiz), C tezligida. pandas 24.5-bob, Matplotlib 24.13-bob, scikit-learn (25), PyTorch — hammasi NumPy ustida. NumPy'ni bilish — ma'lumot tahlilining asosi.

Real vaziyat. Bir hisoblash million o'lchovni qayta ishlardi — Python ro'yxat + for bilan 8 soniya. NumPy massivga o'tdi: natija = massiv * 2 + 5 (bir qator, siklsiz) — 0.05 soniya. 150 barobar tez. Sabab: NumPy ma'lumotni uzluksiz xotirada (C massivi) saqlaydi va amalni C darajasida (vektorlangan) bajaradi. Katta ma'lumot uchun NumPy — zaruriy.

Bu darsda NumPy'ni — ndarray, yaratish, vektorlangan amalni o'rganamiz.

Bu darsda:

  • NumPy va ndarray nima
  • Massiv yaratish (array, arange, zeros)
  • Massiv atributlari (shape, dtype)
  • Vektorlangan amal
  • Agregat (sum, mean, max)
  • Shakl o'zgartirish (reshape)
  • Ro'yxat vs NumPy
  • Amaliy: massiv bilan hisoblash

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

2. Nazariya — chuqur tushuntirish

2.1. NumPy va ndarray nima

NumPy'ning yuragi — ndarray (massiv):

python
import numpy as np
a = np.array([1, 2, 3, 4, 5])     # ndarray

NumPy — Python ilmiy hisoblash kutubxonasi. ndarray (n-dimensional array) — bir xil turdagi (masalan, barcha int yoki float) sonlarni uzluksiz xotirada saqlaydigan massiv. Ro'yxatdan farq: bir tur (ixcham), tez amal (vektorlangan, C darajasi). import numpy as np — an'anaviy nom. Ma'lumot tahlilining poydevori.

2.2. Massiv yaratish

Massiv yaratishning bir necha yo'li:

python
np.array([1, 2, 3])              # ro'yxatdan
np.arange(0, 10, 2)              # [0 2 4 6 8] (start, stop, qadam)
np.zeros(3)                      # [0. 0. 0.]
np.ones((2, 3))                  # 2×3 birlar
np.linspace(0, 1, 5)             # 0 dan 1 gacha 5 ta teng
np.array([[1, 2], [3, 4]])       # 2o'lchamli

Massiv yaratish: np.array(ro'yxat) (ro'yxatdan), np.arange(boshi, oxiri, qadam) (ketma-ketlik — range kabi), np.zeros/np.ones (nol/bir — shakl bilan), np.linspace(a, b, n) (a–b oraliqda n ta teng nuqta). Ko'p o'lchamli — ichma-ich ro'yxat. Bular ma'lumot yaratish/tayyorlashda kerak.

2.3. Massiv atributlari (shape, dtype)

Massiv o'zi haqida ma'lumot:

python
a = np.array([[1, 2, 3], [4, 5, 6]])
a.shape       # (2, 3) — o'lcham (2 qator, 3 ustun)
a.ndim        # 2 — o'lchamlar soni
a.size        # 6 — jami element
a.dtype       # int64 — element turi

Massiv atributlari: .shape (o'lcham — (qator, ustun)), .ndim (o'lchamlar soni — 1D, 2D), .size (jami element), .dtype (element turi — int64, float64). dtype muhim: NumPy bir turdagi (tez, ixcham). .shape — ma'lumot shaklini tushunish uchun asosiy.

2.4. Vektorlangan amal

NumPy'ning kuchi — siklsiz amal:

python
a = np.array([1, 2, 3, 4])
a + 10          # [11 12 13 14] — har elementga +10
a * 2           # [2 4 6 8]
a ** 2          # [1 4 9 16]
a + a           # [2 4 6 8] — element-element
a > 2           # [False False True True]

Vektorlangan amal (vectorization) — butun massiv ustida birdaniga amal (siklsiz): a + 10 (har elementga), a * b (element-element), a > 2 (shart — bool massiv). Bu Python sikldan tezroq (C darajasida) va qisqaroq (bir qator). NumPy'ning asosiy g'oyasi: sikl o'rniga massiv amali.

2.5. Agregat (sum, mean, max)

Massivni bir songa jamlash:

python
a = np.array([1, 2, 3, 4, 5])
a.sum()         # 15
a.mean()        # 3.0 (o'rtacha)
a.max()         # 5
a.min()         # 1
a.std()         # standart chetlanish
# 2D:
m.sum(axis=0)   # ustunlar bo'yicha
m.sum(axis=1)   # qatorlar bo'yicha

Agregat funksiyalari: .sum() (yig'indi), .mean() (o'rtacha), .max()/.min(), .std() (standart chetlanish, 24.16). 2D'da axis bilan: axis=0 (ustunlar bo'yicha — pastga), axis=1 (qatorlar bo'yicha — o'ngga). Bu ma'lumot xulosasi (statistika) uchun asosiy — 24.16'da chuqurroq.

2.6. Shakl o'zgartirish (reshape)

Massiv shaklini o'zgartirish:

python
a = np.arange(6)                 # [0 1 2 3 4 5]
a.reshape(2, 3)                  # [[0 1 2] [3 4 5]]
a.reshape(3, 2)                  # [[0 1] [2 3] [4 5]]
m.flatten()                      # 2D → 1D (yassila)
m.T                              # transpozitsiya (qator↔ustun)

reshape(qator, ustun) — massiv shaklini o'zgartiradi (element soni bir xil bo'lsin — 6 = 2×3). .flatten() (ko'p o'lchamli → 1D), .T (transpozitsiya — qator va ustun almashadi). Shakl o'zgartirish — ma'lumotni tahlil/model uchun to'g'ri shaklga keltirishda muhim.

2.7. Ro'yxat vs NumPy

Xususiyat Ro'yxat (list) NumPy (ndarray)
Tur Aralash Bir xil (dtype)
Xotira Ko'p (har obyekt) Kam (uzluksiz)
Amal Sikl Vektorlangan
Tezlik Sekin Tez (C)
Maqsad Umumiy Son hisoblash

Ro'yxat — umumiy (aralash tur, moslashuvchan), lekin son bilan sekin (sikl, har element obyekt). NumPy — bir tur (ixcham), vektorlangan (tez, C darajasi) — son massivlari uchun. Katta son ma'lumoti → NumPy; kichik aralash → ro'yxat. Ma'lumot tahlilida NumPy asos.

2.8. Nega NumPy tez

NumPy uch sabab bilan tez: 1) ma'lumot uzluksiz xotirada (C massivi — ro'yxat esa har element alohida obyekt, tarqoq), 2) amal C darajasida (Python sikl emas — vektorlangan), 3) bir tur (dtype — tekshirish kerak emas). Bu "ma'lumot joylashuvi va bir jinslilik tezlik beradi" tamoyili. Katta ma'lumotda bu farq 100+ barobar. NumPy — Python'ning tez son yadrosi (C/Fortran ustida).

3. Tez ma'lumotnoma

python
import numpy as np

# yaratish:
np.array([1, 2, 3])            # ro'yxatdan
np.arange(0, 10, 2)            # [0 2 4 6 8]
np.zeros(3); np.ones((2, 3))   # nol/bir
np.linspace(0, 1, 5)           # teng oraliq

# atribut:
a.shape; a.ndim; a.size; a.dtype

# vektorlangan amal:
a + 10; a * 2; a ** 2; a + b; a > 2

# agregat:
a.sum(); a.mean(); a.max(); a.min(); a.std()
m.sum(axis=0)                  # ustun bo'yicha

# shakl:
a.reshape(2, 3); a.flatten(); a.T
a[a > 2]                       # bool indeks (24.3)

NumPy xulosasi

ndarray: bir tur, uzluksiz, tez · vektorlangan: siklsiz amal
shape/dtype: shakl/tur · agregat: sum/mean · reshape: shakl o'zgartir

4. Batafsil misollar

Misollarda NumPy (import numpy as np) bilan sinaladi.

Misol 1 — Massiv yaratish va atributlar

python
"""array/arange/zeros/linspace (yaratish); shape/ndim/size/dtype (atribut)."""

import numpy as np


def main() -> None:
    print("=== 1. array (ro'yxatdan) ===")
    a = np.array([1, 2, 3, 4, 5])
    print(f"  {a}, shape={a.shape}, size={a.size}, ndim={a.ndim}")

    print("\n=== 2. arange / linspace ===")
    print(f"  arange(0,10,2): {np.arange(0, 10, 2)}")
    print(f"  linspace(0,1,5): {np.linspace(0, 1, 5)}")

    print("\n=== 3. zeros / ones ===")
    print(f"  zeros(4): {np.zeros(4)}")
    print(f"  ones(2x3): {np.ones((2, 3)).tolist()}")

    print("\n=== 4. 2D massiv va atributlar ===")
    m = np.array([[1, 2, 3], [4, 5, 6]])
    print(f"  {m.tolist()}")
    print(f"  shape={m.shape}, ndim={m.ndim}, size={m.size}, dtype={m.dtype}")
    print("  ⭐ ndarray — bir tur, shakl (shape) bilan")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. array (ro'yxatdan) ===
  [1 2 3 4 5], shape=(5,), size=5, ndim=1

=== 2. arange / linspace ===
  arange(0,10,2): [0 2 4 6 8]
  linspace(0,1,5): [0.   0.25 0.5  0.75 1.  ]

=== 3. zeros / ones ===
  zeros(4): [0. 0. 0. 0.]
  ones(2x3): [[1.0, 1.0, 1.0], [1.0, 1.0, 1.0]]

=== 4. 2D massiv va atributlar ===
  [[1, 2, 3], [4, 5, 6]]
  shape=(2, 3), ndim=2, size=6, dtype=int64
  ⭐ ndarray — bir tur, shakl (shape) bilan

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

Misol 2 — Vektorlangan amal

python
"""vektorlangan amal: a+10 (skalyar), a*b (element-element), a**2, a>2 (bool) — siklsiz."""

import numpy as np


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

    print("=== 1. Skalyar amal (har elementga) ===")
    print(f"  a + 10 = {a + 10}")
    print(f"  a * 2  = {a * 2}")
    print(f"  a ** 2 = {a ** 2}")

    print("\n=== 2. Element-element amal ===")
    print(f"  a + b = {a + b}")
    print(f"  b / a = {(b / a)}")

    print("\n=== 3. Taqqoslash (bool massiv) ===")
    print(f"  a > 2  = {a > 2}")
    print(f"  a % 2 == 0 = {a % 2 == 0}")

    print("\n=== 4. Amallar zanjiri (siklsiz) ===")
    natija = a * 2 + 100
    print(f"  a*2+100 = {natija}")
    print("  ⭐ vektorlangan — butun massiv birdaniga (sikl yo'q)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Skalyar amal (har elementga) ===
  a + 10 = [11 12 13 14 15]
  a * 2  = [ 2  4  6  8 10]
  a ** 2 = [ 1  4  9 16 25]

=== 2. Element-element amal ===
  a + b = [11 22 33 44 55]
  b / a = [10. 10. 10. 10. 10.]

=== 3. Taqqoslash (bool massiv) ===
  a > 2  = [False False  True  True  True]
  a % 2 == 0 = [False  True False  True False]

=== 4. Amallar zanjiri (siklsiz) ===
  a*2+100 = [102 104 106 108 110]
  ⭐ vektorlangan — butun massiv birdaniga (sikl yo'q)

Nima ko'rsatdi: 2.4-bo'lim.

Misol 3 — Agregat va shakl

python
"""agregat: sum/mean/max/min/std; 2D axis (0 ustun, 1 qator); reshape/T (shakl)."""

import numpy as np


def main() -> None:
    a = np.array([2, 4, 6, 8, 10])

    print("=== 1. Agregat (1D) ===")
    print(f"  sum={a.sum()}, mean={a.mean()}, max={a.max()}, min={a.min()}")
    print(f"  std={round(float(a.std()), 3)}")

    print("\n=== 2. reshape (shakl o'zgartirish) ===")
    b = np.arange(6)
    print(f"  arange(6): {b}")
    print(f"  reshape(2,3): {b.reshape(2, 3).tolist()}")

    print("\n=== 3. 2D agregat (axis) ===")
    m = np.array([[1, 2, 3], [4, 5, 6]])
    print(f"  butun sum: {m.sum()}")
    print(f"  axis=0 (ustun): {m.sum(axis=0)}")
    print(f"  axis=1 (qator): {m.sum(axis=1)}")

    print("\n=== 4. Transpozitsiya (T) ===")
    print(f"  original: {m.tolist()}")
    print(f"  transpoz: {m.T.tolist()}")
    print("  ⭐ agregat (sum/mean), reshape, axis — ma'lumot xulosasi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Agregat (1D) ===
  sum=30, mean=6.0, max=10, min=2
  std=2.828

=== 2. reshape (shakl o'zgartirish) ===
  arange(6): [0 1 2 3 4 5]
  reshape(2,3): [[0, 1, 2], [3, 4, 5]]

=== 3. 2D agregat (axis) ===
  butun sum: 21
  axis=0 (ustun): [5 7 9]
  axis=1 (qator): [ 6 15]

=== 4. Transpozitsiya (T) ===
  original: [[1, 2, 3], [4, 5, 6]]
  transpoz: [[1, 4], [2, 5], [3, 6]]
  ⭐ agregat (sum/mean), reshape, axis — ma'lumot xulosasi

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

Misol 4 — Amaliy: baholar tahlili

Real misol: talaba baholarini NumPy bilan tahlil qilish — o'rtacha, eng yuqori, o'tganlar. Bu — massiv bilan hisoblashning namunasi.

python
"""to'liq tahlil: baholar massivi, statistika (mean/max/min/std), bool filtr (o'tganlar), vektorlangan."""

import numpy as np


def main() -> None:
    # 8 talaba baholari
    baholar = np.array([65, 80, 45, 90, 72, 88, 55, 95])

    print("=== 1. Umumiy statistika ===")
    print(f"  talabalar: {baholar.size}")
    print(f"  o'rtacha: {baholar.mean()}")
    print(f"  eng yuqori: {baholar.max()}, eng past: {baholar.min()}")
    print(f"  std (tarqoqlik): {round(float(baholar.std()), 2)}")

    print("\n=== 2. Bool filtr (o'tganlar — 60+) ===")
    otganlar = baholar[baholar >= 60]
    print(f"  o'tganlar: {otganlar.tolist()}")
    print(f"  o'tganlar soni: {otganlar.size}")

    print("\n=== 3. Vektorlangan (5 ball qo'shish) ===")
    tuzatilgan = baholar + 5
    tuzatilgan = np.minimum(tuzatilgan, 100)   # 100 dan oshmasin
    print(f"  tuzatilgan: {tuzatilgan.tolist()}")

    print("\n=== 4. Baho darajasi (bool sanash) ===")
    alo = (baholar >= 85).sum()
    yaxshi = ((baholar >= 70) & (baholar < 85)).sum()
    print(f"  a'lo (85+): {alo}, yaxshi (70-84): {yaxshi}")
    print("  ⭐ NumPy — statistika, filtr, vektorlangan hisoblash")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Umumiy statistika ===
  talabalar: 8
  o'rtacha: 73.75
  eng yuqori: 95, eng past: 45
  std (tarqoqlik): 16.64

=== 2. Bool filtr (o'tganlar — 60+) ===
  o'tganlar: [65, 80, 90, 72, 88, 95]
  o'tganlar soni: 6

=== 3. Vektorlangan (5 ball qo'shish) ===
  tuzatilgan: [70, 85, 50, 95, 77, 93, 60, 100]

=== 4. Baho darajasi (bool sanash) ===
  a'lo (85+): 3, yaxshi (70-84): 2
  ⭐ NumPy — statistika, filtr, vektorlangan hisoblash

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
"NumPy = ro'yxat" Bir tur, tez (C)
"Massivda for kerak" Vektorlangan (siklsiz)
"Aralash tur mumkin" Bir dtype (ixcham)
"NumPy sekin (Python)" C darajasida (tez)
"reshape nusxa" Odatda ko'rinish (view)
"shape — element soni" O'lcham (qator, ustun)
"Kichik ma'lumotga NumPy" Katta son uchun foydali
"a + b — birlashtirish" Element-element qo'shish

6. Keng tarqalgan xatolar va yechimlari

1. Massivda Python sikl (sekin)

python
for i in range(len(a)): a[i] *= 2      # ⚠️ sekin
a = a * 2                               # ✅ vektorlangan

2. Mos kelmaydigan shakl

python
np.array([1, 2]) + np.array([1, 2, 3])  # ⚠️ shape xato
# bir xil shakl yoki broadcasting 24.2-bob  # ✅

3. reshape element soni mos emas

python
np.arange(6).reshape(2, 4)             # ⚠️ 6 ≠ 8
np.arange(6).reshape(2, 3)             # ✅ (6 = 2×3)

4. Butun son bo'linishi kutish

python
np.array([1, 2, 3]) / 2                # [0.5 1. 1.5] (float)
np.array([1, 2, 3]) // 2               # ✅ butun bo'lish

5. list va ndarray aralashtirish

python
[1, 2, 3] * 2                          # [1,2,3,1,2,3] (ro'yxat takror)
np.array([1, 2, 3]) * 2                # [2 4 6] (element)

6. axis chalkashtirish

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

7. dtype e'tiborsiz (butun kesish)

python
a = np.array([1, 2, 3])   # int
a[0] = 1.9                # ⚠️ 1 (butun kesiladi)
a = np.array([1.0, 2, 3]) # ✅ float

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 24.2-dars: Amallar va broadcasting — vektorlangan chuqurroq
  • 24.3-dars: Indeks va shakl — massiv kesish
  • 24.5-dars: pandas — NumPy ustida (DataFrame)
  • 24.13-dars: Matplotlib — massiv vizualizatsiya
  • 25-qism: ML — NumPy massiv (model kirishi)

8. Eng yaxshi amaliyotlar

  1. Son massivi uchun NumPy (ro'yxat emas).

  2. Sikl o'rniga vektorlangan amal.

  3. dtypeni bil (int/float — kesish).

  4. shapeni tekshir (mos amal).

  5. Agregat (sum/mean) — axis bilan (2D).

  6. reshape — element soni mos.

  7. import numpy as np (an'anaviy).

  8. Katta ma'lumot — NumPy (tez, ixcham).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # NumPy nima?
2.  # ndarray nima?
3.  # np.array nima?
4.  # np.arange nima?
5.  # shape nima?
6.  # dtype nima?
7.  # vektorlangan amal nima?
8.  # a + 10 nima qiladi?
9.  # sum/mean nima?
10. # reshape nima?
11. # axis nima?
12. # ro'yxat vs NumPy?
Javoblar
  1. Ilmiy hisoblash kutubxonasi (tez massiv)
  2. n-o'lchamli massiv (bir tur)
  3. Ro'yxatdan massiv
  4. Ketma-ketlik (range kabi)
  5. Massiv o'lchami (qator, ustun)
  6. Element turi (int64, float64)
  7. Butun massiv birdaniga (siklsiz)
  8. Har elementga 10 qo'shadi
  9. Yig'indi / o'rtacha
  10. Shakl o'zgartirish
  11. O'lcham yo'nalishi (0 ustun, 1 qator)
  12. NumPy bir tur, tez (son uchun)

Vazifa 2: Xatolarni tuzating

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

2.  np.arange(6).reshape(2, 4)          # 2,3

3.  [1, 2, 3] * 2                        # np.array

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

5.  # katta son ro'yxatda sikl           # NumPy
Javoblar
python
1.  a = a * 2

2.  np.arange(6).reshape(2, 3)

3.  np.array([1, 2, 3]) * 2

4.  # bir xil shakl (yoki broadcasting)

5.  a = np.array(...); a * 2

Vazifa 3: Massiv yaratish

Turli yo'l:

  1. array, arange
  2. zeros, ones
  3. linspace
  4. 2D massiv

Vazifa 4: Vektorlangan amal

Siklsiz:

  1. Skalyar (+, *)
  2. Element-element
  3. Bool (>)
  4. Zanjir

Vazifa 5: Agregat

Statistika:

  1. sum, mean
  2. max, min, std
  3. 2D axis
  4. Xulosa

Vazifa 6: Shakl

O'zgartirish:

  1. reshape
  2. flatten
  3. T (transpoz)
  4. Test

Vazifa 7: O'ylash

NumPy son ma'lumotini bir turdagi, uzluksiz massivda saqlaydi va amalni vektorlangan (butun massiv birdaniga) bajaradi — Python sikli o'rniga. Bu 100+ barobar tezroq. Nima uchun "ma'lumot bir jinsli va uzluksiz bo'lsa tezroq", va bu "ma'lumotga yo'naltirilgan dizayn" (data-oriented) tamoyili bilan qanday bog'liq — nega ba'zan moslashuvchanlikni (ro'yxat) tezlikka (NumPy) almashtiramiz?

Javob

Qisqa javob: NumPy tez, chunki: 1) ma'lumot uzluksiz xotirada (C massivi — protsessor keshi samarali o'qiydi; ro'yxat tarqoq — har element alohida obyekt, xotirada sakrash), 2) bir jinsli (bir dtype — tur tekshirish kerak emas, amal to'g'ridan), 3) amal C darajasida (Python sikl emas — vektorlangan). "Ma'lumotga yo'naltirilgan dizayn" — ma'lumotni protsessor va xotira samarali ishlaydigan shaklda tashkil qilish. Moslashuvchanlik (ro'yxat — aralash tur, har xil amal) qulay, lekin sekin (tarqoq, obyekt). Tezlik kerak bo'lsa (katta ma'lumot), moslashuvchanlikni qurbon qilamiz (bir tur, qat'iy massiv). "To'g'ri ma'lumot tuzilishi — to'g'ri ish uchun".

1. Uzluksiz vs tarqoq xotira

Ro'yxat NumPy massiv
Har element — obyekt (tarqoq) Uzluksiz (C massivi)
Xotirada sakrash Ketma-ket (kesh samarali)
Tur tekshirish (har amal) Bir tur (to'g'ridan)

Protsessor uzluksiz xotirani (kesh) tez o'qiydi — tarqoq ma'lumot sekin (xotiraga murojaat).

2. Bir jinslilik (bir tur)

Ro'yxatda har element har xil tur bo'lishi mumkin — amal oldidan tekshirish. NumPy bir dtype — tekshirish yo'q, amal to'g'ridan (tez).

3. Vektorlangan (C darajasi)

a * 2 — Python sikl emas, C sikl (kompilyatsiyalangan). Yuz baravar tez.

4. Moslashuvchanlik vs tezlik

Ro'yxat (moslashuvchan) NumPy (tez)
Aralash tur Bir tur
Har xil amal Son amali
Sekin Tez
Kichik/aralash Katta son

Tanlov: ma'lumot aralash, kichik → ro'yxat; son, katta → NumPy.

5. Muhandislik saboqlari

  1. Ma'lumot joylashuvi tezlikka ta'sir (uzluksiz — tez)
  2. Bir jinslilik — amal to'g'ridan
  3. Moslashuvchanlik vs tezlik tanlov
  4. To'g'ri tuzilma — to'g'ri ish uchun

6. Xulosa

  1. NumPy: uzluksiz + bir tur + vektorlangan
  2. Tezlik — xotira joylashuvi va bir jinslilik
  3. Moslashuvchanlikni tezlikka almashtiramiz
  4. Katta son ma'lumoti → NumPy

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.

Xulosa

Bu darsda NumPy massivini o'rgandik.

Eng muhim uch fikr:

  1. NumPy va ndarray — tez son massivi. NumPy — Python ilmiy hisoblash poydevori; ndarray — bir xil turdagi (dtype) sonlarni uzluksiz xotirada saqlaydigan massiv. Ro'yxatdan farq: bir tur (ixcham), tez amal (vektorlangan). Yaratish: np.array(ro'yxat), np.arange(a, b, qadam), np.zeros/np.ones (shakl bilan), np.linspace(a, b, n) (teng oraliq). Atributlar: .shape (o'lcham), .ndim (o'lchamlar), .size (element soni), .dtype (tur). pandas, Matplotlib, scikit-learn, PyTorch — hammasi NumPy ustida.

  2. Vektorlangan amal — siklsiz. Vektorlangan amal — butun massiv ustida birdaniga: a + 10 (skalyar — har elementga), a * b (element-element), a > 2 (bool massiv), zanjir (a * 2 + 100). Bu Python sikldan tezroq (C darajasida) va qisqaroq (bir qator). Agregat: .sum(), .mean(), .max()/.min(), .std() — 2D'da axis bilan (axis=0 ustun, axis=1 qator). Shakl: reshape(qator, ustun) (element soni mos), .flatten() (1D), .T (transpozitsiya). Bool indeks: a[a > 2].

  3. Ro'yxat vs NumPy — qachon qaysi. Ro'yxat — umumiy (aralash tur, moslashuvchan), lekin son bilan sekin (sikl, har element obyekt); NumPy — bir tur (ixcham), vektorlangan (tez, C darajasi). NumPy tez uch sabab bilan: uzluksiz xotira (kesh samarali), bir jinslilik (dtype — tur tekshirish yo'q), C darajasida amal. Bu "ma'lumotga yo'naltirilgan dizayn" — moslashuvchanlikni (ro'yxat) tezlikka (NumPy) almashtirish. Katta son ma'lumoti → NumPy; kichik aralash → ro'yxat. NumPy — ma'lumot tahlilining asosi.

Keyingi darsda NumPy amallar va broadcasting ni o'rganamiz: har xil shakldagi massivlar ustida amal (broadcasting), matematik funksiyalar — vektorlangan hisoblashni chuqurroq.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
24.1-dars: NumPy — massiv — IlmHamroh