IlmHamroh
Python kursi/Malumot tahlili3/18-dars17 daqiqa
Mundarija (22)

24.3-dars: NumPy — indeks va shakl

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

1. Kirish va motivatsiya

24.1–24.2 da massiv yaratish va amalni ko'rdik. Endi real tahlilning eng ko'p uchraydigan ishi: massivning kerakli qismini tanlash. Jadvalning bir ustuni (barcha narxlar), shartga mos qatorlar (60'dan yuqori baholar), ma'lum indekslar (1, 5, 8-qatorlar). Bu — indekslash (indexing) va kesish (slicing).

NumPy indekslash Python ro'yxatidan kuchliroq: kesish (a[2:5]), ko'p o'lchamli (m[1, 2] — qator, ustun), bool indeks (a[a > 5] — shartga mos), fancy indeks (a[[1, 3, 5]] — ro'yxat bo'yicha). Muhim tushuncha: kesish ko'rinish (view) qaytaradi — nusxa emas (o'zgarish asl massivga ta'sir qiladi). Bu ma'lumot tanlash, filtrlash, o'zgartirishning asosi — pandas 24.7-bob da ham shu.

Real vaziyat. Bir tahlilda 10000 o'lchovdan faqat chegaradan oshganlarini (anomaliya) ajratib, ularni nolga tenglash kerak edi. Sikl bilan: for + if, sekin, uzun. Bool indeks bilan: a[a > chegara] = 0 (bir qator) — NumPy shartga mos elementlarni topdi va o'zgartirdi. Kod bir qatorga qisqardi, tez ishladi. Bool indeksni bilish — ma'lumot bilan ishlashning kaliti.

Bu darsda NumPy indeks va kesishni o'rganamiz.

Bu darsda:

  • Kesish (slicing)
  • Ko'p o'lchamli indeks
  • Bool indeks (shartli)
  • Fancy indeks (ro'yxat bilan)
  • Ko'rinish (view) vs nusxa (copy)
  • Shartli o'zgartirish
  • Shakl kengaytirish (newaxis)
  • Amaliy: ma'lumot tanlash

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

2. Nazariya — chuqur tushuntirish

2.1. Kesish (slicing)

Kesish — massiv qismini olish:

python
a = np.arange(10)      # [0 1 2 3 4 5 6 7 8 9]
a[2:5]                 # [2 3 4] (2 dan 5 gacha)
a[:3]                  # [0 1 2] (boshdan)
a[7:]                  # [7 8 9] (oxiriga)
a[::2]                 # [0 2 4 6 8] (har ikkinchi)
a[-3:]                 # [7 8 9] (oxirgi 3)

Kesish — a[boshi:oxiri:qadam] (Python ro'yxat kabi, 04.x): a[2:5] (2–4, 5 kirmaydi), a[:3] (boshdan), a[7:] (oxiriga), a[::2] (har ikkinchi), a[-3:] (oxirgi 3). Manfiy indeks — oxirdan. Kesish — massiv qismini tanlashning asosiy usuli.

2.2. Ko'p o'lchamli indeks

2D massivda qator va ustun:

python
m = np.arange(12).reshape(3, 4)
m[1, 2]                # element (1-qator, 2-ustun)
m[0]                   # butun 0-qator
m[:, 1]                # butun 1-ustun (barcha qator)
m[0:2, 1:3]            # kichik jadval (qator 0-1, ustun 1-2)

Ko'p o'lchamli indeks — vergul bilan: m[qator, ustun] (bir element), m[0] (butun qator), m[:, 1] (butun ustun — : barcha qator), m[0:2, 1:3] (kichik jadval). Bu 2D ma'lumot (jadval)dan qator, ustun, yoki bo'lakni tanlash. Ustun tanlash (m[:, i]) — pandas'da ustun tanlash kabi.

2.3. Bool indeks (shartli)

Shartga mos elementlarni tanlash:

python
a = np.array([1, 5, 3, 8, 2, 9])
a > 4                  # [False True False True False True]
a[a > 4]               # [5 8 9] (shartga mos)
a[(a > 2) & (a < 8)]   # VA (& kerak, and emas)
a[(a < 2) | (a > 8)]   # YOKI (|)

Bool indeks — shart (bool massiv) bilan tanlash: a[a > 4] (4'dan katta elementlar). Bir necha shart: & (VA), | (YOKI) — qavs bilan ((a > 2) & (a < 8)), Python and/or emas. Bu ma'lumot filtrlashning asosi (24.7 pandas'da ham). Eng ko'p ishlatiladigan indeks turi.

2.4. Fancy indeks (ro'yxat bilan)

Ma'lum indekslarni ro'yxat bilan:

python
a = np.array([10, 20, 30, 40, 50])
a[[0, 2, 4]]           # [10 30 50] (0, 2, 4-indeks)
a[[4, 0, 2]]           # [50 10 30] (tartib ham)
m[[0, 2], [1, 3]]      # (0,1) va (2,3) elementlar

Fancy indeks — indekslar ro'yxati bilan tanlash: a[[0, 2, 4]] (ko'rsatilgan indekslar). Tartib muhim (a[[4, 0, 2]] — shu tartibda). Kesishdan farq: ixtiyoriy indekslar (ketma-ket emas). Fancy indeks nusxa qaytaradi (kesish — ko'rinish). Ma'lum qatorlarni tanlashda foydali.

2.5. Ko'rinish (view) vs nusxa (copy)

Muhim farq: kesish nusxa emas:

python
a = np.arange(5)       # [0 1 2 3 4]
v = a[1:4]             # ko'rinish (view)
v[0] = 99              # a ham o'zgaradi!
# a → [0 99 2 3 4]

c = a[1:4].copy()      # nusxa
c[0] = 0               # a o'zgarmaydi

Ko'rinish vs nusxa: kesish (slicing) ko'rinish (view) qaytaradi — asl massiv bilan bir xotirani bo'lishadi (view'ni o'zgartirsa, asl ham o'zgaradi). .copy() — mustaqil nusxa. Bu tuzoq: kesishni o'zgartirish kutilmagan ta'sir berishi mumkin. Nusxa kerak bo'lsa — .copy(). Bool/fancy indeks — nusxa.

2.6. Shartli o'zgartirish

Bool indeks bilan qiymatni o'zgartirish:

python
a = np.array([-1, 5, -3, 8, -2])
a[a < 0] = 0           # manfiylarni 0 ga
# a → [0 5 0 8 0]
a[a > 5] = 5           # 5'dan kattani 5 ga (chekla)
np.where(a < 0, 0, a)  # yoki where (nusxa)

Shartli o'zgartirish — bool indeks char tomonda: a[a < 0] = 0 (manfiylarni nolga). Bu ma'lumot tozalash (24.8 — noto'g'ri qiymatlar), cheklash (chegara), almashtirishda juda foydali. np.where — o'xshash, lekin nusxa qaytaradi (asl saqlanadi). Joyida (in-place) o'zgartirish — a[shart] = qiymat.

2.7. Shakl kengaytirish (newaxis)

Yangi o'lcham qo'shish:

python
a = np.array([1, 2, 3])    # shakl (3,)
a[:, np.newaxis]           # shakl (3, 1) — ustun
a[np.newaxis, :]           # shakl (1, 3) — qator
a.reshape(-1, 1)           # (3, 1) — o'xshash

Shakl kengaytirish — np.newaxis (yoki None) yangi o'lcham qo'shadi: a[:, np.newaxis] (1D → ustun (3,1)), a[np.newaxis, :] (qator (1,3)). reshape(-1, 1) — o'xshash (-1 avtomatik hisoblaydi). Bu broadcasting 24.2-bob uchun shaklni moslashda kerak (masalan, ustun broadcast).

2.8. Indekslash — ma'lumot tanlash asosi

Indekslash — ma'lumot tahlilining eng ko'p ishlatiladigan amali: kesish (bo'lak), ko'p o'lchamli (qator/ustun), bool (filtr), fancy (ma'lum indekslar). pandas 24.7-bob DataFrame indekslashi shu tamoyillarga asoslanadi (df[df.narx > 100] — bool indeks). "Kerakli qismini tanla, hammasini emas" — samarali tahlil asosi. View/copy farqini bilish — kutilmagan xatolarni oldini oladi.

3. Tez ma'lumotnoma

python
import numpy as np

# kesish (1D):
a[2:5]; a[:3]; a[7:]; a[::2]; a[-3:]

# ko'p o'lchamli (2D):
m[1, 2]        # element
m[0]           # qator · m[:, 1]  # ustun
m[0:2, 1:3]    # kichik jadval

# bool indeks (filtr):
a[a > 4]
a[(a > 2) & (a < 8)]     # VA (& , qavs)
a[(a < 2) | (a > 8)]     # YOKI (|)

# fancy indeks:
a[[0, 2, 4]]

# view vs copy:
v = a[1:4]           # ko'rinish (asl o'zgaradi)
c = a[1:4].copy()    # nusxa

# shartli o'zgartirish:
a[a < 0] = 0

# shakl:
a[:, np.newaxis]     # ustun (3,1)

Indeks xulosasi

Kesish: a[b:o:q] (view) · 2D: m[qator, ustun] · bool: a[a>4] (filtr)
fancy: a[[i,j]] (nusxa) · view o'zgarish → asl · copy() mustaqil
shartli: a[shart]=qiymat

4. Batafsil misollar

Misollarda NumPy (import numpy as np) bilan sinaladi.

Misol 1 — Kesish va ko'p o'lchamli indeks

python
"""kesish: a[b:o:q] (1D); ko'p o'lchamli: m[qator,ustun], m[:,i] (ustun), m[b:o, b:o]."""

import numpy as np


def main() -> None:
    a = np.arange(10)

    print("=== 1. 1D kesish ===")
    print(f"  a = {a.tolist()}")
    print(f"  a[2:5] = {a[2:5].tolist()}")
    print(f"  a[::2] = {a[::2].tolist()}")
    print(f"  a[-3:] = {a[-3:].tolist()}")

    print("\n=== 2. 2D element va qator/ustun ===")
    m = np.arange(12).reshape(3, 4)
    print(f"  m = {m.tolist()}")
    print(f"  m[1,2] = {m[1, 2]}")
    print(f"  m[0] (qator) = {m[0].tolist()}")
    print(f"  m[:,1] (ustun) = {m[:, 1].tolist()}")

    print("\n=== 3. 2D kichik jadval ===")
    print(f"  m[0:2, 1:3] = {m[0:2, 1:3].tolist()}")

    print("\n=== 4. Oxirgi ustun va qator ===")
    print(f"  m[:,-1] (oxirgi ustun) = {m[:, -1].tolist()}")
    print(f"  m[-1] (oxirgi qator) = {m[-1].tolist()}")
    print("  ⭐ kesish — massiv qismini tanlash (1D, 2D)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. 1D kesish ===
  a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  a[2:5] = [2, 3, 4]
  a[::2] = [0, 2, 4, 6, 8]
  a[-3:] = [7, 8, 9]

=== 2. 2D element va qator/ustun ===
  m = [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11]]
  m[1,2] = 6
  m[0] (qator) = [0, 1, 2, 3]
  m[:,1] (ustun) = [1, 5, 9]

=== 3. 2D kichik jadval ===
  m[0:2, 1:3] = [[1, 2], [5, 6]]

=== 4. Oxirgi ustun va qator ===
  m[:,-1] (oxirgi ustun) = [3, 7, 11]
  m[-1] (oxirgi qator) = [8, 9, 10, 11]
  ⭐ kesish — massiv qismini tanlash (1D, 2D)

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

Misol 2 — Bool indeks (filtr)

python
"""bool indeks: a[a>4] (shart), & (VA), | (YOKI); shartli o'zgartirish a[shart]=qiymat."""

import numpy as np


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

    print("=== 1. Oddiy bool indeks ===")
    print(f"  a = {a.tolist()}")
    print(f"  a > 4 = {(a > 4).tolist()}")
    print(f"  a[a > 4] = {a[a > 4].tolist()}")

    print("\n=== 2. VA (&) — oraliq ===")
    print(f"  a[(a>2)&(a<8)] = {a[(a > 2) & (a < 8)].tolist()}")

    print("\n=== 3. YOKI (|) — chekkalar ===")
    print(f"  a[(a<3)|(a>7)] = {a[(a < 3) | (a > 7)].tolist()}")

    print("\n=== 4. Shartli o'zgartirish ===")
    b = a.copy()
    b[b < 5] = 0                      # 5'dan kichikni 0 ga
    print(f"  b[b<5]=0 → {b.tolist()}")
    print(f"  shartga mos soni: {(a > 4).sum()}")
    print("  ⭐ bool indeks — filtr va shartli o'zgartirish")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Oddiy bool indeks ===
  a = [1, 5, 3, 8, 2, 9, 4, 7]
  a > 4 = [False, True, False, True, False, True, False, True]
  a[a > 4] = [5, 8, 9, 7]

=== 2. VA (&) — oraliq ===
  a[(a>2)&(a<8)] = [5, 3, 4, 7]

=== 3. YOKI (|) — chekkalar ===
  a[(a<3)|(a>7)] = [1, 8, 2, 9]

=== 4. Shartli o'zgartirish ===
  b[b<5]=0 → [0, 5, 0, 8, 0, 9, 0, 7]
  shartga mos soni: 4
  ⭐ bool indeks — filtr va shartli o'zgartirish

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

Misol 3 — Fancy indeks va view/copy

python
"""fancy indeks: a[[i,j,k]] (ro'yxat, nusxa); view (kesish — asl o'zgaradi) vs copy (mustaqil)."""

import numpy as np


def main() -> None:
    print("=== 1. Fancy indeks (ro'yxat bilan) ===")
    a = np.array([10, 20, 30, 40, 50])
    print(f"  a[[0,2,4]] = {a[[0, 2, 4]].tolist()}")
    print(f"  a[[4,0,2]] = {a[[4, 0, 2]].tolist()} (tartib)")

    print("\n=== 2. View (kesish — asl bilan bog'liq) ===")
    x = np.arange(5)
    v = x[1:4]
    v[0] = 99
    print(f"  view o'zgargach x = {x.tolist()} (x[1] ham o'zgardi)")

    print("\n=== 3. Copy (mustaqil nusxa) ===")
    y = np.arange(5)
    c = y[1:4].copy()
    c[0] = 99
    print(f"  copy o'zgargach y = {y.tolist()} (o'zgarmadi)")

    print("\n=== 4. Fancy indeks — nusxa ===")
    z = np.arange(5)
    f = z[[1, 2, 3]]
    f[0] = 99
    print(f"  fancy o'zgargach z = {z.tolist()} (fancy — nusxa)")
    print("  ⭐ kesish=view (bog'liq), copy/fancy=nusxa (mustaqil)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Fancy indeks (ro'yxat bilan) ===
  a[[0,2,4]] = [10, 30, 50]
  a[[4,0,2]] = [50, 10, 30] (tartib)

=== 2. View (kesish — asl bilan bog'liq) ===
  view o'zgargach x = [0, 99, 2, 3, 4] (x[1] ham o'zgardi)

=== 3. Copy (mustaqil nusxa) ===
  copy o'zgargach y = [0, 1, 2, 3, 4] (o'zgarmadi)

=== 4. Fancy indeks — nusxa ===
  fancy o'zgargach z = [0, 1, 2, 3, 4] (fancy — nusxa)
  ⭐ kesish=view (bog'liq), copy/fancy=nusxa (mustaqil)

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

Misol 4 — Amaliy: sensor ma'lumoti tanlash

Real misol: sensor o'lchovlari — anomaliya topish (bool), tanlash (fancy), tozalash (shartli). Bu — ma'lumot tanlash va tozalashning namunasi.

python
"""to'liq tanlash: sensor o'lchovlar, bool filtr (anomaliya), shartli tozalash (chegara), statistika."""

import numpy as np


def main() -> None:
    # 12 soatlik harorat o'lchovlari (ba'zisi xato: -99, 200)
    harorat = np.array([21, 22, -99, 23, 24, 200, 22, 21, 20, -99, 23, 22])

    print("=== 1. Xato qiymatlarni topish (bool) ===")
    xato = (harorat < -50) | (harorat > 60)
    print(f"  xato o'lchovlar soni: {xato.sum()}")
    print(f"  xato qiymatlar: {harorat[xato].tolist()}")

    print("\n=== 2. Tozalash (xatoni o'rtacha bilan almashtirish) ===")
    toza = harorat.copy()
    normal = toza[(toza >= -50) & (toza <= 60)]
    ortacha = int(normal.mean())
    toza[xato] = ortacha
    print(f"  toza: {toza.tolist()}")

    print("\n=== 3. Statistika (toza ma'lumot) ===")
    print(f"  o'rtacha: {round(float(toza.mean()), 1)}")
    print(f"  eng yuqori: {toza.max()}, eng past: {toza.min()}")

    print("\n=== 4. Ma'lum soatlar (fancy indeks) ===")
    tanlangan = toza[[0, 6, 11]]      # 0, 6, 11-soat
    print(f"  0,6,11-soat: {tanlangan.tolist()}")
    issiq = (toza > ortacha).sum()
    print(f"  o'rtachadan issiq soatlar: {issiq}")
    print("  ⭐ bool/fancy indeks — ma'lumot tanlash va tozalash")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Xato qiymatlarni topish (bool) ===
  xato o'lchovlar soni: 3
  xato qiymatlar: [-99, 200, -99]

=== 2. Tozalash (xatoni o'rtacha bilan almashtirish) ===
  toza: [21, 22, 22, 23, 24, 22, 22, 21, 20, 22, 23, 22]

=== 3. Statistika (toza ma'lumot) ===
  o'rtacha: 22.0
  eng yuqori: 24, eng past: 20

=== 4. Ma'lum soatlar (fancy indeks) ===
  0,6,11-soat: [21, 22, 22]
  o'rtachadan issiq soatlar: 3
  ⭐ bool/fancy indeks — ma'lumot tanlash va tozalash

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
"Kesish nusxa" Ko'rinish (view — bog'liq)
"a[a>4] — sikl" Bool indeks (vektorlangan)
"and bilan bool" & (qavs bilan)
"Fancy indeks — view" Nusxa (mustaqil)
"m[:, 1] — qator" Ustun (barcha qator, 1-ustun)
"View o'zgartsa asl saqlanadi" Asl ham o'zgaradi
"Indeks 1 dan" 0 dan (Python)
"Shartli o'zgartirish sikl" a[shart] = qiymat

6. Keng tarqalgan xatolar va yechimlari

1. View'ni nusxa deb o'ylash

python
v = a[1:4]; v[0] = 0      # ⚠️ a ham o'zgaradi
c = a[1:4].copy()         # ✅ mustaqil

2. Bool indeksda and/or

python
a[(a>2) and (a<8)]        # ⚠️ xato (massiv and)
a[(a>2) & (a<8)]          # ✅ (& , qavs)

3. Qavssiz &

python
a[a > 2 & a < 8]          # ⚠️ ustunlik xato
a[(a > 2) & (a < 8)]      # ✅ qavs

4. axis/o'lcham chalkashtirish

python
m[1]      # qator · m[:, 1]  # ustun     # ✅ farqni bil

5. Chegaradan tashqari indeks

python
a[100]                    # ⚠️ IndexError
a[a < len(a)]  # yoki tekshir             # ✅

6. Fancy indeksda shakl kutmaslik

python
a[[0, 2, 4]]              # nusxa ( tartib saqlanadi)

7. Kesishda oxiri kirmasligi

python
a[2:5]                    # 2,3,4 (5 KIRMAYDI)  — ehtiyot

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 24.2-dars (o'tilgan): Broadcasting — shakl (newaxis)
  • 24.4-dars: Unumdorlik — view (nusxasiz tez)
  • 24.7-dars: pandas tanlash — bool indeks
  • 24.8-dars: pandas tozalash — shartli o'zgartirish
  • 25-qism: ML — ma'lumot bo'lish (train/test)

8. Eng yaxshi amaliyotlar

  1. Filtr — bool indeks (a[a > x]).

  2. Bir necha shart — &/| qavs bilan.

  3. Nusxa kerak bo'lsa — .copy() (view emas).

  4. Ustun — m[:, i], qator — m[i].

  5. Shartli o'zgartirish — a[shart] = qiymat.

  6. Fancy indeks — ma'lum indekslar (nusxa).

  7. Kesishda oxiri kirmaydi (2:5 → 2,3,4).

  8. Shakl broadcast uchun — newaxis.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # Kesish nima?
2.  # a[2:5] — nima?
3.  # m[:, 1] — nima?
4.  # bool indeks nima?
5.  # a[a>4] — nima?
6.  # & va | nima?
7.  # fancy indeks nima?
8.  # view nima?
9.  # copy nima?
10. # view o'zgartsa asl-chi?
11. # shartli o'zgartirish?
12. # newaxis nima?
Javoblar
  1. Massiv qismini olish
  2. 2,3,4-elementlar (5 kirmaydi)
  3. 1-ustun (barcha qator)
  4. Shart bilan tanlash
  5. 4'dan katta elementlar
  6. VA / YOKI (bool, qavs bilan)
  7. Indekslar ro'yxati bilan
  8. Ko'rinish (asl bilan bog'liq)
  9. Mustaqil nusxa
  10. Asl ham o'zgaradi
  11. a[shart] = qiymat
  12. Yangi o'lcham qo'shish

Vazifa 2: Xatolarni tuzating

python
1.  a[(a>2) and (a<8)]      # &

2.  a[a > 2 & a < 8]        # qavs

3.  v = a[1:4]; v[0]=0      # copy (asl saqlash)

4.  m[1]  # ustun kerak     # m[:,1]

5.  a[2:5]  # 2,3,4,5 kutildi  # oxiri kirmaydi
Javoblar
python
1.  a[(a>2) & (a<8)]

2.  a[(a > 2) & (a < 8)]

3.  c = a[1:4].copy(); c[0]=0

4.  m[:, 1]  # ustun

5.  a[2:6]  # 5 kerak bo'lsa

Vazifa 3: Kesish

Tanlash:

  1. 1D kesish
  2. 2D qator/ustun
  3. Kichik jadval
  4. Qadam (::2)

Vazifa 4: Bool indeks

Filtr:

  1. Oddiy shart
  2. & (VA)
  3. | (YOKI)
  4. Shartli o'zgartirish

Vazifa 5: View/copy

Farq:

  1. View (kesish)
  2. O'zgartir — asl-chi?
  3. Copy
  4. Fancy (nusxa)

Vazifa 6: Amaliy tozalash

Ma'lumot:

  1. Xato qiymat (bool)
  2. Almashtirish
  3. Statistika
  4. Fancy tanlash

Vazifa 7: O'ylash

NumPy kesish ko'rinish (view) qaytaradi — asl massiv bilan bir xotirani bo'lishadi (nusxa emas). Bu tezlik uchun (nusxa ko'chirish yo'q), lekin tuzoq: view'ni o'zgartirish asl massivga ta'sir qiladi. Nima uchun NumPy nusxa o'rniga view'ni tanlaydi (tezlik/xotira), va bu "aniq nusxa" (explicit copy) tamoyili bilan qanday bog'liq — nega "view — standart, copy — aniq so'ralgan" dizayni mantiqli?

Javob

Qisqa javob: NumPy kesish view (ko'rinish) qaytaradi — asl bilan bir xotirani bo'lishadi, nusxa ko'chirmaydi. Sabab: tezlik va xotira — katta massivda kesish nusxa bo'lsa, har kesish xotirani ko'chiradi (sekin, RAM). View — bepul (faqat "oyna"). Lekin tuzoq: view'ni o'zgartirish asl massivga ta'sir qiladi (kutilmagan). Shu sabab NumPy "view — standart, copy — aniq (.copy())" dizaynini tanladi: eng ko'p holda o'qish (view yetarli, tez), o'zgartirish kerak bo'lganda aniq .copy() (dasturchi niyati aniq). "Aniq nusxa" tamoyili — nusxa qimmat, shuning uchun aniq so'ralgan bo'lsin (yashirin emas). Bu "standart — arzon, qimmat — aniq" dizayn falsafasi.

1. View — tez, arzon

Kesish view — asl massiv "oynasi" (yangi xotira yo'q). Katta massivda bu muhim: nusxa = xotira + vaqt, view = bepul.

2. Tuzoq — kutilmagan ta'sir

View'ni o'zgartirsa, asl o'zgaradi. Buni bilmasangiz — xato (v[0]=0 asl massivni buzadi).

3. Nega "view standart, copy aniq"

Amal Standart
O'qish (ko'p holda) View (tez)
O'zgartirish Aniq .copy()

Eng ko'p holda o'qish (view yetarli). O'zgartirish — kamroq va aniq (dasturchi .copy() yozadi — niyat aniq).

4. "Aniq nusxa" tamoyili

Nusxa qimmat (xotira, vaqt) — shuning uchun yashirin emas, aniq. Dasturchi nusxa kerak deb qaror qiladi (.copy()). Standart — arzon (view); qimmat — aniq so'ralgan.

5. Muhandislik saboqlari

  1. Standart — arzon amal (view — tez)
  2. Qimmat amal — aniq so'ralgan (copy)
  3. View tuzog'ini bil (asl o'zgaradi)
  4. Nusxa kerak bo'lsa — .copy()

6. Xulosa

  1. Kesish — view (tez, xotira arzon)
  2. Tuzoq — view o'zgartsa asl o'zgaradi
  3. "View standart, copy aniq" — mantiqli
  4. Qimmat amal — aniq so'ralgan

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.

Xulosa

Bu darsda NumPy indeks va kesishni o'rgandik.

Eng muhim uch fikr:

  1. Kesish va ko'p o'lchamli indeks. Kesish — a[boshi:oxiri:qadam] (a[2:5] — 2,3,4; oxiri kirmaydi; a[::2] har ikkinchi; a[-3:] oxirgi 3). Ko'p o'lchamli indeks — vergul bilan: m[qator, ustun] (element), m[0] (qator), m[:, 1] (ustun — : barcha qator), m[0:2, 1:3] (kichik jadval). Bu jadvaldan qator, ustun, bo'lakni tanlash — pandas'da ustun tanlash kabi.

  2. Bool indeks va shartli o'zgartirish. Bool indeks — shart bilan: a[a > 4] (mos elementlar); bir necha shart & (VA), | (YOKI) — qavs bilan ((a > 2) & (a < 8)), Python and/or emas. Shartli o'zgartirish — bool indeks char tomonda: a[a < 0] = 0 (manfiylarni nolga). Fancy indeks — indekslar ro'yxati (a[[0, 2, 4]] — tartib muhim, nusxa qaytaradi). Bu ma'lumot filtrlash va tozalashning asosi (24.7–24.8).

  3. View vs copy — muhim farq. Kesish (slicing) ko'rinish (view) qaytaradi — asl massiv bilan bir xotirani bo'lishadi (view'ni o'zgartirsa, asl ham o'zgaradi). .copy() — mustaqil nusxa; bool/fancy indeks ham nusxa. NumPy "view standart, copy aniq" dizayni — tezlik/xotira uchun (nusxa qimmat, shuning uchun aniq .copy() so'ralgan). Bu tuzoq: view'ni o'zgartirish kutilmagan ta'sir berishi mumkin. np.newaxis — shakl kengaytirish (broadcasting uchun). Indekslash — ma'lumot tanlashning eng ko'p ishlatiladigan amali.

Keyingi darsda NumPy unumdorlik ni o'rganamiz: vektorlashtirish nega tez, xotira tejash, dtype tanlovi — katta ma'lumot bilan samarali ishlash.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
24.3-dars: NumPy — indeks va shakl — IlmHamroh