2.9-dars: Shart va tanlash

2-QISM — NUMPY · 9-dars

1. Kirish va motivatsiya

Ma'lumot bor — endi undan shart bo'yicha qism ajratmoqchisiz: faqat 18 yoshdan katta mijozlar, faqat manfiy qiymatlar, faqat o'rtachadan yuqori baholar. Bu — boolean indekslash (shart bo'yicha tanlash) va np.where (shartga qarab tanlash/o'zgartirish). O'tgan darsda a > 3 bool massiv qaytarishini ko'rdik; endi shu bool massivni filtr sifatida ishlatamiz: a[a > 3] — faqat shart bajarganlar. Nega muhim? (1) Filtrlash — Data Science'da doim ma'lumotni shart bo'yicha ajratasiz (chegara, kategoriya, oraliq); (2) Tozalash — noto'g'ri qiymatlarni topish/almashtirish (manfiy → 0, NaN → o'rtacha); (3) Shartli o'zgartirish — np.where bilan "agar shart bo'lsa X, aks holda Y". Bu dars shart va tanlashni chuqur o'rgatadi — ma'lumotni filtrlash va shartli o'zgartirish.

Shart va tanlash — shart bo'yicha element tanlash/o'zgartirish: boolean indekslash (a[a > 5] — shart bajarganlar), shart (a > 5 — bool massiv, 2.5), birlashtirish (& VA, | YOKI, ~ EMAS — qavs bilan), np.where (np.where(shart, x, y) — shartga qarab tanla), shartli o'zgartirish (a[a < 0] = 0 — shart bajarganlarni o'zgartir), np.any/np.all (birortasi/barchasi). Foydalanish: filtrlash, tozalash, shartli o'zgartirish. Bu 2.5 (taqqoslash), 2.4 (indekslash) bilan bog'liq. Boolean indeks — shart bo'yicha. where — shartli. Filtr.

Real vaziyat. Data Scientist 1000 mijoz yoshi (massiv) bilan ishlar edi. Kattalar (18+) ni ajratdi — yosh[yosh >= 18] (boolean indeks — faqat shart bajarganlar). Keyin oraliq — yosh[(yosh >= 25) & (yosh <= 40)] (25-40 orasi — & bilan, qavs muhim). Ma'lumotda manfiy xato qiymatlar bor edi — yosh[yosh < 0] = 0 (shartli o'zgartirish — manfiylarni 0 ga). So'ng np.where(yosh >= 18, "katta", "kichik") (har mijozga yorliq). Boolean indeks va where ma'lumotni shart bo'yicha filtrladi va o'zgartirdi (siklsiz). Filtrlash — Data Science tozalash va tahlil asosi.

Bu darsda shart va tanlashni o'rganamiz.

Bu darsda:

• Boolean indekslash
• Shartlarni birlashtirish (&, |, ~)
• np.where (shartli tanlash)
• Shartli o'zgartirish
• any va all
• Shart amaliyoti
• Shart tuzoqlari
• Amaliy: filtr modeli

ℹ Misollar real numpy bilan (deterministik) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. Boolean indekslash

Shart bo'yicha tanlash:

import numpy as np

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

a > 4            # [F T F T F T] (bool massiv — 2.5)
a[a > 4]         # [5 8 9] (faqat shart bajarganlar!)

# bool massivni FILTR sifatida ishlatish
a[a % 2 == 0]    # [8 2] (juft sonlar)

Boolean indekslash — shart bo'yicha tanlash: a > 4 (bool massiv — 2.5), a[a > 4] (faqat shart bajarganlar — [5, 8, 9]). Sabab: ma'lumotni shart bo'yicha ajratish (kattalar, manfiylar, oraliq — filtr); bool massiv filtr (True — olinadi, False — tashlanadi). a[shart] — shart True bo'lgan elementlar. Bu 2.5 (taqqoslash — bool massiv) davomi (bool massivni indeks sifatida). Natija — yangi massiv (faqat mos elementlar — soni o'zgarishi mumkin). Boolean indeks — shart bo'yicha (a[a > 4]). Filtr. Tanlash.

2.2. Shartlarni birlashtirish (&, |, ~)

Ko'p shart:

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

# & (VA), | (YOKI), ~ (EMAS) — QAVS bilan!
a[(a > 2) & (a < 8)]    # [5 3] (2 dan katta VA 8 dan kichik)
a[(a < 2) | (a > 8)]    # [1 9] (2 dan kichik YOKI 8 dan katta)
a[~(a > 4)]             # [1 3 2] (4 dan katta EMAS)

# and/or ISHLAMAYDI — &, |, ~ ishlatilg

Shartlarni birlashtirish (&, |, ~) — ko'p shart: & (VA — ikki shart ham), | (YOKI — biri yetadi), ~ (EMAS — inkor); QAVS bilan ((a > 2) & (a < 8)). Sabab: ko'pincha ko'p shart (oraliq — katta VA kichik; ikki kategoriya — biri YOKI ikkinchi); shartlar &/|/~ bilan birlashadi. MUHIM: Python and/or/not ishlamaydi (massivda xato — element-wise emas); NumPy &/|/~ (element-wise); qavs shart (& ustuvorlik — a > 2 & a < 8 xato, (a > 2) & (a < 8) to'g'ri). Shartlar — & VA, | YOKI, ~ EMAS (qavs bilan). and/or emas. Qavs.

2.3. np.where (shartli tanlash)

Shartga qarab tanla:

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

# np.where(shart, x, y) — shart bo'lsa x, aks holda y
np.where(a > 4, "katta", "kichik")
# ['kichik' 'katta' 'kichik' 'katta' 'kichik']

np.where(a > 4, a, 0)      # [0 5 0 8 0] (shart bo'lsa a, aks 0)
np.where(a < 0, 0, a)      # manfiylarni 0 ga

np.where (shartli tanlash) — shartga qarab tanla: np.where(shart, x, y) — shart True bo'lsa x, False bo'lsa y (har element uchun). Sabab: ko'pincha "agar shart bo'lsa X, aks holda Y" kerak (yorliq — katta/kichik; almashtirish — manfiy → 0); np.where buni siklsiz (har elementga shart, x yoki y). np.where(a > 4, a, 0) (shart bo'lsa asl, aks 0), np.where(a < 0, 0, a) (manfiylar 0). x/y skalyar yoki massiv. Bu ternar (shartli ifoda — vektorlashtirilgan). where — shartli tanlash (shart? x : y). Siklsiz. Shartli.

2.4. Shartli o'zgartirish

Shart bajarganlarni o'zgartir:

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

# Boolean indeks bilan O'ZGARTIRISH
a[a < 0] = 0             # manfiylarni 0 ga
# a → [0 5 0 8 0]

b = np.array([1, 5, 3, 8, 2])
b[b > 4] = 4             # 4 dan kattalarni 4 ga (cheklash)
# b → [1 4 3 4 2]

Shartli o'zgartirish — shart bajarganlarni o'zgartir: a[a < 0] = 0 (manfiylarni 0 ga), b[b > 4] = 4 (cheklash — 4 dan kattalar 4 ga). Sabab: tozalash (noto'g'ri qiymatlar — manfiy yosh → 0, chegaradan tashqari → chegara); boolean indeksga qiymat berish (a[shart] = qiymat — faqat shart bajarganlar o'zgaradi). np.where yangi massiv (asl saqlanadi), a[shart] = joyida o'zgartiradi (asl o'zgaradi). Tozalash (6-qism) uchun muhim. Shartli o'zgartirish — a[shart] = qiymat. Joyida. Tozalash.

2.5. any va all

Birortasi/barchasi:

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

(a > 0).all()      # True (barchasi > 0?)
(a > 7).any()      # True (birortasi > 7?)
(a > 10).any()     # False (birortasi > 10? — yo'q)

np.any(a > 4)      # True · np.all(a > 4) — False

any va all — birortasi/barchasi: (a > 0).all() (barchasi shart bajaradi-mi — hammasi True bo'lsa True), (a > 7).any() (birortasi shart bajaradi-mi — bittasi True yetadi). Sabab: ba'zan umumiy javob kerak (barcha qiymat musbat-mi — tekshirish; birorta xato bor-mi — validatsiya); all (hammasi), any (bittasi). Bool massivda (.all(), .any()) yoki np.all/np.any. axis bilan ham (yo'nalish bo'yicha). Tekshirish/validatsiya uchun. any/all — birortasi/barchasi. Umumiy javob. Tekshirish.

2.6. Shart amaliyoti

Shart amaliyoti: boolean indeks (a[a > 5] — filtr); shartlar birlashtirish (&/|/~ — qavs bilan); np.where (shartli tanlash — x/y); shartli o'zgartirish (a[shart] = qiymat — joyida, tozalash); any/all (tekshirish); qavs ((a > 2) & (a < 8) — ustuvorlik); .copy() (filtr natijasini o'zgartmoqchi bo'lsa — view/nusxa); NaN (np.isnan(a) — NaN filtr). Tuzoqlar: and/or (massivda xato — &/|), qavs unutish (ustuvorlik xato), boolean indeks nusxa (o'zgartsa asl — 2.4), NaN taqqoslash (nan > 0 False — isnan). Amaliyot — boolean indeks, &/|, where, shartli o'zgartirish. Filtr. Qavs.

2.7. Shart tuzoqlari

Shart asosiy tuzoqlari: and/or/not (massivda xato — "truth value ambiguous"; NumPy &/|/~); qavs unutish (a > 2 & a < 8 — & ustuvorlik yuqori, xato; (a > 2) & (a < 8) to'g'ri); boolean indeks nusxa (a[a > 5] nusxa qaytaradi — o'zgartsa asl o'zgarmaydi; lekin a[a > 5] = x joyida o'zgartiradi); NaN taqqoslash (nan > 0 = False har doim — NaN bilan taqqoslash doim False; np.isnan kerak); soni o'zgaradi (boolean indeks natija — mos elementlar soni, asl emas; shakl kutilmagan); shart shakl (bool massiv massiv bilan bir xil shakl bo'lishi kerak); np.where uch argument (where(shart, x, y) — x, y unutsa faqat indeks qaytaradi). Sabab: shart mantiqiy nozik (and/or, qavs, NaN — jim xato yoki noto'g'ri). Yechim: &/|/~, qavs, isnan, where uch argument. Tuzoqlar — and/or, qavs, NaN.

2.8. Shart — ma'lumotni filtrlash

Shart asosiy g'oyasi — ma'lumotni filtrlash: ma'lumotni shart bo'yicha ajratish (kattalar, oraliq, xato qiymatlar) va shartli o'zgartirish (manfiy → 0, chegaralash); Data Science tozalash va tahlil asosi. Boolean indekslash (a[a > 5] — bool massivni filtr, faqat shart bajarganlar), shartlar birlashtirish (& VA, | YOKI, ~ EMAS — qavs bilan, and/or emas), np.where (shartli tanlash — "shart? x : y", siklsiz), shartli o'zgartirish (a[shart] = qiymat — joyida, tozalash). Data Science'da doim filtrlash (chegara, kategoriya, xato qiymat — tozalash 6-qism; guruh — tahlil). Bu 2.5 (taqqoslash — bool massiv) davomi va Pandas (df[df.yosh > 18] — bir xil g'oya), tozalash uchun. Shart — ma'lumotni filtrlash (boolean indeks, where). Tozalash. Tahlil. Filtr.

3. Tez ma'lumotnoma

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

# BOOLEAN INDEKSLASH (filtr):
a > 4            # bool massiv (2.5)
a[a > 4]         # [5 8 9] (faqat shart bajarganlar)

# SHARTLAR BIRLASHTIRISH (&, |, ~ — QAVS bilan):
a[(a > 2) & (a < 8)]   # VA (oraliq)
a[(a < 2) | (a > 8)]   # YOKI
a[~(a > 4)]            # EMAS
#   and/or ISHLAMAYDI — &, |, ~ ishlat!

# np.where (shartli tanlash):
np.where(a > 4, "katta", "kichik")   # shart? x : y
np.where(a < 0, 0, a)                 # manfiylarni 0 ga

# SHARTLI O'ZGARTIRISH (joyida):
a[a < 0] = 0     # manfiylar 0 ga (tozalash)

# ANY / ALL (tekshirish):
(a > 0).all()    # barchasi? · (a > 7).any() — birortasi?

# NaN:
a[~np.isnan(a)]  # NaN emaslar (nan > 0 doim False)

QOIDA: &/|/~ (and/or emas) · qavs · a[shart]=x joyida

Shart xulosasi

Shart — ma'lumotni filtrlash (shart bo'yicha tanlash/o'zgartirish)
Boolean indeks — a[a > 5] (bool massiv filtr)
&, |, ~ — VA, YOKI, EMAS (qavs bilan, and/or emas)
np.where(shart, x, y) — shartli tanlash (shart? x : y)
a[shart] = qiymat — shartli o'zgartirish (joyida, tozalash)

4. Batafsil misollar

Misollar real numpy bilan (deterministik) ishlaydi.

Misol 1 — Boolean indekslash

"""Boolean indekslash: filtr (real numpy)."""

import numpy as np


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

    print("=== 1. Shart (bool massiv) ===")
    print(f"  a > 4: {a > 4}")

    print("\n=== 2. Filtr ===")
    print(f"  a[a > 4]: {a[a > 4]} (faqat shart bajarganlar)")

    print("\n=== 3. Juft sonlar ===")
    print(f"  a[a % 2 == 0]: {a[a % 2 == 0]}")

    print("\n=== 4. Real: kattalar ===")
    yosh = np.array([15, 22, 17, 30, 12, 45])
    print(f"  yosh[yosh >= 18]: {yosh[yosh >= 18]}")
    print("  ⭐ Boolean indeks — shart bo'yicha filtr")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Shart (bool massiv) ===
  a > 4: [False  True False  True False  True]

=== 2. Filtr ===
  a[a > 4]: [5 8 9] (faqat shart bajarganlar)

=== 3. Juft sonlar ===
  a[a % 2 == 0]: [8 2]

=== 4. Real: kattalar ===
  yosh[yosh >= 18]: [22 30 45]
  ⭐ Boolean indeks — shart bo'yicha filtr

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — Shartlarni birlashtirish

"""Shartlarni birlashtirish: &, |, ~ (real numpy)."""

import numpy as np


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

    print("=== 1. VA (&) ===")
    print(f"  a[(a > 2) & (a < 8)]: {a[(a > 2) & (a < 8)]}")

    print("\n=== 2. YOKI (|) ===")
    print(f"  a[(a < 2) | (a > 8)]: {a[(a < 2) | (a > 8)]}")

    print("\n=== 3. EMAS (~) ===")
    print(f"  a[~(a > 4)]: {a[~(a > 4)]}")

    print("\n=== 4. Real: oraliq ===")
    yosh = np.array([15, 22, 30, 45, 55, 28])
    ishchi = yosh[(yosh >= 25) & (yosh <= 45)]
    print(f"  25-45 yosh: {ishchi}")
    print("  ⭐ &, |, ~ — qavs bilan (and/or emas)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. VA (&) ===
  a[(a > 2) & (a < 8)]: [5 3]

=== 2. YOKI (|) ===
  a[(a < 2) | (a > 8)]: [1 9]

=== 3. EMAS (~) ===
  a[~(a > 4)]: [1 3 2]

=== 4. Real: oraliq ===
  25-45 yosh: [30 45 28]
  ⭐ &, |, ~ — qavs bilan (and/or emas)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — np.where

"""np.where: shartli tanlash (real numpy)."""

import numpy as np


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

    print("=== 1. Yorliq ===")
    print(f"  {np.where(a > 4, 'katta', 'kichik')}")

    print("\n=== 2. Shart bo'lsa asl, aks 0 ===")
    print(f"  np.where(a > 4, a, 0): {np.where(a > 4, a, 0)}")

    print("\n=== 3. Manfiylarni 0 ga ===")
    b = np.array([-2, 5, -1, 8, -3])
    print(f"  np.where(b < 0, 0, b): {np.where(b < 0, 0, b)}")

    print("\n=== 4. Ikki massiv ===")
    x = np.array([10, 20, 30])
    y = np.array([1, 2, 3])
    print(f"  np.where([T,F,T], x, y): {np.where([True, False, True], x, y)}")
    print("  ⭐ np.where — shart? x : y (siklsiz)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Yorliq ===
  ['kichik' 'katta' 'kichik' 'katta' 'kichik']

=== 2. Shart bo'lsa asl, aks 0 ===
  np.where(a > 4, a, 0): [0 5 0 8 0]

=== 3. Manfiylarni 0 ga ===
  np.where(b < 0, 0, b): [0 5 0 8 0]

=== 4. Ikki massiv ===
  np.where([T,F,T], x, y): [10  2 30]
  ⭐ np.where — shart? x : y (siklsiz)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 4 — Shartli o'zgartirish va any/all

"""Shartli o'zgartirish va any/all (real numpy)."""

import numpy as np


def main() -> None:
    print("=== 1. Manfiylarni 0 ga (joyida) ===")
    a = np.array([-2, 5, -1, 8, -3])
    a[a < 0] = 0
    print(f"  a: {a}")

    print("\n=== 2. Cheklash (4 dan katta → 4) ===")
    b = np.array([1, 5, 3, 8, 2])
    b[b > 4] = 4
    print(f"  b: {b}")

    print("\n=== 3. any va all ===")
    c = np.array([1, 5, 3, 8, 2])
    print(f"  (c > 0).all(): {(c > 0).all()} (barchasi > 0?)")
    print(f"  (c > 7).any(): {(c > 7).any()} (birortasi > 7?)")

    print("\n=== 4. NaN ===")
    d = np.array([1.0, np.nan, 3.0])
    print(f"  d[~np.isnan(d)]: {d[~np.isnan(d)]} (NaN emaslar)")
    print("  ⭐ Shartli o'zgartirish + tekshirish")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Manfiylarni 0 ga (joyida) ===
  a: [0 5 0 8 0]

=== 2. Cheklash (4 dan katta → 4) ===
  b: [1 4 3 4 2]

=== 3. any va all ===
  (c > 0).all(): True (barchasi > 0?)
  (c > 7).any(): True (birortasi > 7?)

=== 4. NaN ===
  d[~np.isnan(d)]: [1. 3.] (NaN emaslar)
  ⭐ Shartli o'zgartirish + tekshirish

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

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

6. Keng tarqalgan xatolar va yechimlari

1. and/or

a[(a > 2) and (a < 8)]   # xato (truth value ambiguous)      # ⚠️
a[(a > 2) & (a < 8)]     # & (element-wise)                   # ✅

2. Qavs unutish

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

3. NaN taqqoslash

a[a > 0]   # NaN o'tkazib yuboradi (nan > 0 False)           # ⚠️
a[~np.isnan(a)]   # NaN ni aniq filtr                         # ✅

4. where argumentlari

np.where(a > 4)   # faqat indeks qaytaradi                   # ⚠️
np.where(a > 4, x, y)   # shart? x : y                        # ✅

5. Filtr natijasini o'zgartirish

qism = a[a > 4]; qism[0] = 9   # asl o'zgarmaydi (nusxa)      # ⚠️
a[a > 4] = 9   # joyida o'zgartirish (asl)                     # ✅

6. Soni kutish

a[a > 4].shape   # mos elementlar soni (asl emas)            # ⚠️
# soni o'zgaradi (filtr)                                       # ✅

7. Bool shakl

a[bool_massiv]   # bool massiv a bilan bir xil shakl         # ⚠️
# shaklni tekshir                                              # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 2.5-dars (o'tilgan): Taqqoslash (bool massiv)
• 2.4-dars (o'tilgan): Indekslash
• 3-qism: Pandas (df[df.yosh > 18] — filtr)
• 6-qism: Tozalash (xato qiymatlarni almashtirish)
• 4-qism: Statistika (shartli tahlil — guruh)

8. Eng yaxshi amaliyotlar

1. Boolean indeks — a[shart] (filtr).

2. &/|/~ — VA/YOKI/EMAS (and/or emas).

3. Qavs — (a > 2) & (a < 8) (ustuvorlik).

4. np.where(shart, x, y) — shartli tanlash.

5. a[shart] = qiymat — joyida o'zgartirish (tozalash).

6. NaN — ~np.isnan(a) (nan > 0 doim False).

7. any/all — tekshirish.

8. Shart — ma'lumotni filtrlash.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # a[a > 4] nima?
2.  # bool massiv nima uchun?
3.  # & nima?
4.  # and/or ishlaydimi?
5.  # qavs kerakmi?
6.  # np.where nima?
7.  # where argumentlari?
8.  # a[shart] = x nima?
9.  # nusxa yoki joyida?
10. # nan > 0?
11. # all vs any?
12. # nega filtr muhim?

Vazifa 2: Xatolarni tuzating

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

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

3.  a[a > 0]   # NaN bor

4.  np.where(a > 4)   # x, y kerak

5.  qism = a[a > 4]; qism[0] = 9   # asl o'zgarmaydi

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

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

3.  a[~np.isnan(a)]   # NaN filtr

4.  np.where(a > 4, x, y)

5.  a[a > 4] = 9   # joyida

Vazifa 3: Boolean indeks

Modellang:

1. Shart
2. Filtr
3. Tanlash
4. Soni

Vazifa 4: Birlashtirish

Modellang:

1. &
2. |
3. ~
4. Qavs

Vazifa 5: where

Modellang:

1. Shart
2. x
3. y
4. Siklsiz

Vazifa 6: O'zgartirish

Modellang:

1. Joyida
2. Tozalash
3. Cheklash
4. Manfiy

Vazifa 7: O'ylash

NumPy'da shartlarni birlashtirish uchun Python'ning and/or/not ishlamaydi — &/|/~ ishlatiladi, va har bir shart qavsga olinishi kerak. Nima uchun and/or massivda ishlamaydi (nima uchun "truth value ambiguous" xatosi), va nega & uchun qavs shart ((a > 2) & (a < 8))?

Nimani mustahkamlaydi: 2.2, 2.7-bo'limlar.

Xulosa

Bu darsda shart va tanlashni o'rgandik.

Eng muhim uch fikr:

1. Boolean indekslash va birlashtirish. Boolean indekslash — shart bo'yicha tanlash: a > 4 (bool massiv), a[a > 4] (faqat shart bajarganlar — bool massivni filtr sifatida). Shartlar birlashtirish — & (VA), | (YOKI), ~ (EMAS); qavs bilan ((a > 2) & (a < 8) — ustuvorlik); Python and/or ishlamaydi (massivda "truth value ambiguous" xato — bitta True/False kutadi; &/| element-wise).

2. np.where va shartli o'zgartirish. np.where — shartli tanlash: np.where(shart, x, y) (shart True → x, False → y; "shart? x : y" — siklsiz); np.where(a < 0, 0, a) (manfiylar 0). Shartli o'zgartirish — a[shart] = qiymat (joyida — asl o'zgaradi; a[a < 0] = 0 manfiylar 0, tozalash); np.where yangi massiv, a[shart] = joyida.

3. Ma'lumotni filtrlash. any/all — birortasi/barchasi ((a > 0).all(), (a > 7).any() — tekshirish). Shart — ma'lumotni filtrlash (shart bo'yicha ajratish/o'zgartirish — tozalash, tahlil); Data Science'da doim (chegara, kategoriya, xato qiymat — 6-qism tozalash; guruh — tahlil); Pandas'da bir xil g'oya (df[df.yosh > 18]). Tuzoqlar: and/or (&/|/~), qavs unutish, NaN taqqoslash (nan > 0 doim False — isnan), boolean indeks nusxa (soni o'zgaradi).

Keyingi darsda tasodifiy sonlar (random)ni o'rganamiz: tasodifiy massivlar, seed (takrorlanuvchi natija), taqsimotlar — simulyatsiya va ML uchun.