3.7-dars: Yo'q qiymatlar (NaN)

3-QISM — PANDAS · 7-dars

1. Kirish va motivatsiya

Real ma'lumotning eng katta va eng ko'p uchraydigan muammosi — yo'q qiymatlar (NaN — Not a Number). So'rovnomada ba'zi savollar javobsiz, sensor ba'zan ishlamagan, ma'lumot bazasida bo'sh kataklar, CSV'da bo'sh joylar. Deyarli har real ma'lumotda NaN bor. Va NaN jim xato manbai: mean NaN'ni o'tkazib yuboradi (lekin sizga aytmaydi), + NaN tarqatadi, model NaN bilan ishlamaydi. Shuning uchun Data Science'ning eng muhim ko'nikmalaridan biri — NaN bilan to'g'ri ishlash: topish (isna), o'chirish (dropna), to'ldirish (fillna). Nega muhim? (1) Real ma'lumot — deyarli har doim NaN bor; (2) Model talabi — ko'p model NaN bilan ishlamaydi; (3) To'g'ri natija — noto'g'ri NaN ishlov — noto'g'ri xulosa. Bu dars NaN bilan ishlashni o'rgatadi — ma'lumot tozalashning yuragi.

Yo'q qiymatlar (NaN) — bo'sh/yo'q ma'lumot: NaN nima (Not a Number — yo'q qiymat), topish (isna/isnull — qayerda, .sum() — nechta), o'chirish (dropna — NaN qator/ustun), to'ldirish (fillna — qiymat bilan: 0, o'rtacha, oldingi), NaN xatti-harakati (amalda tarqaladi, statistikada o'tkaziladi), strategiya (o'chirish vs to'ldirish). Foydalanish: real ma'lumot tozalash, model tayyorlash, to'g'ri tahlil. Bu 3.6 (ustunlar), 6-qism (tozalash) bilan bog'liq. NaN — yo'q qiymat. isna/dropna/fillna. Tozalash.

Real vaziyat. Data Scientist so'rovnoma ma'lumoti bilan ishlar edi (1000 kishi — yosh, daromad, shahar; ba'zi javoblar bo'sh — NaN). Avval topdi: df.isna().sum() (har ustunda nechta NaN — daromad 150 ta bo'sh, shahar 30 ta). Qaror: yosh (5 ta NaN — kam) — dropna (o'chirish); daromad (150 ta — ko'p) — fillna(df["daromad"].median()) (o'rtacha bilan to'ldirish); shahar — fillna("Noma'lum") (kategoriya). NaN'ni e'tiborsiz qoldirsa — mean noto'g'ri, model xato. To'g'ri ishlov (topish → qaror → o'chirish/to'ldirish) ma'lumotni toza qildi (model uchun tayyor). NaN — real ma'lumot eng katta muammosi (tozalash yuragi).

Bu darsda NaN bilan ishlashni o'rganamiz.

Bu darsda:

• NaN nima va topish (isna)
• O'chirish (dropna)
• To'ldirish (fillna)
• NaN xatti-harakati
• Strategiya (o'chirish vs to'ldirish)
• NaN amaliyoti
• NaN tuzoqlari
• Amaliy: NaN modeli

ℹ Misollar real pandas bilan (deterministik) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. NaN nima va topish (isna)

Yo'q qiymat va topish:

import pandas as pd
import numpy as np

df = pd.DataFrame({
    "yosh": [25, np.nan, 30, np.nan],
    "shahar": ["T", "S", None, "B"],
})

# TOPISH
df.isna()              # har katak NaN-mi (bool DataFrame)
df.isna().sum()        # har ustunda nechta NaN
df.isna().sum().sum()  # jami NaN
df["yosh"].isna()      # bitta ustun (bool Series)
df.notna()             # aksincha (NaN emas)

NaN nima va topish (isna) — yo'q qiymat: NaN (Not a Number — yo'q/bo'sh qiymat; np.nan, None); topish (df.isna() — har katak NaN-mi, bool DataFrame; df.isna().sum() — har ustunda nechta; .sum().sum() — jami; df["yosh"].isna() — bitta ustun). Sabab: NaN ko'rinmas (bo'sh — jim); avval topish kerak (qayerda, nechta — qaror uchun); isna NaN'ni aniqlaydi. isna/isnull (bir xil), notna (aksincha). df.isna().sum() — birinchi qadam (NaN xaritasi). NaN — yo'q qiymat; topish — isna().sum() (nechta). Ko'rinmas. Topish.

2.2. O'chirish (dropna)

NaN qator/ustunni o'chirish:

df = pd.DataFrame({
    "yosh": [25, np.nan, 30],
    "shahar": ["T", "S", None],
})

# QATOR o'chirish (NaN bor qator)
df.dropna()                    # NaN bor qatorlar o'chadi
df.dropna(subset=["yosh"])     # faqat yosh NaN bo'lsa

# USTUN o'chirish
df.dropna(axis=1)              # NaN bor ustunlar

# necha NaN bo'lsa o'chirish
df.dropna(thresh=2)           # kamida 2 to'la qiymat kerak

O'chirish (dropna) — NaN qator/ustun: df.dropna() (NaN bor qatorlar o'chadi), df.dropna(subset=["yosh"]) (faqat yosh NaN bo'lsa), df.dropna(axis=1) (NaN bor ustunlar), df.dropna(thresh=2) (kamida 2 to'la qiymat). Sabab: NaN kam bo'lsa (bir necha qator — 5%) o'chirish oson (ma'lumot kam yo'qoladi); dropna NaN qatorni olib tashlaydi. subset (faqat ba'zi ustun NaN bo'lsa — muhim ustun), axis=1 (ustun — agar ustun ko'p NaN). O'chirish — dropna (NaN qator/ustun). Kam NaN. subset.

2.3. To'ldirish (fillna)

NaN'ni qiymat bilan:

df = pd.DataFrame({"yosh": [25, np.nan, 30], "shahar": ["T", None, "B"]})

# QIYMAT bilan
df["yosh"].fillna(0)                    # 0 bilan
df["yosh"].fillna(df["yosh"].mean())    # o'rtacha bilan
df["yosh"].fillna(df["yosh"].median())  # median (chetdan chidamli)
df["shahar"].fillna("Noma'lum")         # kategoriya

# OLDINGI/KEYINGI qiymat (vaqt qatori)
df["yosh"].ffill()      # oldingi qiymat (forward)
df["yosh"].bfill()      # keyingi qiymat (backward)

To'ldirish (fillna) — NaN'ni qiymat bilan: fillna(0) (0 bilan), fillna(df["yosh"].mean()) (o'rtacha), fillna(median()) (median — chetdan chidamli, 1.5), fillna("Noma'lum") (kategoriya); ffill (oldingi qiymat — forward), bfill (keyingi — backward, vaqt qatori). Sabab: NaN ko'p bo'lsa (o'chirish — ko'p ma'lumot yo'qoladi) yoki saqlash kerak (qator muhim) — to'ldirish; fillna NaN'ni almashtiradi. Median afzal (o'rtacha — chetga sezgir 1.5); kategoriya — "Noma'lum"; vaqt qatori — ffill (oldingi). To'ldirish — fillna (o'rtacha/median/kategoriya). Ko'p NaN. Median.

2.4. NaN xatti-harakati

NaN xatti-harakati — NaN qanday ta'sir qiladi: (1) amalda tarqaladi — NaN + 5 = NaN (5 * NaN = NaN; NaN bilan amal → NaN; ustun qo'shish — bir NaN butun natijani NaN); (2) statistikada o'tkaziladi — mean/sum/max NaN'ni o'tkazib yuboradi ([1, NaN, 3].mean() = 2 — NaN hisobga olinmaydi; lekin jim — sizga aytmaydi); (3) taqqoslash False — NaN > 0 = False, NaN == NaN = False (NaN o'zi bilan ham teng emas! isna kerak — 2.9); (4) tur — NaN float (int ustun NaN bo'lsa float bo'ladi); (5) guruhda — groupby NaN'ni o'tkazib yuboradi 3.8-bob. Sabab: NaN maxsus (yo'q qiymat — noaniq; amal noaniq → NaN; statistika o'tkazib — lekin jim). Bilish muhim (jim xato — mean noto'g'ri, + NaN tarqatadi). NaN xatti — tarqaladi (amal), o'tkaziladi (statistika), False (taqqoslash). Jim. Maxsus.

2.5. Strategiya (o'chirish vs to'ldirish)

Strategiya (o'chirish vs to'ldirish) — qaysini tanlash: o'chirish (dropna) — NaN kam bo'lsa (< 5% — ma'lumot kam yo'qoladi), qator muhim emas (bir necha namuna); to'ldirish (fillna) — NaN ko'p bo'lsa (o'chirish — ko'p ma'lumot yo'qoladi), qator muhim (saqlash); usul: son — median/o'rtacha (median chidamli), kategoriya — mod (eng ko'p) yoki "Noma'lum", vaqt qatori — ffill (oldingi). Sabab: NaN'ni e'tiborsiz qoldirib bo'lmaydi (jim xato); lekin qanday ishlov — kontekstga (kam — o'chir; ko'p — to'ldir; tur — usul). Noto'g'ri strategiya — ma'lumot buziladi (0 bilan to'ldirish — o'rtachani o'zgartiradi; ko'p o'chirish — ma'lumot yo'qoladi). Strategiya — o'chirish (kam) vs to'ldirish (ko'p). Kontekst. Usul.

2.6. NaN amaliyoti

NaN amaliyoti: topish (isna().sum() — birinchi qadam, nechta); o'chirish (dropna — kam NaN, subset); to'ldirish (fillna — ko'p NaN; median son, "Noma'lum" kategoriya); strategiya (kam — o'chir, ko'p — to'ldir; kontekst); ffill/bfill (vaqt qatori); tekshirish (to'ldirib/o'chirib keyin isna().sum() — 0); tur (NaN float — int → float). Tuzoqlar: NaN e'tiborsiz (jim xato — statistika/model), == NaN (False — isna), 0 bilan to'ldirish (o'rtacha buziladi — median afzal), dropna natija (yangi — saqla), ko'p o'chirish (ma'lumot yo'qoladi). Amaliyot — isna, dropna, fillna, strategiya. Tozalash. Kontekst.

2.7. NaN tuzoqlari

NaN asosiy tuzoqlari: NaN e'tiborsiz (topmasdan ishlash — mean jim o'tkazadi (noto'g'ri), model xato beradi; doim isna().sum() birinchi); == NaN (df[df["a"] == np.nan] — bo'sh (NaN o'zi bilan teng emas); df[df["a"].isna()] — 2.9); 0 bilan to'ldirish (fillna(0) — 0 haqiqiy qiymat deb hisoblanadi (o'rtacha pasayadi, taqsimot buziladi); median/o'rtacha afzal — kontekstga); dropna natija (df.dropna() — yangi, asl o'zgarmaydi; df = df.dropna() yoki inplace); ko'p o'chirish (dropna() — bitta ustun ko'p NaN bo'lsa ko'p qator o'chadi; subset bilan aniq); tur o'zgaradi (int ustun NaN → float (NaN float); to'ldirib keyin astype(int)); fillna zanjir (df["a"].fillna(0) — Series qaytaradi, df["a"] = ... saqlash kerak); NaN vs bo'sh matn ("" — bo'sh matn, NaN emas; farqli). Sabab: NaN jim/maxsus (ko'rinmas, == False, tur o'zgaradi — jim xato). Yechim: isna topish, isna() taqqoslash, median to'ldirish, natija saqlash. Tuzoqlar — e'tiborsiz, == NaN, 0 to'ldirish, ko'p o'chirish.

2.8. NaN — real ma'lumotning eng katta muammosi

NaN asosiy g'oyasi — real ma'lumotning eng katta muammosi: real ma'lumotda deyarli doim yo'q qiymatlar (javobsiz so'rov, ishlamagan sensor, bo'sh katak); NaN jim xato manbai (statistikada o'tkaziladi — jim; amalda tarqaladi; model ishlamaydi). NaN bilan to'g'ri ishlash — Data Science eng muhim ko'nikmasi. Topish (isna().sum() — birinchi qadam, qayerda/nechta), o'chirish (dropna — kam NaN), to'ldirish (fillna — ko'p NaN; median/kategoriya), strategiya (kontekst — kam o'chir, ko'p to'ldir; usul — tur). NaN maxsus (== NaN False — isna; amal tarqatadi; float). Data Science oqimi: NaN topish → qaror → ishlov → tekshir (tozalash — 6-qism). Bu 3.6 (ustunlar) davomi va 6-qism (tozalash), 20-qism (ML — NaN talab) uchun. NaN — real ma'lumotning eng katta muammosi (topish/o'chirish/to'ldirish). Jim xato. Tozalash yuragi.

3. Tez ma'lumotnoma

import pandas as pd
import numpy as np

# TOPISH (birinchi qadam):
df.isna()              # har katak (bool DataFrame)
df.isna().sum()        # har ustunda nechta NaN
df.isna().sum().sum()  # jami
df["yosh"].isna()      # bitta ustun
df[df["yosh"].isna()]  # NaN qatorlar (== NaN EMAS!)

# O'CHIRISH (kam NaN):
df.dropna()                    # NaN bor qatorlar
df.dropna(subset=["yosh"])     # faqat yosh NaN
df.dropna(axis=1)              # NaN bor ustunlar

# TO'LDIRISH (ko'p NaN):
df["yosh"].fillna(df["yosh"].median())   # median (afzal)
df["shahar"].fillna("Noma'lum")          # kategoriya
df["yosh"].ffill()                        # oldingi (vaqt qatori)

# STRATEGIYA:
#   kam NaN (<5%) → dropna · ko'p NaN → fillna
#   son → median · kategoriya → mod/"Noma'lum" · vaqt → ffill

QOIDA: isna().sum() birinchi · == NaN emas (isna) · median (0 emas) · natijani saqla

NaN xulosasi

NaN — real ma'lumotning eng katta muammosi (jim xato)
Topish — isna().sum() (birinchi qadam, nechta)
O'chirish — dropna (kam NaN, subset)
To'ldirish — fillna (ko'p NaN; median son, "Noma'lum" kategoriya)
Xatti-harakat — amalda tarqaladi, statistikada o'tkaziladi, == False

4. Batafsil misollar

Misollar real pandas bilan (deterministik) ishlaydi.

Misol 1 — Topish (isna)

"""NaN topish: isna (real pandas)."""

import numpy as np
import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "yosh": [25, np.nan, 30, np.nan],
        "shahar": ["T", "S", None, "B"],
        "daromad": [500, 700, np.nan, 900],
    })

    print("=== 1. Har ustunda NaN ===")
    print(f"  {df.isna().sum().to_dict()}")

    print("\n=== 2. Jami NaN ===")
    print(f"  jami: {df.isna().sum().sum()}")

    print("\n=== 3. NaN qatorlar ===")
    print(f"  yosh NaN qatorlar soni: {df['yosh'].isna().sum()}")

    print("\n=== 4. NaN emas (notna) ===")
    print(f"  yosh to'la: {df['yosh'].notna().sum()}")
    print("  ⭐ Topish — isna().sum() (birinchi qadam)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Har ustunda NaN ===
  {'yosh': 2, 'shahar': 1, 'daromad': 1}

=== 2. Jami NaN ===
  jami: 4

=== 3. NaN qatorlar ===
  yosh NaN qatorlar soni: 2

=== 4. NaN emas (notna) ===
  yosh to'la: 2
  ⭐ Topish — isna().sum() (birinchi qadam)

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — O'chirish (dropna)

"""NaN o'chirish: dropna (real pandas)."""

import numpy as np
import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "yosh": [25, np.nan, 30, 40],
        "shahar": ["T", "S", None, "B"],
    })

    print("=== 1. Barcha NaN qator ===")
    print(f"  asl: {len(df)}, dropna: {len(df.dropna())}")

    print("\n=== 2. subset (faqat yosh) ===")
    print(f"  yosh NaN o'chirilgan: {len(df.dropna(subset=['yosh']))}")

    print("\n=== 3. Ustun o'chirish ===")
    print(f"  ustunlar (axis=1): {list(df.dropna(axis=1).columns)}")

    print("\n=== 4. Natijani saqlash ===")
    toza = df.dropna()
    print(f"  toza qator: {len(toza)}, NaN: {toza.isna().sum().sum()}")
    print("  ⭐ O'chirish — dropna (kam NaN)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Barcha NaN qator ===
  asl: 4, dropna: 2

=== 2. subset (faqat yosh) ===
  yosh NaN o'chirilgan: 3

=== 3. Ustun o'chirish ===
  ustunlar (axis=1): []

=== 4. Natijani saqlash ===
  toza qator: 2, NaN: 0
  ⭐ O'chirish — dropna (kam NaN)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — To'ldirish (fillna)

"""NaN to'ldirish: fillna (real pandas)."""

import numpy as np
import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "yosh": [25, np.nan, 30, np.nan, 40],
        "shahar": ["T", "S", None, "B", None],
    })

    print("=== 1. Median bilan (son) ===")
    yosh_median = df["yosh"].median()
    df["yosh"] = df["yosh"].fillna(yosh_median)
    print(f"  median {yosh_median}, NaN: {df['yosh'].isna().sum()}")

    print("\n=== 2. Kategoriya ('Noma'lum') ===")
    df["shahar"] = df["shahar"].fillna("Nomalum")
    print(f"  shaharlar: {list(df['shahar'])}")

    print("\n=== 3. ffill (oldingi) ===")
    s = pd.Series([1.0, np.nan, np.nan, 4.0])
    print(f"  ffill: {list(s.ffill())}")

    print("\n=== 4. Tekshirish ===")
    print(f"  jami NaN: {df.isna().sum().sum()}")
    print("  ⭐ To'ldirish — fillna (median, kategoriya)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Median bilan (son) ===
  median 30.0, NaN: 0

=== 2. Kategoriya ('Noma'lum') ===
  shaharlar: ['T', 'S', 'Nomalum', 'B', 'Nomalum']

=== 3. ffill (oldingi) ===
  ffill: [1.0, 1.0, 1.0, 4.0]

=== 4. Tekshirish ===
  jami NaN: 0
  ⭐ To'ldirish — fillna (median, kategoriya)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 4 — NaN xatti-harakati

"""NaN xatti-harakati (real pandas)."""

import numpy as np
import pandas as pd


def main() -> None:
    s = pd.Series([1.0, np.nan, 3.0])

    print("=== 1. Amalda tarqaladi ===")
    print(f"  s + 5: {list(s + 5)} (NaN saqlanadi)")

    print("\n=== 2. Statistikada o'tkaziladi ===")
    print(f"  mean: {s.mean()} (NaN o'tkazildi: (1+3)/2)")
    print(f"  sum: {s.sum()} (NaN o'tkazildi)")

    print("\n=== 3. Taqqoslash (== False) ===")
    print(f"  np.nan == np.nan: {np.nan == np.nan} (o'zi bilan teng emas!)")

    print("\n=== 4. isna kerak ===")
    df = pd.DataFrame({"a": [1, np.nan, 3]})
    print(f"  == nan (bo'sh): {len(df[df['a'] == np.nan])}")
    print(f"  isna: {len(df[df['a'].isna()])}")
    print("  ⭐ NaN — tarqaladi, o'tkaziladi, == False")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Amalda tarqaladi ===
  s + 5: [6.0, nan, 8.0] (NaN saqlanadi)

=== 2. Statistikada o'tkaziladi ===
  mean: 2.0 (NaN o'tkazildi: (1+3)/2)
  sum: 4.0 (NaN o'tkazildi)

=== 3. Taqqoslash (== False) ===
  np.nan == np.nan: False (o'zi bilan teng emas!)

=== 4. isna kerak ===
  == nan (bo'sh): 0
  isna: 1
  ⭐ NaN — tarqaladi, o'tkaziladi, == False

Nima ko'rsatdi: 2.4-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. NaN e'tiborsiz

df["a"].mean()   # NaN jim o'tkaziladi (bilmasdan)           # ⚠️
df["a"].isna().sum()   # avval topish                         # ✅

2. == NaN

df[df["a"] == np.nan]   # bo'sh (NaN teng emas)               # ⚠️
df[df["a"].isna()]   # to'g'ri                                 # ✅

3. 0 bilan to'ldirish

df["yosh"].fillna(0)   # o'rtacha buziladi (0 haqiqiy deb)    # ⚠️
df["yosh"].fillna(df["yosh"].median())   # median             # ✅

4. dropna natijasi

df.dropna()   # asl o'zgarmaydi                               # ⚠️
df = df.dropna()   # natijani saqla                            # ✅

5. Ko'p o'chirish

df.dropna()   # bitta ustun ko'p NaN → ko'p qator o'chadi     # ⚠️
df.dropna(subset=["muhim"])   # aniq ustun                     # ✅

6. Tur (float)

# int ustun NaN → float                                       # ⚠️
df["yosh"].fillna(0).astype(int)   # to'ldirib int            # ✅

7. fillna saqlash

df["a"].fillna(0)   # Series qaytaradi (asl o'zgarmaydi)      # ⚠️
df["a"] = df["a"].fillna(0)   # saqlash                        # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 2.9-dars (o'tilgan): NumPy shart (isnan)
• 3.6-dars (o'tilgan): Ustunlar (tur, to_numeric)
• 6-qism: Tozalash (NaN — asosiy muammo)
• 4-qism: Statistika (NaN — o'rtacha ta'siri)
• 20-qism: ML (model NaN bilan ishlamaydi)

8. Eng yaxshi amaliyotlar

1. isna().sum() — birinchi qadam (topish).

2. isna() — taqqoslash (== NaN emas).

3. dropna — kam NaN (subset).

4. fillna(median) — ko'p NaN (0 emas).

5. Kategoriya — "Noma'lum" (fillna).

6. Natijani saqla (dropna/fillna yangi).

7. Ishlovdan keyin isna().sum() tekshir.

8. NaN — real ma'lumotning eng katta muammosi.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # NaN nima?
2.  # isna nima?
3.  # nechta NaN qanday?
4.  # dropna nima?
5.  # subset nima uchun?
6.  # fillna nima?
7.  # median yoki 0?
8.  # NaN amalda?
9.  # NaN statistikada?
10. # == NaN?
11. # kam NaN strategiya?
12. # nega NaN muhim?

Vazifa 2: Xatolarni tuzating

1.  df["a"].mean()   # NaN topmasdan

2.  df[df["a"] == np.nan]   # NaN qatorlar

3.  df["yosh"].fillna(0)   # median kerak

4.  df.dropna()   # asl o'zgarmaydi

5.  df["a"].fillna(0)   # saqlash

1.  df["a"].isna().sum()   # avval topish

2.  df[df["a"].isna()]

3.  df["yosh"].fillna(df["yosh"].median())

4.  df = df.dropna()

5.  df["a"] = df["a"].fillna(0)

Vazifa 3: Topish

Modellang:

1. isna
2. sum
3. Qayerda
4. Nechta

Vazifa 4: O'chirish

Modellang:

1. dropna
2. subset
3. axis
4. Kam NaN

Vazifa 5: To'ldirish

Modellang:

1. fillna
2. Median
3. Kategoriya
4. ffill

Vazifa 6: Strategiya

Modellang:

1. Kam → o'chir
2. Ko'p → to'ldir
3. Son → median
4. Kontekst

Vazifa 7: O'ylash

NaN'ni to'ldirishda oddiy tanlov — 0 bilan to'ldirish (fillna(0)), lekin median yoki o'rtacha ko'pincha yaxshiroq. Nima uchun 0 bilan to'ldirish ko'pincha ma'lumotni "buzadi" (statistikani noto'g'ri qiladi), va nega "yo'q qiymatni qanday to'ldirish" o'zi muhim qaror (nega bir universal to'g'ri javob yo'q)?

Nimani mustahkamlaydi: 2.3, 2.5-bo'limlar.

Xulosa

Bu darsda NaN bilan ishlashni o'rgandik.

Eng muhim uch fikr:

1. NaN va topish. NaN (Not a Number) — yo'q/bo'sh qiymat (np.nan, None); real ma'lumotda deyarli doim bor. Topish — df.isna() (har katak — bool), df.isna().sum() (har ustunda nechta — birinchi qadam), .sum().sum() (jami), df[df["a"].isna()] (NaN qatorlar — == NaN emas!). NaN ko'rinmas — avval topish shart.

2. O'chirish va to'ldirish. O'chirish — df.dropna() (NaN bor qatorlar), subset= (faqat ba'zi ustun), axis=1 (ustun); kam NaN uchun. To'ldirish — df.fillna(median()) (son — median afzal, 0 emas), fillna("Noma'lum") (kategoriya), ffill/bfill (vaqt qatori — oldingi/keyingi); ko'p NaN uchun. Natija saqla (df = df.dropna(); fillna Series qaytaradi).

3. Eng katta muammo. NaN xatti-harakati — amalda tarqaladi (NaN + 5 = NaN), statistikada o'tkaziladi (mean NaN'ni jim — noto'g'ri bo'lishi mumkin), taqqoslash False (NaN == NaN False — isna kerak). Strategiya — kam NaN o'chir, ko'p to'ldir; tur — son median, kategoriya mod, vaqt ffill; kontekstga (universal javob yo'q). NaN — real ma'lumotning eng katta muammosi (jim xato — tozalash yuragi 6-qism; model NaN bilan ishlamaydi 20-qism). Tuzoqlar: NaN e'tiborsiz, == NaN (isna), 0 to'ldirish (buzadi — median), ko'p o'chirish (subset), tur float.

Keyingi darsda guruhlash (groupby)ni o'rganamiz: ma'lumotni guruhlarga bo'lib tahlil qilish (har shahar bo'yicha o'rtacha, har kategoriya bo'yicha jami) — Data Science tahlilining eng kuchli vositasi.