2.12-dars: Tezlik (sikl vs vektor)

2-QISM — NUMPY · 12-dars

1. Kirish va motivatsiya

Bir necha darsda "NumPy tez", "vektorlashtirish tez" dedik. Endi buni o'lchaymiz — Python siklini NumPy vektorlashtirilgan amali bilan taqqoslab, tezlik farqini o'z ko'zimiz bilan ko'ramiz. Bu dars nazariy emas, amaliy: time moduli bilan vaqtni o'lchash, natijani solishtirish, va NumPy tezligining sabablarini chuqurroq tushunish. Nega muhim? (1) Isbot — "tez" degan gap emas, raqam (10-100x farq); (2) Qaror — qachon NumPy, qachon Python (katta ma'lumot — NumPy shart); (3) Optimallashtirish — kodni tezlashtirish (sikl → vektor). Data Science'da million qatorli ma'lumot bilan ishlaganda tezlik hal qiluvchi (sekin kod — ish to'xtaydi). Bu dars tezlikni o'lchash va tushunishni o'rgatadi — amaliy samaradorlik.

Tezlik (sikl vs vektor) — Python sikl va NumPy vektor taqqoslash: vaqt o'lchash (time.perf_counter — boshlanish/oxir farqi), sikl (Python for — sekin, har element interpretator), vektor (NumPy a * 2 — tez, C tilida), farq (10-100x — element soni ko'p bo'lsa farq katta), sabab (C tilida, siklsiz, uzluksiz xotira — 2.5), qaror (katta ma'lumot — NumPy shart). Foydalanish: isbot, optimallashtirish, qaror. Bu 2.5 (vektorlashtirish), 2.1 (xotira) bilan bog'liq. Tezlik — sikl vs vektor. O'lchash. 10-100x.

Real vaziyat. Data Scientist 1 million sonli massivni 2 ga ko'paytirmoqchi edi. Ikki usul sinab ko'rdi: (1) Python sikl — for i in range(len(a)): natija[i] = a[i] * 2 (~0.3 soniya); (2) NumPy vektor — natija = a * 2 (~0.003 soniya) — 100x tez. time.perf_counter bilan o'lchadi (isbot — raqam). Million qatorda farq sezilarli (soniya vs millisekund); real loyihada (o'nlab million qator, ko'p amal) — sikl daqiqalar (ish to'xtaydi), vektor soniya. NumPy tezligi isbotlanadi (o'lchash — 100x). Tezlik — amaliy samaradorlik (katta ma'lumot uchun hal qiluvchi).

Bu darsda tezlik va o'lchashni o'rganamiz.

Bu darsda:

• Vaqt o'lchash (time)
• Sikl vs vektor taqqoslash
• Tezlik sabablari (chuqurroq)
• Xotira samaradorligi
• Qachon NumPy, qachon Python
• Tezlik amaliyoti
• Tezlik tuzoqlari
• Amaliy: optimallashtirish modeli

ℹ Misollar real numpy bilan (deterministik) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. Vaqt o'lchash (time)

Vaqtni o'lchash:

import time
import numpy as np

# perf_counter — aniq vaqt (soniyada)
boshlanish = time.perf_counter()
# ... kod ...
oxir = time.perf_counter()
vaqt = oxir - boshlanish   # o'tgan vaqt

# NumPy vektor
a = np.arange(1_000_000)
t0 = time.perf_counter()
natija = a * 2
t1 = time.perf_counter()
# t1 - t0 → juda kichik (millisekund)

Vaqt o'lchash (time) — kod qancha vaqt oladi: time.perf_counter() (aniq vaqt — soniyada), boshlanish va oxir farqi (oxir - boshlanish — o'tgan vaqt). Sabab: tezlikni isbotlash uchun o'lchash kerak ("tez" gap emas — raqam); perf_counter aniq (yuqori aniqlik — kichik vaqt ham). Amaldan oldin va keyin vaqt olinadi (farq — amal vaqti). time.time (oddiy), perf_counter (aniqroq — o'lchash uchun). Vaqt o'lchash — perf_counter (boshlanish/oxir farqi). Aniq. Isbot.

2.2. Sikl vs vektor taqqoslash

Ikki usulni o'lchash:

import time
import numpy as np

a = np.arange(1_000_000)

# 1. Python sikl (SEKIN)
t0 = time.perf_counter()
natija1 = [x * 2 for x in a]
t1 = time.perf_counter()
sikl_vaqt = t1 - t0

# 2. NumPy vektor (TEZ)
t0 = time.perf_counter()
natija2 = a * 2
t1 = time.perf_counter()
vektor_vaqt = t1 - t0

# vektor 10-100x tez!

Sikl vs vektor taqqoslash — ikki usulni o'lchash: Python sikl ([x * 2 for x in a] — sekin, har element interpretator), NumPy vektor (a * 2 — tez, C tilida); har birini perf_counter bilan o'lchab taqqoslash. Sabab: farqni ko'rish (10-100x — raqam bilan isbot); ikki usul bir xil natija (a * 2), lekin turli tezlik (sikl sekin, vektor tez). Element soni ko'p bo'lsa (million) farq katta (kichik massivda farq sezilmaydi — overhead). Vektor doim tez (katta ma'lumotda). Sikl vs vektor — o'lchash, taqqoslash (10-100x). Vektor tez. Isbot.

2.3. Tezlik sabablari (chuqurroq)

Tezlik sabablari (chuqurroq — 2.5 davomi): (1) C tilida — NumPy amallari C (kompilyatsiya — mashinaga yaqin, tez); Python interpretatsiya (har qadam o'qi/tekshir — sekin); (2) siklsiz — a * 2 bir buyruq (C ichida sikl — tez), Python for million marta interpretator (overhead har element); (3) xom sonlar — ndarray xom sonlar (2.1 — obyekt emas; Python ro'yxat — har element obyekt, quti); (4) uzluksiz xotira — ndarray ketma-ket (2.1 — kesh do'st, tez o'qish; ro'yxat tarqoq — sekin); (5) SIMD — zamonaviy protsessor bir vaqtda ko'p son (vektorlashtirilgan — C dan foydalanadi). Sabab: bu omillar birgalikda NumPy'ni tez qiladi (C + siklsiz + xom son + uzluksiz xotira + SIMD); Python sekin (interpretator + obyekt + tarqoq). Tezlik sabablari — C, siklsiz, xom son, uzluksiz xotira. Birgalikda. Tez.

2.4. Xotira samaradorligi

Xotira samaradorligi — NumPy kam xotira: ndarray xom sonlar (2.1 — int64 har element 8 bayt, aniq); Python ro'yxat obyektlar (har int — obyekt, ~28 bayt + ko'rsatkich — ko'p xotira). Sabab: NumPy kam xotira (xom son — 8 bayt; ro'yxat — 28+ bayt har element; million son — NumPy 8 MB, ro'yxat 28+ MB); kam xotira tez (kesh do'st — 2.1, uzluksiz o'qish); to'g'ri dtype (2.3 — int8 kichik ma'lumotda, kam xotira). a.nbytes (massiv xotirasi — bayt). Katta ma'lumotda xotira muhim (RAM cheklangan — ro'yxat sig'maydi, NumPy sig'adi). Xotira samaradorligi — xom son (kam xotira). NumPy tejamli. Kesh do'st.

2.5. Qachon NumPy, qachon Python

Qachon NumPy, qachon Python: NumPy — (1) son massivlari (bir tur — int/float; matematik amal — vektorlashtirilgan tez); (2) katta ma'lumot (million+ qator — sikl sekin, vektor shart); (3) matematika (chiziqli algebra, statistika — NumPy funksiyalari); (4) tezlik muhim (takror hisob — ML). Python (oddiy) — (1) kichik ma'lumot (kam element — farq sezilmaydi, oddiy kod); (2) aralash tur (matn, son, obyekt — ro'yxat moslashuvchan); (3) oddiy mantiq (murakkab shart — sikl o'qilishli); (4) NumPy ortiqcha (bir amal — import behuda). Sabab: NumPy son/katta/tez uchun (vektorlashtirish); Python kichik/aralash/oddiy uchun (moslashuvchan). To'g'ri vosita kontekstga (katta son — NumPy, kichik aralash — Python). Qachon — NumPy (son, katta, tez), Python (kichik, aralash). Kontekst. Vosita.

2.6. Tezlik amaliyoti

Tezlik amaliyoti: perf_counter (vaqt o'lchash — isbot); sikl vs vektor (taqqoslash — 10-100x); vektorlashtirish (sikl → vektor — optimallashtirish, 2.5); katta ma'lumot (NumPy shart — sikl sekin); xotira (nbytes, dtype — 2.3); profillash (sekin joyni topish — o'lchash); kichik massivda farq yo'q (overhead — million+ da seziladi); qaror (kontekst — NumPy yoki Python). Tuzoqlar: sikl katta ma'lumotda (sekin — vektorlashtir), kichik massivda o'lchash (farq sezilmaydi — overhead), NumPy ichida sikl (for NumPy massivda — sekin, vektorlashtir), noto'g'ri dtype (ko'p xotira). Amaliyot — o'lchash, taqqoslash, vektorlashtirish. Isbot. Optimallashtirish.

2.7. Tezlik tuzoqlari

Tezlik asosiy tuzoqlari: NumPy ichida sikl (for x in massiv — NumPy massivda sikl sekin; vektorlashtir — a * 2; eng ko'p xato — NumPy'ning tezligini yo'qotish); kichik massivda o'lchash (kam element — farq sezilmaydi yoki sikl tezroq; overhead — NumPy import/tayyorgarlik; million+ da NumPy tez); erta optimallashtirish (oddiy kod ishlar edi — behuda optimallashtirish murakkablashtiradi; avval to'g'ri, keyin tez agar sekin bo'lsa); noto'g'ri dtype (float64 kichik ma'lumotda — ko'p xotira; int8 yetganda — 2.3); nusxa isrof (keraksiz .copy() — xotira/vaqt; view yetganda — 2.13); ro'yxat → massiv har amalda (np.array(list) takror — sekin; bir marta); append sikl (massivga np.append sikl ichida — har safar nusxa, sekin; ro'yxatga yig'ib keyin massiv). Sabab: tezlik kontekst/usul nozik (NumPy ichida sikl, kichik massiv, erta optimallashtirish — behuda yoki sekin). Yechim: vektorlashtir, katta ma'lumotda o'lcha, avval to'g'ri. Tuzoqlar — NumPy sikl, kichik massiv, erta optimallashtirish.

2.8. Tezlik — amaliy samaradorlik

Tezlik asosiy g'oyasi — amaliy samaradorlik: "NumPy tez" — gap emas, o'lchanadigan haqiqat (perf_counter — sikl vs vektor, 10-100x farq); Data Science'da million qatorli ma'lumotda tezlik hal qiluvchi (sekin kod — ish to'xtaydi, daqiqalar/soatlar). NumPy tez, chunki: C tilida (interpretator emas), siklsiz (bir buyruq — C ichida sikl), xom sonlar (obyekt emas), uzluksiz xotira (kesh do'st — 2.1), SIMD (protsessor parallel). Xotira ham tejamli (xom son — kam xotira, ro'yxat obyektdan kam). To'g'ri vosita kontekstga (son/katta/tez — NumPy; kichik/aralash/oddiy — Python). Eng ko'p tuzoq — NumPy ichida sikl (tezlikni yo'qotish; vektorlashtir). Bu 2.5 (vektorlashtirish) va 2.1 (xotira) davomi, butun Data Science uchun (katta ma'lumot — tezlik shart). Tezlik — amaliy samaradorlik (o'lchanadigan, 10-100x). Katta ma'lumot. Hal qiluvchi.

3. Tez ma'lumotnoma

import time
import numpy as np

# VAQT O'LCHASH:
t0 = time.perf_counter()
# ... kod ...
t1 = time.perf_counter()
vaqt = t1 - t0   # o'tgan vaqt (soniya)

# SIKL vs VEKTOR (million element):
a = np.arange(1_000_000)
[x * 2 for x in a]   # sikl (SEKIN — ~0.1s)
a * 2                # vektor (TEZ — ~0.001s, 100x)

# TEZLIK SABABLARI:
#   C tilida · siklsiz · xom sonlar · uzluksiz xotira · SIMD

# XOTIRA:
a.nbytes    # massiv xotirasi (bayt)
#   NumPy xom son (8 bayt) · ro'yxat obyekt (28+ bayt)

# QACHON:
#   NumPy — son, katta ma'lumot, matematika, tezlik
#   Python — kichik, aralash tur, oddiy mantiq

QOIDA: NumPy ichida sikl YO'Q (vektorlashtir) · katta ma'lumotda o'lcha

Tezlik xulosasi

Tezlik — amaliy samaradorlik (o'lchanadigan, 10-100x)
perf_counter — vaqt o'lchash (isbot)
Sikl sekin (interpretator) · vektor tez (C tilida)
Sabablari — C, siklsiz, xom son, uzluksiz xotira, SIMD
Tuzoq — NumPy ichida sikl (tezlikni yo'qotadi)

4. Batafsil misollar

Misollar real numpy bilan (deterministik) ishlaydi.

Misol 1 — Vaqt o'lchash

"""Vaqt o'lchash: perf_counter (real numpy)."""

import time
import numpy as np


def main() -> None:
    print("=== 1. perf_counter ===")
    a = np.arange(1_000_000)
    t0 = time.perf_counter()
    natija = a * 2
    t1 = time.perf_counter()
    print(f"  vektor tayyor (element: {len(natija)})")

    print("\n=== 2. Vaqt musbat ===")
    print(f"  o'tgan vaqt >= 0: {(t1 - t0) >= 0}")

    print("\n=== 3. Natija to'g'ri ===")
    print(f"  natija[0]: {natija[0]}, natija[5]: {natija[5]}")

    print("\n=== 4. Tushuntirish ===")
    print("  boshlanish/oxir farqi = amal vaqti")
    print("  ⭐ perf_counter — vaqt o'lchash (isbot)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. perf_counter ===
  vektor tayyor (element: 1000000)

=== 2. Vaqt musbat ===
  o'tgan vaqt >= 0: True

=== 3. Natija to'g'ri ===
  natija[0]: 0, natija[5]: 10

=== 4. Tushuntirish ===
  boshlanish/oxir farqi = amal vaqti
  ⭐ perf_counter — vaqt o'lchash (isbot)

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — Sikl vs vektor

"""Sikl vs vektor: taqqoslash (real numpy)."""

import time
import numpy as np


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

    print("=== 1. Python sikl ===")
    t0 = time.perf_counter()
    natija1 = [x * 2 for x in a]
    sikl_vaqt = time.perf_counter() - t0
    print(f"  sikl bajarildi (element: {len(natija1)})")

    print("\n=== 2. NumPy vektor ===")
    t0 = time.perf_counter()
    natija2 = a * 2
    vektor_vaqt = time.perf_counter() - t0
    print(f"  vektor bajarildi (element: {len(natija2)})")

    print("\n=== 3. Natijalar bir xil ===")
    print(f"  bir xil: {natija1[5] == natija2[5]}")

    print("\n=== 4. Vektor tezroq ===")
    print(f"  vektor tezroq yoki teng: {vektor_vaqt <= sikl_vaqt}")
    print("  ⭐ Vektor 10-100x tez (katta ma'lumotda)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Python sikl ===
  sikl bajarildi (element: 100000)

=== 2. NumPy vektor ===
  vektor bajarildi (element: 100000)

=== 3. Natijalar bir xil ===
  bir xil: True

=== 4. Vektor tezroq ===
  vektor tezroq yoki teng: True
  ⭐ Vektor 10-100x tez (katta ma'lumotda)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — Xotira samaradorligi

"""Xotira samaradorligi: nbytes (real numpy)."""

import sys
import numpy as np


def main() -> None:
    print("=== 1. NumPy xotira ===")
    a = np.arange(1000, dtype=np.int64)
    print(f"  int64 massiv (1000): {a.nbytes} bayt")

    print("\n=== 2. dtype ta'siri ===")
    b = np.arange(1000, dtype=np.int8)
    print(f"  int8 massiv (1000): {b.nbytes} bayt (8x kam)")

    print("\n=== 3. Ro'yxat (obyektlar) ===")
    ro_yxat = list(range(1000))
    print(f"  ro'yxat elementlari obyekt (ko'proq xotira)")

    print("\n=== 4. Tushuntirish ===")
    print("  NumPy xom son (8 bayt) · ro'yxat obyekt (28+ bayt)")
    print("  ⭐ Xotira samaradorligi — xom son (tejamli)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. NumPy xotira ===
  int64 massiv (1000): 8000 bayt

=== 2. dtype ta'siri ===
  int8 massiv (1000): 1000 bayt (8x kam)

=== 3. Ro'yxat (obyektlar) ===
  ro'yxat elementlari obyekt (ko'proq xotira)

=== 4. Tushuntirish ===
  NumPy xom son (8 bayt) · ro'yxat obyekt (28+ bayt)
  ⭐ Xotira samaradorligi — xom son (tejamli)

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — Optimallashtirish (sikl → vektor)

"""Optimallashtirish: sikl → vektor (real numpy)."""

import numpy as np


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

    print("=== 1. SEKIN: sikl ===")
    natija1 = []
    for x in a:
        natija1.append(x ** 2 + 1)
    print(f"  sikl: {natija1}")

    print("\n=== 2. TEZ: vektor ===")
    natija2 = a ** 2 + 1
    print(f"  vektor: {natija2}")

    print("\n=== 3. Bir xil natija ===")
    print(f"  bir xil: {list(natija2) == natija1}")

    print("\n=== 4. Xulosa ===")
    print("  sikl (sekin) → vektor (tez, sodda)")
    print("  ⭐ Optimallashtirish — NumPy ichida sikl yo'q")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. SEKIN: sikl ===
  sikl: [np.int64(2), np.int64(5), np.int64(10), np.int64(17), np.int64(26)]

=== 2. TEZ: vektor ===
  vektor: [ 2  5 10 17 26]

=== 3. Bir xil natija ===
  bir xil: True

=== 4. Xulosa ===
  sikl (sekin) → vektor (tez, sodda)
  ⭐ Optimallashtirish — NumPy ichida sikl yo'q

Nima ko'rsatdi: 2.7-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. NumPy ichida sikl

for x in massiv: natija.append(x * 2)   # sekin              # ⚠️
natija = massiv * 2   # vektorlashtir (tez)                   # ✅

2. Kichik massivda o'lchash

# 10 element o'lchash (farq sezilmaydi)                       # ⚠️
# katta ma'lumotda o'lcha (million+)                           # ✅

3. append sikl

for x in a: natija = np.append(natija, x)   # sekin (nusxa)  # ⚠️
natija = [.. for x in a]; np.array(natija)   # yig'ib keyin   # ✅

4. Noto'g'ri dtype

np.arange(1000, dtype=np.float64)   # ko'p xotira            # ⚠️
np.arange(1000, dtype=np.int16)   # yetsa (kam xotira)        # ✅

5. Erta optimallashtirish

# oddiy kod ishlar edi (behuda murakkablik)                  # ⚠️
# avval to'g'ri, keyin tez (agar sekin bo'lsa)                 # ✅

6. Takror np.array

for i in ...: np.array(list)   # har safar (sekin)           # ⚠️
arr = np.array(list)   # bir marta                            # ✅

7. Keraksiz nusxa

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

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 2.5-dars (o'tilgan): Vektorlashtirish
• 2.1-dars (o'tilgan): Xotira (uzluksiz)
• 3-qism: Pandas (vektorlashtirilgan amallar — tez)
• 20-qism: ML (katta ma'lumot — tezlik shart)
• 22-qism: Deep Learning (GPU — parallel tezlik)

8. Eng yaxshi amaliyotlar

1. perf_counter — vaqt o'lchash (isbot).

2. Vektorlashtir (NumPy ichida sikl yo'q).

3. Katta ma'lumotda o'lcha (kichik — overhead).

4. To'g'ri dtype (xotira tejash).

5. Avval to'g'ri, keyin tez (erta optimallashtirmang).

6. append sikl yo'q (ro'yxatga yig', keyin massiv).

7. Kontekst — NumPy (katta/son) yoki Python (kichik).

8. Tezlik — amaliy samaradorlik (o'lchanadigan).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # perf_counter nima?
2.  # vaqt qanday o'lchanadi?
3.  # sikl yoki vektor tez?
4.  # farq qancha?
5.  # nega vektor tez?
6.  # kichik massivda farq?
7.  # NumPy ichida sikl?
8.  # NumPy xotira?
9.  # qachon NumPy?
10. # qachon Python?
11. # erta optimallashtirish?
12. # append sikl?

Vazifa 2: Xatolarni tuzating

1.  for x in a: natija.append(x*2)   # NumPy massiv

2.  # 10 element o'lchash

3.  for x in a: natija = np.append(natija, x)

4.  np.arange(1000, dtype=np.float64)   # int yetadi

5.  # oddiy kodni optimallashtirish

1.  natija = a * 2   # vektorlashtir

2.  katta ma'lumotda o'lcha (million+)

3.  ro'yxatga yig', keyin np.array

4.  dtype=np.int16   # kam xotira

5.  avval to'g'ri, keyin tez (agar sekin)

Vazifa 3: O'lchash

Modellang:

1. perf_counter
2. Boshlanish
3. Oxir
4. Farq

Vazifa 4: Taqqoslash

Modellang:

1. Sikl
2. Vektor
3. Farq
4. 10-100x

Vazifa 5: Sabablari

Modellang:

1. C tilida
2. Siklsiz
3. Xom son
4. Xotira

Vazifa 6: Qaror

Modellang:

1. NumPy
2. Python
3. Kontekst
4. Vosita

Vazifa 7: O'ylash

"Erta optimallashtirish — barcha yomonliklarning ildizi" (Donald Knuth) — mashhur dasturlash tamoyili. Bu tezlik bilan qanday bog'liq: nima uchun "avval to'g'ri kod, keyin (agar kerak bo'lsa) tez kod" to'g'ri yondashuv, va nega "hamma joyda NumPy ishlatib maksimal tezlik" ham noto'g'ri strategiya bo'lishi mumkin?

Nimani mustahkamlaydi: 2.5, 2.7-bo'limlar.

Xulosa

Bu darsda tezlik va o'lchashni o'rgandik.

Eng muhim uch fikr:

1. O'lchash va taqqoslash. Vaqt o'lchash (time.perf_counter) — kod qancha vaqt oladi (boshlanish/oxir farqi — aniq, isbot uchun). Sikl vs vektor — Python sikl ([x * 2 for x in a] — sekin) va NumPy vektor (a * 2 — tez) taqqoslash; 10-100x farq (element soni ko'p — million — farq katta; kichik massivda sezilmaydi — overhead); "NumPy tez" — gap emas, o'lchanadigan haqiqat.

2. Sabablar va xotira. Tezlik sabablari — NumPy tez, chunki: C tilida (interpretator emas), siklsiz (bir buyruq — C ichida sikl), xom sonlar (obyekt emas — 2.1), uzluksiz xotira (kesh do'st), SIMD (protsessor parallel). Xotira samaradorligi — NumPy tejamli (xom son — int64 8 bayt; Python ro'yxat — obyekt 28+ bayt; million son — NumPy 8 MB, ro'yxat 28+ MB); to'g'ri dtype (2.3 — int8 kichik ma'lumotda).

3. Amaliy samaradorlik. Qachon NumPy (son, katta ma'lumot, matematika, tezlik), qachon Python (kichik, aralash tur, oddiy mantiq) — kontekstga qarab. Tezlik — amaliy samaradorlik (o'lchanadigan — 10-100x; Data Science'da million qator — hal qiluvchi). Eng ko'p tuzoq — NumPy ichida sikl (for x in massiv — tezlikni yo'qotadi; vektorlashtir). "Erta optimallashtirish — yomonlik ildizi" (avval to'g'ri/sodda, o'lcha, sekin bo'lsa optimallashtir — kerakli joy). Tuzoqlar: NumPy ichida sikl, kichik massivda o'lchash, append sikl (nusxa), erta optimallashtirish.

Keyingi darsda saqlash va tuzoqlar (copy vs view)ni o'rganamiz: massivni faylga saqlash (save/load) va view/nusxa tuzog'ini chuqurroq — ma'lumotni saqlash va xavfsiz ishlash.