IlmHamroh
Python kursi/Malumot tahlili8/18-dars15 daqiqa
Mundarija (22)

24.8-dars: pandas — tozalash

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

1. Kirish va motivatsiya

24.6 da ko'rdik: real ma'lumot iflos — "garbage in, garbage out". Endi shu iflos ma'lumotni tozalash: bo'sh qiymatlar (NaN — yo'q narx), dublikatlar (bir yozuv ikki marta), noto'g'ri turlar (son matn bo'lib qolgan), nomuvofiq matn ("EN", "en", "En" — bir narsa), noto'g'ri qiymatlar (manfiy yosh). Bularsiz tahlil noto'g'ri natija beradi.

Ma'lumot tozalash — tahlilning eng ko'p vaqt oladigan qismi (ba'zan 80%). pandas tozalash vositalari: bo'sh qiymatlar (dropna, fillna), dublikatlar (drop_duplicates), turlar (astype, to_numeric), matn (.str.lower, .str.strip, replace), nom (rename). Toza ma'lumot — to'g'ri tahlilning zaruriy sharti. "Iflos ma'lumot bilan eng yaxshi model ham xato".

Real vaziyat. Bir hisobot noto'g'ri chiqdi — o'rtacha narx juda past edi. Sabab: ba'zi narxlar matn ("N/A"), ba'zi qatorlar takror, "uz"/"UZ"/"Uz" alohida hisoblangan. Tozalash qilindi: fillna (bo'sh — o'rtacha), drop_duplicates (takror), str.lower (matn birxil), to_numeric (son). Hisobot to'g'ri bo'ldi. Tozalash — ishonchli tahlilning poydevori.

Bu darsda pandas tozalashni o'rganamiz.

Bu darsda:

  • Bo'sh qiymatlar (isna, dropna, fillna)
  • Dublikatlar (drop_duplicates)
  • Turlarni tuzatish (astype, to_numeric)
  • Matn tozalash (.str)
  • Qiymat almashtirish (replace)
  • Ustun nomi (rename)
  • Noto'g'ri qiymatlar
  • Amaliy: to'liq tozalash

ℹ Misollarda pandas (import pandas as pd) bilan sinaladi.

2. Nazariya — chuqur tushuntirish

2.1. Bo'sh qiymatlar (isna, dropna, fillna)

NaN — yo'q ma'lumot:

python
df.isna().sum()          # har ustunda bo'sh soni
df.dropna()              # bo'sh qatorlarni o'chir
df.dropna(subset=["narx"])  # faqat narx bo'sh bo'lsa
df.fillna(0)             # bo'shni 0 ga
df["narx"].fillna(df["narx"].mean())  # o'rtacha bilan

Bo'sh qiymatlar (NaN): .isna().sum() (birinchi qadam — qayerda, qancha bo'sh), .dropna() (bo'sh qatorlarni o'chir — subset bilan faqat ba'zi ustun), .fillna(qiymat) (to'ldir — 0, o'rtacha, oldingi qiymat). Tanlov: bo'sh kam bo'lsa o'chir (dropna), muhim bo'lsa to'ldir (fillna). Ma'lumotga qarab.

2.2. Dublikatlar (drop_duplicates)

Takrorlangan qatorlar:

python
df.duplicated()              # takror qator (bool)
df.duplicated().sum()        # takror soni
df.drop_duplicates()         # takrorlarni o'chir
df.drop_duplicates(subset=["nom"], keep="first")  # nom bo'yicha

Dublikatlar — takrorlangan qatorlar (bir yozuv ikki marta — xato manba, birlashtirish): .duplicated() (takrormi — bool), .duplicated().sum() (soni), .drop_duplicates() (o'chir). subset (qaysi ustun bo'yicha takror), keep="first"/"last" (qaysini saqla). Takror ma'lumot — noto'g'ri sanoq/statistika. Tozalashning muhim qadami.

2.3. Turlarni tuzatish (astype, to_numeric)

Noto'g'ri tur — matn bo'lib qolgan son:

python
df["narx"].astype(int)              # tur o'zgartirish
pd.to_numeric(df["narx"], errors="coerce")  # matn → son (xato → NaN)
df["narx"].astype("Int64")          # nullable int (NaN bilan)
df["sana"] = pd.to_datetime(df["sana"])  # sana

Turlarni tuzatish: .astype(int) (tur o'zgartirish — 24.4), pd.to_numeric(x, errors="coerce") (matnni songa — xato qiymat → NaN, xavfsiz), pd.to_datetime (sanaga). "Int64" (bosh harf — nullable int, NaN bilan ishlaydi). Real ma'lumotda son ko'pincha matn ("100", "N/A") — to'g'ri turga o'girish kerak. errors="coerce" — xatoda to'xtamaydi.

2.4. Matn tozalash (.str)

Nomuvofiq matn:

python
df["til"].str.lower()        # kichik harf
df["til"].str.upper()        # katta harf
df["nom"].str.strip()        # bo'sh joylarni olib tashla
df["nom"].str.replace(" ", "_")  # almashtirish
df["til"].str.strip().str.lower()  # zanjir

Matn tozalash (.str — 04-qism satrlar): .str.lower()/.str.upper() (harf birxil — "EN"/"en" → "en"), .str.strip() (chet bo'sh joylar), .str.replace(a, b) (almashtirish). Zanjir bilan (.str.strip().str.lower()). Nomuvofiq matn ("uz", "UZ", "Uz") — bir narsa sifatida hisoblanmaydi — tozalash birxil qiladi.

2.5. Qiymat almashtirish (replace, map)

Qiymatlarni o'zgartirish:

python
df["til"].replace({"en": "english", "uz": "uzbek"})  # lug'at
df["status"].replace("kut", "kutilmoqda")            # bitta
df["baho"].map({1: "past", 2: "o'rta", 3: "yuqori"}) # xarita

replace — qiymatlarni almashtirish: .replace({eski: yangi}) (lug'at — ko'p qiymat), .replace(eski, yangi) (bitta). .map({...}) — har qiymatni xarita bo'yicha (kategoriyani belgiga). Bu kod (1, 2, 3) ni ma'noga ("past", "o'rta") yoki nomuvofiqni birxilga. Ma'lumotni standartlashtirish (bir xil ko'rinish).

2.6. Ustun nomi (rename)

Ustunlarni qayta nomlash:

python
df.rename(columns={"nom": "mahsulot", "narx": "price"})
df.columns = ["a", "b", "c"]              # hammasi
df.columns = df.columns.str.lower()        # kichik harf
df.columns = df.columns.str.strip()        # bo'sh joy

rename(columns={...}) — ustun nomlarini o'zgartirish (lug'at — eski: yangi). df.columns = [...] (hammasini). df.columns.str.lower() (barcha nom kichik). Real ma'lumotda ustun nomlari iflos ("Narx ", "NOM", bo'sh joyli) — birxil, toza nomga keltirish. O'qiluvchan va ishlashga qulay.

2.7. Noto'g'ri qiymatlar

Mantiqsiz qiymatlar:

python
df[df["yosh"] < 0]                    # noto'g'ri (manfiy yosh)
df.loc[df["yosh"] < 0, "yosh"] = None # NaN ga (keyin fillna)
df = df[df["narx"] > 0]               # noto'g'rini o'chir
df["narx"] = df["narx"].clip(0, 1000) # oraliqda chekla

Noto'g'ri qiymatlar — mantiqsiz (manfiy yosh, 200 baho, kelajak sana): topish (df[df.yosh < 0]), tuzatish (loc bilan NaN yoki o'chirish, clip bilan cheklash). Bu bo'sh emas, lekin xato qiymat — statistikani buzadi. Mantiqiy chegara (yosh 0–120, baho 0–100) bilan tekshir. Ma'lumot to'g'riligi (validation).

2.8. Tozalash jarayoni

Tozalash tartibi: 1) ma'lumotni tani (head, dtypes, isna, describe), 2) bo'sh qiymatlar (fillna/dropna), 3) dublikatlar (drop_duplicates), 4) turlar (to_numeric, astype), 5) matn (.str), 6) noto'g'ri qiymatlar (mantiqiy chegara), 7) ustun nomlari (rename). Har qadamdan keyin tekshir. Tozalash — takrorlanadigan (skript — 26-qism) bo'lsin (qo'lda emas). "Toza ma'lumot — to'g'ri tahlil" — poydevor.

3. Tez ma'lumotnoma

python
import pandas as pd

# bo'sh qiymatlar:
df.isna().sum()                          # tekshir
df.dropna(subset=["narx"])               # o'chir
df["narx"].fillna(df["narx"].mean())     # to'ldir

# dublikatlar:
df.duplicated().sum()
df.drop_duplicates(subset=["nom"], keep="first")

# turlar:
pd.to_numeric(df["narx"], errors="coerce")
df["sana"] = pd.to_datetime(df["sana"])
df["narx"].astype("Int64")               # nullable int

# matn:
df["til"].str.strip().str.lower()
df["til"].replace({"en": "english"})

# ustun nomi:
df.rename(columns={"nom": "mahsulot"})
df.columns = df.columns.str.lower()

# noto'g'ri qiymat:
df = df[df["yosh"] > 0]
df["narx"] = df["narx"].clip(0, 1000)

Tozalash xulosasi

Bo'sh: isna/dropna/fillna · dublikat: drop_duplicates
Tur: to_numeric/astype · matn: str.lower/strip · replace: almashtirish
rename: ustun nomi · noto'g'ri: mantiqiy chegara · takrorlanadigan skript

4. Batafsil misollar

Misollarda pandas (import pandas as pd) bilan sinaladi.

Misol 1 — Bo'sh qiymatlar

python
"""bo'sh qiymatlar: isna (tekshir), dropna (o'chir), fillna (to'ldir — 0, o'rtacha)."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "nom": ["Python", "Go", None, "PHP", "Ruby"],
        "narx": [100, None, 150, 80, None],
    })

    print("=== 1. isna (bo'shni tekshir) ===")
    print(f"  har ustunda bo'sh: {df.isna().sum().to_dict()}")

    print("\n=== 2. dropna (bo'sh qatorlarni o'chir) ===")
    print(f"  original qatorlar: {len(df)}")
    print(f"  dropna keyin: {len(df.dropna())}")

    print("\n=== 3. fillna (0 bilan) ===")
    print(f"  narx fillna(0): {df['narx'].fillna(0).tolist()}")

    print("\n=== 4. fillna (o'rtacha bilan) ===")
    ortacha = df["narx"].mean()
    print(f"  o'rtacha: {round(ortacha, 1)}")
    print(f"  fillna(o'rtacha): {df['narx'].fillna(ortacha).round(1).tolist()}")
    print("  ⭐ isna → dropna yoki fillna (ma'lumotga qarab)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. isna (bo'shni tekshir) ===
  har ustunda bo'sh: {'nom': 1, 'narx': 2}

=== 2. dropna (bo'sh qatorlarni o'chir) ===
  original qatorlar: 5
  dropna keyin: 2

=== 3. fillna (0 bilan) ===
  narx fillna(0): [100.0, 0.0, 150.0, 80.0, 0.0]

=== 4. fillna (o'rtacha bilan) ===
  o'rtacha: 110.0
  fillna(o'rtacha): [100.0, 110.0, 150.0, 80.0, 110.0]
  ⭐ isna → dropna yoki fillna (ma'lumotga qarab)

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — Dublikatlar va turlar

python
"""dublikatlar (duplicated, drop_duplicates); turlar (to_numeric errors=coerce, astype)."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "nom": ["Python", "Go", "Python", "Rust", "Go"],
        "narx": [100, 120, 100, 150, 120],
    })

    print("=== 1. Dublikatlar (duplicated) ===")
    print(f"  takror qatorlar soni: {df.duplicated().sum()}")

    print("\n=== 2. drop_duplicates ===")
    toza = df.drop_duplicates()
    print(f"  original: {len(df)}, tozalangan: {len(toza)}")

    print("\n=== 3. subset bo'yicha (nom) ===")
    nom_uniq = df.drop_duplicates(subset=["nom"], keep="first")
    print(f"  noyob nomlar: {nom_uniq['nom'].tolist()}")

    print("\n=== 4. to_numeric (matn → son) ===")
    df2 = pd.DataFrame({"narx": ["100", "200", "N/A", "150"]})
    df2["narx_son"] = pd.to_numeric(df2["narx"], errors="coerce")
    print(f"  matn: {df2['narx'].tolist()}")
    print(f"  son (xato→NaN): {df2['narx_son'].tolist()}")
    print("  ⭐ drop_duplicates (takror), to_numeric (tur)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Dublikatlar (duplicated) ===
  takror qatorlar soni: 2

=== 2. drop_duplicates ===
  original: 5, tozalangan: 3

=== 3. subset bo'yicha (nom) ===
  noyob nomlar: ['Python', 'Go', 'Rust']

=== 4. to_numeric (matn → son) ===
  matn: ['100', '200', 'N/A', '150']
  son (xato→NaN): [100.0, 200.0, nan, 150.0]
  ⭐ drop_duplicates (takror), to_numeric (tur)

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

Misol 3 — Matn tozalash va almashtirish

python
"""matn tozalash (str.strip, str.lower); replace (lug'at); rename (ustun nomi)."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "Nom ": ["Python", "Go", "Rust"],
        "til": [" UZ", "en ", "En"],
    })

    print("=== 1. Ustun nomi tozalash (rename/strip) ===")
    df.columns = df.columns.str.strip().str.lower()
    print(f"  ustunlar: {list(df.columns)}")

    print("\n=== 2. Matn tozalash (strip + lower) ===")
    df["til"] = df["til"].str.strip().str.lower()
    print(f"  til: {df['til'].tolist()}")

    print("\n=== 3. replace (lug'at bilan) ===")
    df["til_toliq"] = df["til"].replace({"uz": "uzbek", "en": "english"})
    print(f"  to'liq: {df['til_toliq'].tolist()}")

    print("\n=== 4. rename (ustun qayta nomlash) ===")
    df = df.rename(columns={"nom": "mahsulot"})
    print(f"  yangi ustunlar: {list(df.columns)}")
    print("  ⭐ str (matn), replace (qiymat), rename (ustun) — tozalash")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Ustun nomi tozalash (rename/strip) ===
  ustunlar: ['nom', 'til']

=== 2. Matn tozalash (strip + lower) ===
  til: ['uz', 'en', 'en']

=== 3. replace (lug'at bilan) ===
  to'liq: ['uzbek', 'english', 'english']

=== 4. rename (ustun qayta nomlash) ===
  yangi ustunlar: ['mahsulot', 'til', 'til_toliq']
  ⭐ str (matn), replace (qiymat), rename (ustun) — tozalash

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

Misol 4 — Amaliy: to'liq tozalash quvuri

Real misol: iflos ma'lumot — bo'sh, takror, matn son, nomuvofiq til, noto'g'ri narx. To'liq tozalash. Bu — ma'lumot tozalashning namunasi.

python
"""to'liq tozalash: bo'sh (fillna), takror (drop_duplicates), tur (to_numeric), matn (str), noto'g'ri (filtr)."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    # iflos ma'lumot
    df = pd.DataFrame({
        "mahsulot": ["Python", "Go", "Python", "Rust", "PHP"],
        "narx": ["100", "120", "100", "N/A", "-50"],       # matn, N/A, manfiy
        "til": [" UZ", "en", " uz", "EN ", "Uz"],           # nomuvofiq
    })

    print("=== 1. Boshlang'ich holat ===")
    print(f"  qatorlar: {len(df)}, ustunlar: {list(df.columns)}")

    print("\n=== 2. Turlarni tuzat (narx → son) ===")
    df["narx"] = pd.to_numeric(df["narx"], errors="coerce")
    print(f"  narx (son, xato→NaN): {df['narx'].tolist()}")

    print("\n=== 3. Matn tozala (til birxil) ===")
    df["til"] = df["til"].str.strip().str.lower()
    print(f"  til: {df['til'].tolist()}")

    print("\n=== 4. Takror, bo'sh, noto'g'ri tozala ===")
    df = df.drop_duplicates(subset=["mahsulot"], keep="first")   # takror
    df = df[df["narx"] > 0]                                       # noto'g'ri/bo'sh (NaN>0 False)
    print(f"  yakuniy qatorlar: {len(df)}")
    print(f"  toza mahsulotlar: {df['mahsulot'].tolist()}")
    print(f"  o'rtacha narx: {round(df['narx'].mean(), 1)}")
    print("  ⭐ tur → matn → takror → noto'g'ri — to'liq tozalash")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Boshlang'ich holat ===
  qatorlar: 5, ustunlar: ['mahsulot', 'narx', 'til']

=== 2. Turlarni tuzat (narx → son) ===
  narx (son, xato→NaN): [100.0, 120.0, 100.0, nan, -50.0]

=== 3. Matn tozala (til birxil) ===
  til: ['uz', 'en', 'uz', 'en', 'uz']

=== 4. Takror, bo'sh, noto'g'ri tozala ===
  yakuniy qatorlar: 2
  toza mahsulotlar: ['Python', 'Go']
  o'rtacha narx: 110.0
  ⭐ tur → matn → takror → noto'g'ri — to'liq 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
"Ma'lumot toza" Real ma'lumot iflos (tekshir)
"Bo'sh — doim o'chir" Ma'lumotga qarab (fillna ham)
"astype(int) NaN bilan" to_numeric/Int64 (nullable)
"Takror muammo emas" Statistikani buzadi
"'UZ' = 'uz'" Yo'q (str.lower kerak)
"Bo'sh = noto'g'ri" Bo'sh (NaN) ≠ xato qiymat
"Tozalash bir marta" Takrorlanadigan skript
"Turlar to'g'ri" Tekshir (son matn bo'lishi mumkin)

6. Keng tarqalgan xatolar va yechimlari

1. Bo'sh qiymatlarni tekshirmaslik

python
df["narx"].mean()   # NaN aralash                  # ⚠️
df["narx"].isna().sum()  # avval tekshir            # ✅

2. astype(int) NaN bilan

python
df["narx"].astype(int)   # NaN — xato               # ⚠️
pd.to_numeric(df["narx"], errors="coerce")          # ✅

3. Matnni birxil qilmaslik

python
df["til"].value_counts()  # UZ, uz, Uz alohida       # ⚠️
df["til"].str.lower().value_counts()                 # ✅

4. errors="coerce"siz to_numeric

python
pd.to_numeric(df["x"])   # xato qiymatda to'xtaydi    # ⚠️
pd.to_numeric(df["x"], errors="coerce")              # ✅

5. Takror ustunda subsetsiz

python
df.drop_duplicates()   # butun qator bir xil bo'lsa   # ba'zan kerak
df.drop_duplicates(subset=["id"])  # id bo'yicha       # ✅

6. Noto'g'ri qiymatni sezmaslik

python
df["yosh"].mean()   # manfiy yosh aralash             # ⚠️
df = df[df["yosh"] > 0]  # avval filtrla              # ✅

7. Tozalashni asl'ga saqlamaslik

python
df.dropna()   # yangi (asl o'zgarmaydi)               # ⚠️
df = df.dropna()   # yoki inplace                     # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 24.6-dars (o'tilgan): O'qish — iflos ma'lumot manbai
  • 24.7-dars (o'tilgan): Filtr — noto'g'ri qiymatlar
  • 24.9-dars: Guruhlash — toza ma'lumot
  • 25-qism: ML — ma'lumot tayyorlash (tozalash)
  • 26-qism: Avtomatlashtirish — tozalash skripti

8. Eng yaxshi amaliyotlar

  1. Avval tani (isna, dtypes, describe).

  2. Bo'sh — ma'lumotga qarab (dropna/fillna).

  3. to_numeric(errors="coerce") — matn son.

  4. Takror — drop_duplicates (subset).

  5. Matn — .str.strip().str.lower() (birxil).

  6. Noto'g'ri qiymat — mantiqiy chegara.

  7. Ustun nomi — toza (rename, str.lower).

  8. Tozalash — takrorlanadigan skript.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # isna nima?
2.  # dropna nima?
3.  # fillna nima?
4.  # drop_duplicates nima?
5.  # to_numeric errors=coerce?
6.  # astype vs to_numeric?
7.  # str.lower nima?
8.  # replace nima?
9.  # rename nima?
10. # noto'g'ri qiymat vs bo'sh?
11. # Int64 nima?
12. # tozalash tartibi?
Javoblar
  1. Qayerda bo'sh (tekshirish)
  2. Bo'sh qatorlarni o'chirish
  3. Bo'shni to'ldirish
  4. Takror qatorlarni o'chirish
  5. Matn → son (xato → NaN)
  6. astype qat'iy, to_numeric xavfsiz (coerce)
  7. Matn kichik harf
  8. Qiymat almashtirish
  9. Ustun qayta nomlash
  10. Bo'sh — yo'q, noto'g'ri — xato qiymat
  11. Nullable int (NaN bilan)
  12. Tani → bo'sh → takror → tur → matn → noto'g'ri

Vazifa 2: Xatolarni tuzating

python
1.  df["narx"].astype(int)  # NaN bor       # to_numeric

2.  df["til"].value_counts()  # UZ, uz      # str.lower

3.  pd.to_numeric(df["x"])  # xato qiymat    # errors=coerce

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

5.  df["yosh"].mean()  # manfiy aralash       # filtr
Javoblar
python
1.  pd.to_numeric(df["narx"], errors="coerce")

2.  df["til"].str.lower().value_counts()

3.  pd.to_numeric(df["x"], errors="coerce")

4.  df = df.dropna()

5.  df[df["yosh"] > 0]["yosh"].mean()

Vazifa 3: Bo'sh qiymatlar

Tozalash:

  1. isna tekshir
  2. dropna
  3. fillna (0)
  4. fillna (o'rtacha)

Vazifa 4: Dublikat va tur

Tozalash:

  1. duplicated
  2. drop_duplicates
  3. to_numeric
  4. astype

Vazifa 5: Matn

Tozalash:

  1. str.strip
  2. str.lower
  3. replace
  4. rename

Vazifa 6: To'liq

Quvur:

  1. Iflos ma'lumot
  2. Turlar
  3. Bo'sh, takror
  4. Noto'g'ri

Vazifa 7: O'ylash

Ma'lumot tozalash — tahlilning eng ko'p vaqt oladigan qismi (ba'zan 80%). Bo'sh qiymat (NaN — yo'q) va noto'g'ri qiymat (manfiy yosh — xato) farq qiladi. Nima uchun "tozalash — tahlilning asosiy qismi", va nega uni takrorlanadigan (skript, qo'lda emas) qilish muhim — "toza ma'lumot, to'g'ri natija" tamoyili bilan qanday bog'liq?

Javob

Qisqa javob: Tozalash tahlilning 80% vaqtini oladi, chunki real ma'lumot iflos (bo'sh, takror, xato, nomuvofiq) va toza ma'lumotsiz tahlil noto'g'ri ("garbage in, garbage out", 24.6). Bo'sh (NaN — ma'lumot yo'q) va noto'g'ri (manfiy yosh — ma'lumot xato) farq: bo'shni to'ldirish/o'chirish, xatoni tuzatish/o'chirish. Tozalash takrorlanadigan (skript) bo'lsin, chunki: ma'lumot yangilanadi (har oy yangi CSV — qo'lda tozalash takror mehnat), hujjatlangan (skript — nima qilindi, ko'rinadi), xatosiz (qo'lda tozalash — inson xatosi), tekshiriladigan (test — 17-qism). "Toza ma'lumot — to'g'ri natija" — poydevor; skript bilan ishonchli va takrorlanadigan.

1. Nega 80% tozalash

Real ma'lumot iflos (odam kiritgan, turli tizim). Toza ma'lumotsiz — noto'g'ri tahlil. Tozalash — poydevor (uy poydevori kabi).

2. Bo'sh vs noto'g'ri

Bo'sh (NaN) Noto'g'ri
Ma'lumot yo'q Ma'lumot xato
isna Mantiqiy chegara
dropna/fillna Tuzat/o'chir/clip
Bilamiz yo'qligini Sezish kerak

3. Nega takrorlanadigan skript

Qo'lda Skript
Har safar takror Bir marta yoz, qayta ishlat
Xato (inson) Ishonchli
Hujjatsiz Kod — hujjat
Yangi ma'lumot — qayta Avtomatik

Ma'lumot yangilanadi (har oy) — skript qayta ishlaydi. Qo'lda — takror mehnat va xato.

4. "Toza ma'lumot, to'g'ri natija"

Iflos → xato natija (garbage in, garbage out). Toza → ishonchli tahlil. Tozalash — tahlilning zaruriy sharti (bezak emas).

5. Muhandislik saboqlari

  1. Tozalash — tahlilning asosi (80%)
  2. Bo'sh (yo'q) ≠ noto'g'ri (xato)
  3. Takrorlanadigan skript (qo'lda emas)
  4. Toza ma'lumot — to'g'ri natija (poydevor)

6. Xulosa

  1. Tozalash — vaqt oladi, lekin zaruriy
  2. Bo'sh va noto'g'ri — har xil
  3. Skript (takrorlanadigan, hujjatlangan)
  4. Ma'lumot sifati — natija sifati

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.

Xulosa

Bu darsda pandas tozalashni o'rgandik.

Eng muhim uch fikr:

  1. Bo'sh qiymatlar va dublikatlar. Bo'sh qiymatlar (NaN): .isna().sum() (birinchi qadam — qayerda, qancha), .dropna() (o'chir — subset bilan ba'zi ustun), .fillna(qiymat) (to'ldir — 0, o'rtacha). Tanlov ma'lumotga qarab (kam bo'lsa o'chir, muhim bo'lsa to'ldir). Dublikatlar (takror qatorlar): .duplicated().sum() (soni), .drop_duplicates(subset=[...], keep="first") (o'chir). Takror — noto'g'ri sanoq/statistika.

  2. Turlar va matn tozalash. Turlarni tuzatish: pd.to_numeric(x, errors="coerce") (matnni songa — xato → NaN, xavfsiz), pd.to_datetime (sanaga), .astype("Int64") (nullable int — NaN bilan). errors="coerce" muhim (xatoda to'xtamaydi). Matn tozalash (.str): .str.lower()/.str.strip() (birxil — "EN"/"en" → "en"), .str.replace. Qiymat: .replace({eski: yangi}) (almashtirish), .map({...}) (xarita). Ustun nomi: .rename(columns={...}), df.columns.str.lower().

  3. Noto'g'ri qiymatlar va jarayon. Noto'g'ri qiymatlar — mantiqsiz (manfiy yosh, 200 baho): topish (df[df.yosh < 0]), tuzatish (loc NaN, o'chirish, clip). Bo'sh (NaN — yo'q) va noto'g'ri (xato qiymat) farq qiladi. Tozalash tartibi: tani → bo'sh → dublikat → tur → matn → noto'g'ri → ustun nomi. Tozalash — tahlilning eng ko'p vaqt oladigan qismi (80%), takrorlanadigan skript bo'lsin (ma'lumot yangilanadi, hujjatlangan, xatosiz). "Toza ma'lumot — to'g'ri natija" — ishonchli tahlilning poydevori ("garbage in, garbage out", 24.6).

Keyingi darsda pandas: guruhlash ni o'rganamiz: groupby bilan ma'lumotni toifalab jamlash (har kategoriya bo'yicha jami, o'rtacha) — tahlilning eng kuchli vositalaridan.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
24.8-dars: pandas — tozalash — IlmHamroh