2.13-dars: Saqlash va tuzoqlar (copy vs view)

2-QISM — NUMPY · 13-dars

1. Kirish va motivatsiya

NumPy bilan ishlaganingizda ikkita amaliy masala doim uchraydi: (1) massivni faylga saqlash (hisoblangan natijani keyingi safar qayta o'qish — save/load); (2) copy vs view tuzog'i — ba'zi amallar mustaqil nusxa, ba'zilari asl massivga bog'liq "ko'rinish" (view) qaytaradi, va buni bilmaslik jim xatolarga olib keladi. O'tgan darslarda slice 2.4-bob va reshape 2.7-bob view qaytarishini ko'rdik; endi bu mavzuni to'liq yig'amiz — qaysi amal nusxa, qaysi view, va qanday xavfsiz ishlash. Nega muhim? (1) Saqlash — hisoblangan ma'lumotni qayta ishlatish (vaqt tejash); (2) Xavfsizlik — view tuzog'i asl ma'lumotni jim buzadi (eng ko'p uchraydigan NumPy xatosi); (3) Ongli qaror — qachon nusxa (xavfsiz), qachon view (tez). Bu dars saqlash va copy/view tuzog'ini chuqur o'rgatadi — ma'lumotni saqlash va xavfsiz ishlash.

Saqlash va tuzoqlar — fayl va copy/view: np.save/np.load (bitta massiv — .npy), np.savez (ko'p massiv — .npz), matn (savetxt/loadtxt — CSV), view (asl xotiraga bog'liq — slice/reshape/transpose, 2.4/2.7), copy (mustaqil — .copy(), flatten, fancy indeks), .base (view-mi tekshirish), xavfsiz ishlash (o'zgartmoqchi bo'lsa .copy()). Foydalanish: natija saqlash, xavfsiz o'zgartirish, ongli qaror. Bu 2.4 (slice view), 2.7 (reshape) bilan bog'liq. Saqlash — save/load. Tuzoq — copy vs view. Xavfsiz.

Real vaziyat. Data Scientist 2 soat hisoblab tozalangan ma'lumotni (katta massiv) saqlamoqchi edi (har safar qayta hisoblama uchun) — np.save("toza.npy", data), keyin data = np.load("toza.npy") (bir zumda o'qidi — 2 soat tejadi). Keyin view tuzog'iga duch keldi: qism = data[:100]; qism[qism < 0] = 0 — asl data ham o'zgardi (slice view — 2.4!); model noto'g'ri o'rgandi (jim xato — soatlab debug). .copy() bilan tuzatdi (qism = data[:100].copy()). .base bilan tekshirdi (view-mi). Saqlash vaqt tejadi, copy/view bilish xato oldini (asl buzilmasin). Saqlash va tuzoq — amaliy NumPy (natija saqlash, xavfsiz ishlash).

Bu darsda saqlash va copy/view tuzog'ini o'rganamiz.

Bu darsda:

• save va load (faylga saqlash)
• copy vs view (tuzoq)
• Qaysi amal nusxa, qaysi view
• .base (view tekshirish)
• Xavfsiz ishlash
• Saqlash amaliyoti
• copy/view tuzoqlari
• Amaliy: saqlash modeli

ℹ Misollar real numpy bilan (deterministik) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. save va load (faylga saqlash)

Massivni faylga:

import numpy as np

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

# BITTA massiv (.npy)
np.save("massiv.npy", a)
b = np.load("massiv.npy")     # qayta o'qish

# KO'P massiv (.npz)
np.savez("ikki.npz", x=a, y=a*2)
data = np.load("ikki.npz")
data["x"]                      # nomi bo'yicha

# MATN (CSV — boshqa dasturlar uchun)
np.savetxt("matn.csv", a, delimiter=",")

save va load (faylga saqlash) — massivni faylga: np.save (bitta massiv — .npy binar format, tez/aniq), np.load (qayta o'qish), np.savez (ko'p massiv — .npz, nomi bo'yicha), savetxt/loadtxt (matn — CSV, boshqa dasturlar uchun). Sabab: hisoblangan natijani qayta ishlatish (2 soat hisob — bir marta, keyin load bir zumda; vaqt tejash); .npy binar (tez, aniq — float saqlanadi), CSV (matn — Excel/boshqa o'qiydi, lekin sekinroq/kattaroq). save/load — faylga (.npy binar, .npz ko'p, CSV matn). Saqlash. Qayta ishlatish.

2.2. copy vs view (tuzoq)

Mustaqil nusxa yoki bog'liq ko'rinish:

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

# VIEW — asl xotiraga bog'liq (slice, reshape)
v = a[:3]              # view
v[0] = 999            # a ham o'zgaradi! → [999, 2, 3, 4, 5]

# COPY — mustaqil nusxa
c = a[:3].copy()      # copy
c[0] = 999            # a o'zgarmaydi

copy vs view (tuzoq) — mustaqil nusxa yoki bog'liq ko'rinish: view (asl xotiraga bog'liq — slice/reshape/transpose; o'zgartsa asl o'zgaradi — 2.4), copy (mustaqil nusxa — .copy(); asl saqlanadi). Sabab: NumPy tezlik/xotira uchun ko'p amalda view (nusxa olmaydi — tez, kam xotira; 2.4/2.6); lekin kutilmagan (view o'zgartsa asl buziladi — jim xato). Eng ko'p NumPy tuzog'I (view — Python ro'yxatdan farq; ro'yxat slice nusxa, NumPy slice view). Yechim: o'zgartmoqchi bo'lsa .copy() (mustaqil — asl xavfsiz). copy vs view — view bog'liq, copy mustaqil. Tuzoq. .copy().

2.3. Qaysi amal nusxa, qaysi view

Qaysi amal nusxa, qaysi view:

VIEW qaytaradi (asl xotiraga bog'liq — tez):
   - slice (a[:3], a[1:4])           # 2.4
   - reshape (a.reshape(3, 4))        # 2.7
   - transpose (a.T)                  # 2.7
   - ravel (a.ravel())                # 2.7

COPY qaytaradi (mustaqil nusxa — xavfsiz):
   - .copy() (aniq nusxa)
   - flatten (a.flatten())            # 2.7
   - fancy indeks (a[[0, 2, 4]])      # ro'yxat indeks
   - boolean indeks (a[a > 2])        # 2.9
   - arifmetik (a * 2, a + b)         # yangi massiv

Qaysi amal nusxa, qaysi view — bilish muhim: VIEW (asl xotiraga bog'liq — tez): slice 2.4-bob, reshape/transpose/ravel 2.7-bob; COPY (mustaqil — xavfsiz): .copy(), flatten 2.7-bob, fancy indeks (a[[0,2,4]] — ro'yxat indeks), boolean indeks (a[a > 2] — 2.9), arifmetik (a * 2, a + b — yangi massiv). Sabab: qaysi amal view/copy bilmasa — tuzoq (view o'zgartsa asl); slice/reshape view (bog'liq — ehtiyot), boolean/fancy/arifmetik copy (mustaqil — xavfsiz). Umumiy: oddiy indeks/reshape view, shart/ro'yxat/amal copy. Qaysi — slice/reshape view, boolean/fancy/amal copy. Bilish. Tuzoq.

2.4. .base (view tekshirish)

.base (view tekshirish) — view-mi bilish: massiv.base — agar view bo'lsa asl massivni ko'rsatadi (is not None), agar copy/original bo'lsa None:

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

v = a[:3]              # view
v.base is not None    # True (view — asl bor)

c = a[:3].copy()      # copy
c.base is None        # True (copy — mustaqil)

Sabab: ba'zan view-mi copy-mi bilmasiz (kod murakkab — qaysi amal); .base tekshiradi (view — asl bor, is not None; copy — None); debug uchun (asl o'zgardi-mi — view-mi tekshir). v.base — view'ning asl massivi. .base — view tekshirish (is not None view, None copy). Tekshirish. Debug.

2.5. Xavfsiz ishlash

Xavfsiz ishlash — view tuzog'ini oldini olish: (1) o'zgartmoqchi bo'lsa .copy() (slice/reshapeni o'zgartmoqchi — a[:3].copy(), asl saqlanadi); (2) o'zgartmaslik (view faqat o'qish uchun — o'zgartmasa muammo yo'q, view tez); (3) funksiyada ehtiyot (funksiyaga massiv berish — ichida o'zgartsa asl; .copy() yoki hujjatla); (4) .base tekshir (view-mi — debug); (5) arifmetik xavfsiz (a * 2 — yangi massiv, asl saqlanadi; ko'p holda copy kerak emas). Sabab: view tuzog'I jim (asl buziladi — sezilmaydi); xavfsiz ishlash oldini oladi (.copy() o'zgartmoqchi bo'lsa, o'qish uchun view). Muvozanat: tezlik (view — o'qish) vs xavfsizlik (copy — o'zgartish). Xavfsiz ishlash — .copy() (o'zgartish), view (o'qish). Oldini olish. Muvozanat.

2.6. Saqlash amaliyoti

Saqlash va copy/view amaliyoti: np.save/load (bitta massiv — .npy binar, tez); savez (ko'p massiv — .npz); savetxt (CSV — boshqa dasturlar); copy vs view (bilish — slice/reshape view, boolean/fancy/amal copy); .copy() (o'zgartmoqchi bo'lsa — xavfsiz); .base (view tekshir — debug); arifmetik (a * 2 — yangi massiv, xavfsiz); saqlash format (.npy tez/aniq, CSV moslashuvchan). Tuzoqlar: view o'zgartish (asl buziladi — .copy()), CSV float aniqlik (matn — yaxlitlash), fayl yo'li (mavjud emas — xato), copy/view chalkash (qaysi amal). Amaliyot — save/load, copy vs view, .copy(), .base. Saqlash. Xavfsiz.

2.7. copy/view tuzoqlari

Saqlash/copy asosiy tuzoqlari: view o'zgartish (slice/reshape view — o'zgartsa asl buziladi; eng ko'p NumPy tuzog'I — .copy() kerak bo'lsa); copy/view chalkash (qaysi amal — slice view, boolean copy; bilmasa xato); CSV aniqlik (savetxt — matn, float yaxlitlash mumkin; aniq kerak bo'lsa .npy binar); fayl yo'li (load — fayl mavjud emas, xato; yo'l tekshir); .npy versiya (binar — NumPy o'qiydi, boshqa dastur emas; CSV umumiy); katta fayl (.npy katta massiv — disk joyi; siqish savez_compressed); funksiya o'zgartish (funksiyaga massiv — ichida view o'zgartsa asl; ehtiyot/.copy()). Sabab: saqlash/copy format/bog'liqlik nozik (view, CSV aniqlik, fayl yo'l — jim xato yoki yo'qotish). Yechim: .copy() o'zgartish, .npy aniq, yo'l tekshir. Tuzoqlar — view o'zgartish, copy/view chalkash, CSV aniqlik.

2.8. Saqlash va tuzoq — ma'lumotni saqlash va xavfsiz ishlash

Saqlash va copy/view asosiy g'oyasi — ma'lumotni saqlash va xavfsiz ishlash: (1) saqlash — hisoblangan natijani qayta ishlatish (save/load — 2 soat hisob bir marta, keyin bir zumda o'qish; vaqt tejash); .npy (binar — tez/aniq), CSV (umumiy — boshqa dastur); (2) copy vs view — NumPy amallari view (asl xotiraga bog'liq — tez/kam xotira: slice/reshape/transpose) yoki copy (mustaqil — xavfsiz: .copy()/flatten/boolean/fancy/arifmetik); eng ko'p NumPy tuzog'I (view o'zgartsa asl buziladi — jim xato). Xavfsiz ishlash: o'zgartmoqchi bo'lsa .copy() (asl saqlanadi), o'qish uchun view (tez); .base (view tekshir — debug). Data Science'da doim (natija saqlash — vaqt tejash; view tuzog'I — asl buzilmasin, model to'g'ri). Bu 2.4 (slice view), 2.7 (reshape view) yig'indisi va butun NumPy uchun (xavfsiz ishlash). Saqlash va tuzoq — ma'lumotni saqlash va xavfsiz ishlash (save/load, copy vs view). Amaliy. Xavfsiz.

3. Tez ma'lumotnoma

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

# SAQLASH:
np.save("m.npy", a)          # bitta (binar — tez/aniq)
b = np.load("m.npy")         # o'qish
np.savez("ikki.npz", x=a, y=a*2)   # ko'p massiv
np.savetxt("m.csv", a, delimiter=",")   # CSV (umumiy)

# COPY vs VIEW:
v = a[:3]          # VIEW (asl xotira — o'zgartsa asl!)
c = a[:3].copy()   # COPY (mustaqil — xavfsiz)

# QAYSI AMAL:
#   VIEW: slice, reshape, transpose, ravel (bog'liq)
#   COPY: .copy(), flatten, fancy [[0,2]], boolean [a>2], a*2

# .base (view tekshirish):
v.base is not None    # True (view)
c.base is None        # True (copy)

# XAVFSIZ:
qism = a[:3].copy()   # o'zgartmoqchi bo'lsa .copy()

QOIDA: slice/reshape VIEW · o'zgartmoqchi bo'lsa .copy() · .npy aniq

Saqlash xulosasi

Saqlash va tuzoq — ma'lumotni saqlash va xavfsiz ishlash
save/load — faylga (.npy binar, .npz ko'p, CSV umumiy)
view — asl xotiraga bog'liq (slice, reshape — o'zgartsa asl)
copy — mustaqil (.copy(), boolean, fancy, arifmetik)
Xavfsiz — o'zgartmoqchi bo'lsa .copy() (asl saqlanadi)

4. Batafsil misollar

Misollar real numpy bilan (deterministik) ishlaydi.

Misol 1 — save va load

"""save va load: faylga saqlash (real numpy)."""

import os
import tempfile
import numpy as np


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

    print("=== 1. save va load ===")
    yol = os.path.join(papka, "massiv.npy")
    np.save(yol, a)
    b = np.load(yol)
    print(f"  saqlangan va o'qilgan: {b}")

    print("\n=== 2. Bir xil ===")
    print(f"  asl bilan bir xil: {np.array_equal(a, b)}")

    print("\n=== 3. Ko'p massiv (savez) ===")
    yol2 = os.path.join(papka, "ikki.npz")
    np.savez(yol2, x=a, y=a * 2)
    data = np.load(yol2)
    print(f"  x: {data['x']}, y: {data['y']}")

    print("\n=== 4. Tushuntirish ===")
    print("  .npy binar (tez/aniq) · .npz ko'p massiv")
    print("  ⭐ save/load — natijani qayta ishlatish")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. save va load ===
  saqlangan va o'qilgan: [1 2 3 4 5]

=== 2. Bir xil ===
  asl bilan bir xil: True

=== 3. Ko'p massiv (savez) ===
  x: [1 2 3 4 5], y: [ 2  4  6  8 10]

=== 4. Tushuntirish ===
  .npy binar (tez/aniq) · .npz ko'p massiv
  ⭐ save/load — natijani qayta ishlatish

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — copy vs view

"""copy vs view: tuzoq (real numpy)."""

import numpy as np


def main() -> None:
    print("=== 1. VIEW (asl o'zgaradi) ===")
    a = np.array([1, 2, 3, 4, 5])
    v = a[:3]
    v[0] = 999
    print(f"  view o'zgardi → a: {a} (asl ham!)")

    print("\n=== 2. COPY (mustaqil) ===")
    a2 = np.array([1, 2, 3, 4, 5])
    c = a2[:3].copy()
    c[0] = 999
    print(f"  copy o'zgardi → a2: {a2} (saqlandi)")

    print("\n=== 3. Farq ===")
    print("  view — asl xotira · copy — mustaqil")

    print("\n=== 4. Yechim ===")
    print("  o'zgartmoqchi bo'lsa .copy()")
    print("  ⭐ copy vs view — eng ko'p NumPy tuzog'i")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. VIEW (asl o'zgaradi) ===
  view o'zgardi → a: [999   2   3   4   5] (asl ham!)

=== 2. COPY (mustaqil) ===
  copy o'zgardi → a2: [1 2 3 4 5] (saqlandi)

=== 3. Farq ===
  view — asl xotira · copy — mustaqil

=== 4. Yechim ===
  o'zgartmoqchi bo'lsa .copy()
  ⭐ copy vs view — eng ko'p NumPy tuzog'i

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — Qaysi amal nusxa, qaysi view

"""Qaysi amal nusxa, qaysi view (real numpy)."""

import numpy as np


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

    print("=== 1. VIEW amallari ===")
    print(f"  slice base None emas: {a[:3].base is not None}")
    print(f"  reshape base None emas: {a.reshape(-1).base is not None}")

    print("\n=== 2. COPY amallari ===")
    print(f"  .copy() base None: {a.copy().base is None}")
    print(f"  boolean base None: {a[a > 2].base is None}")

    print("\n=== 3. Fancy indeks (copy) ===")
    print(f"  fancy [[0,2,4]] base None: {a[[0, 2, 4]].base is None}")

    print("\n=== 4. Arifmetik (copy) ===")
    print(f"  a*2 base None: {(a * 2).base is None}")
    print("  ⭐ slice/reshape VIEW · boolean/fancy/amal COPY")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. VIEW amallari ===
  slice base None emas: True
  reshape base None emas: True

=== 2. COPY amallari ===
  .copy() base None: True
  boolean base None: True

=== 3. Fancy indeks (copy) ===
  fancy [[0,2,4]] base None: True

=== 4. Arifmetik (copy) ===
  a*2 base None: True
  ⭐ slice/reshape VIEW · boolean/fancy/amal COPY

Nima ko'rsatdi: 2.3-bo'lim.

Misol 4 — Xavfsiz ishlash

"""Xavfsiz ishlash: .copy() (real numpy)."""

import numpy as np


def main() -> None:
    print("=== 1. Xato: view o'zgartirish ===")
    data = np.array([5, -2, 3, -1, 8])
    qism = data[:3]
    qism[qism < 0] = 0
    print(f"  data (buzildi): {data}")

    print("\n=== 2. To'g'ri: .copy() ===")
    data2 = np.array([5, -2, 3, -1, 8])
    qism2 = data2[:3].copy()
    qism2[qism2 < 0] = 0
    print(f"  data2 (saqlandi): {data2}")

    print("\n=== 3. .base tekshirish ===")
    a = np.array([1, 2, 3])
    print(f"  slice view: {a[:2].base is not None}")

    print("\n=== 4. Arifmetik xavfsiz ===")
    b = np.array([1, 2, 3])
    yangi = b * 2
    print(f"  b*2 asl saqladi: {b} (yangi: {yangi})")
    print("  ⭐ Xavfsiz — o'zgartmoqchi bo'lsa .copy()")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Xato: view o'zgartirish ===
  data (buzildi): [ 5  0  3 -1  8]

=== 2. To'g'ri: .copy() ===
  data2 (saqlandi): [ 5 -2  3 -1  8]

=== 3. .base tekshirish ===
  slice view: True

=== 4. Arifmetik xavfsiz ===
  b*2 asl saqladi: [1 2 3] (yangi: [2 4 6])
  ⭐ Xavfsiz — o'zgartmoqchi bo'lsa .copy()

Nima ko'rsatdi: 2.5-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. View o'zgartirish

qism = a[:3]; qism[0] = 9   # asl o'zgaradi                  # ⚠️
qism = a[:3].copy(); qism[0] = 9   # mustaqil                 # ✅

2. copy/view chalkash

# slice copy deb o'ylash (view!)                             # ⚠️
# slice/reshape view, boolean/fancy copy                      # ✅

3. CSV aniqlik

np.savetxt("f.csv", data)   # float yaxlitlash               # ⚠️
np.save("f.npy", data)   # aniq (binar)                       # ✅

4. Fayl yo'li

np.load("yoq.npy")   # fayl mavjud emas (xato)               # ⚠️
# yo'lni tekshir (os.path.exists)                             # ✅

5. Funksiyada o'zgartirish

def f(arr): arr[0] = 9   # asl o'zgaradi (view/original)     # ⚠️
def f(arr): arr = arr.copy(); ...   # mustaqil                # ✅

6. Keraksiz copy

b = (a * 2).copy()   # a*2 allaqachon copy                   # ⚠️
b = a * 2   # yangi massiv (copy kerak emas)                   # ✅

7. .base noto'g'ri o'qish

a.base   # original uchun None (view uchun asl)              # ⚠️
a.base is not None   # view-mi tekshir                        # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 2.4-dars (o'tilgan): Slice (view)
• 2.7-dars (o'tilgan): Reshape (view), flatten (copy)
• 2.9-dars (o'tilgan): Boolean indeks (copy)
• 3-qism: Pandas (.copy() — SettingWithCopyWarning)
• 6-qism: Tozalash (ma'lumotni saqlash, xavfsiz o'zgartirish)

8. Eng yaxshi amaliyotlar

1. np.save/load — natijani saqlash (.npy aniq).

2. slice/reshape — view (asl xotira).

3. boolean/fancy/arifmetik — copy (mustaqil).

4. O'zgartmoqchi bo'lsa .copy() (xavfsiz).

5. .base — view tekshirish (debug).

6. CSV umumiy, .npy aniq (float).

7. Funksiyada ehtiyot (view o'zgartirish).

8. Saqlash va tuzoq — xavfsiz ishlash.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # save nima?
2.  # .npy vs CSV?
3.  # savez nima?
4.  # view nima?
5.  # copy nima?
6.  # slice view yoki copy?
7.  # boolean indeks?
8.  # arifmetik (a*2)?
9.  # .base nima?
10. # view o'zgartirish?
11. # .copy() qachon?
12. # nega view tuzoq?

Vazifa 2: Xatolarni tuzating

1.  qism = a[:3]; qism[0] = 9   # asl saqlansin

2.  # slice copy deb

3.  np.savetxt("f.csv", data)   # aniq kerak

4.  def f(arr): arr[0] = 9   # asl o'zgarmasin

5.  b = (a * 2).copy()   # keraksiz

1.  qism = a[:3].copy()

2.  slice — view (boolean — copy)

3.  np.save("f.npy", data)   # binar aniq

4.  arr = arr.copy() (funksiyada)

5.  b = a * 2   # allaqachon copy

Vazifa 3: Saqlash

Modellang:

1. save
2. load
3. savez
4. CSV

Vazifa 4: copy/view

Modellang:

1. View
2. Copy
3. Bog'liq
4. Mustaqil

Vazifa 5: Qaysi amal

Modellang:

1. Slice (view)
2. Boolean (copy)
3. Fancy (copy)
4. Arifmetik (copy)

Vazifa 6: Xavfsiz

Modellang:

1. .copy()
2. O'qish
3. .base
4. Funksiya

Vazifa 7: O'ylash

NumPy'ning "copy vs view" tuzog'i eng ko'p uchraydigan xatolardan biri: ba'zi amallar (slice, reshape) asl massivga bog'liq view, boshqalari (boolean indeks, arifmetik) mustaqil copy qaytaradi. Nima uchun NumPy bu nomuvofiqlikni saqlab qoladi (nega hamma amal bir xil — hammasi view yoki hammasi copy — emas), va bu "tezlik vs xavfsizlik" savdosi bilan qanday bog'liq?

Nimani mustahkamlaydi: 2.2, 2.3-bo'limlar.

Xulosa

Bu darsda saqlash va copy/view tuzog'ini o'rgandik.

Eng muhim uch fikr:

1. Saqlash. save va load — massivni faylga: np.save (bitta massiv — .npy binar, tez/aniq), np.load (qayta o'qish), np.savez (ko'p massiv — .npz), savetxt/loadtxt (matn — CSV, boshqa dasturlar). Hisoblangan natijani qayta ishlatish (vaqt tejash — 2 soat hisob bir marta, keyin bir zumda); .npy binar (aniq — float), CSV matn (umumiy — lekin yaxlitlash mumkin).

2. copy vs view. view (asl xotiraga bog'liq — o'zgartsa asl o'zgaradi) yoki copy (mustaqil — .copy()). Qaysi amal: VIEW — slice 2.4-bob, reshape/transpose/ravel 2.7-bob; COPY — .copy(), flatten 2.7-bob, fancy indeks (a[[0,2,4]]), boolean indeks (a[a > 2] — 2.9), arifmetik (a * 2). Eng ko'p NumPy tuzog'I (view o'zgartsa asl buziladi — jim xato). .base (view tekshir — is not None view, None copy).

3. Xavfsiz ishlash. Xavfsiz — o'zgartmoqchi bo'lsa .copy() (asl saqlanadi), o'qish uchun view (tez); funksiyada ehtiyot (view o'zgartsa asl). Saqlash va tuzoq — ma'lumotni saqlash va xavfsiz ishlash (save/load — vaqt tejash; copy/view — asl buzilmasin). Nomuvofiqlik (slice view, boolean copy) — amal tabiati (uzluksiz — view/tez; tarqoq/yangi — copy/majbur); tezlik vs xavfsizlik savdosi (NumPy tezlik — view; .copy() xavfsizlik). Tuzoqlar: view o'zgartish (.copy()), copy/view chalkash, CSV aniqlik (.npy), funksiya o'zgartish.

Keyingi darsda NumPy amaliy loyihani bajaramiz: butun NumPy bilimini (massiv, indekslash, vektorlashtirish, broadcasting, agregatsiya, shart) real ma'lumot tahlilida qo'llab — 2-qismni yakunlaymiz.