6.4-dars: Tur o'zgartirish

6-QISM — MA'LUMOTNI TOZALASH · 4-dars

1. Kirish va motivatsiya

Ma'lumot noto'g'ri turda kelishi mumkin: son matn sifatida saqlangan ("123" — string, int emas), sana matn ("2024-01-01" — datetime emas), kategoriya object (xotira ko'p). CSV o'qiganda 3.3-bob pandas turni taxmin qiladi — lekin har doim to'g'ri emas (bo'sh katak, aralash format, - belgisi). Tur o'zgartirish (type conversion) — ustunni to'g'ri turga keltirish: matnni songa (pd.to_numeric, astype), matnni sanaga (pd.to_datetime), object'ni kategoriyaga (astype("category") — xotira). Bu shart: matnni qo'shib bo'lmaydi ("12" + "3" = "123", 15 emas), sana matn bo'lsa vaqt amallari ishlamaydi (oy, kun ajratib bo'lmaydi). Nega muhim? (1) Hisob — matn songa qo'shib bo'lmaydi; (2) Vaqt — sana matn bo'lsa amallar yo'q; (3) Xotira — kategoriya/to'g'ri tur (samarali). Bu dars tur o'zgartirishni o'rgatadi — to'g'ri turga keltirish.

Tur o'zgartirish (type conversion) — to'g'ri turga: matn → son (pd.to_numeric, astype(int/float); errors="coerce" — xatoli → NaN), matn → sana (pd.to_datetime — vaqt amallari 3.12), object → kategoriya (astype("category") — xotira), tekshirish (df.dtypes, df.info()), xato format (aralash, -, bo'sh — coerce). Foydalanish: hisob (son), vaqt amallari (sana), xotira (kategoriya). Bu 3.3 (CSV o'qish), 3.12 (datetime), 6.1 (NaN — coerce), 6.11 (quvur) bilan bog'liq. Tur o'zgartirish — to'g'ri turga. Son. Sana.

Real vaziyat. Data Scientist CSV'dan savdo ma'lumotini o'qidi 3.3-bob. Iflos ma'lumot: narx ustuni matn ("1200", "1,500", "-" — vergul, bo'sh belgi), sana ustuni matn ("2024-01-15"). df.dtypes (narx: object, sana: object — noto'g'ri). Muammo: df["narx"].sum() — matn (qo'shib bo'lmaydi; yoki "12001500..." — birlashtiradi). Hal: narx → son (pd.to_numeric(df["narx"].str.replace(",", ""), errors="coerce") — vergul olib tashla, - → NaN), sana → datetime (pd.to_datetime(df["sana"]) — endi oy/kun ajratish). Data Scientist tekshirdi (dtypes), o'zgartirdi (to_numeric, to_datetime), hisobladi (sum). Tur o'zgartirish — to'g'ri turga.

Bu darsda tur o'zgartirishni o'rganamiz.

Bu darsda:

• Matn → son (to_numeric, astype)
• Matn → sana (to_datetime)
• errors="coerce" (xato → NaN)
• Kategoriya turi (xotira)
• Tur tekshirish (dtypes)
• Tur amaliyoti
• Tur tuzoqlari
• Amaliy: tur o'zgartirish

ℹ Misollar real pandas bilan (Python 3.14) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. Matn → son (to_numeric, astype)

Matnni raqamga:

import pandas as pd

# astype — oddiy o'zgartirish (toza matn → son)
df["narx"] = df["narx"].astype(int)     # yoki float

# pd.to_numeric — kuchliroq (xatoni boshqarish)
df["narx"] = pd.to_numeric(df["narx"])

# avval tozalash (vergul, bo'shliq)
df["narx"] = df["narx"].str.replace(",", "").str.strip()
df["narx"] = pd.to_numeric(df["narx"])

Matn → son (to_numeric, astype) — raqamga: astype(int/float) (oddiy — toza matn → son; "123" → 123), pd.to_numeric(df["x"]) (kuchliroq — xatoni boshqaradi; errors= bilan); avval tozalash (vergul "1,500", bo'shliq " 12 ", valyuta "$12" — str.replace/str.strip; keyin son). Sabab: matn son emas ("12" + "3" = "123" — birlashtiradi, 15 emas; hisob yo'q); son turga → hisob (sum, mean); astype (toza), to_numeric (xato — coerce). astype (toza matn), to_numeric (xato boshqarish), tozalash (vergul/bo'shliq oldin). Matn → son — to_numeric/astype (tozalab; hisob). Son. to_numeric.

2.2. Matn → sana (to_datetime)

Matnni sanaga:

import pandas as pd

# pd.to_datetime — matn → datetime (3.12)
df["sana"] = pd.to_datetime(df["sana"])

# format ko'rsatish (aniqroq/tezroq)
df["sana"] = pd.to_datetime(df["sana"], format="%Y-%m-%d")

# endi vaqt amallari (3.12)
df["sana"].dt.year    # yil
df["sana"].dt.month   # oy
df["sana"].dt.dayofweek   # hafta kuni

Matn → sana (to_datetime) — datetime: pd.to_datetime(df["sana"]) (matn → datetime; 3.12); format="%Y-%m-%d" (format ko'rsatish — aniqroq, tezroq; %Y yil, %m oy, %d kun); keyin vaqt amallari (.dt.year, .dt.month, .dt.dayofweek — 3.12). Sabab: sana matn bo'lsa vaqt amallari yo'q (oy/kun ajratib bo'lmaydi; saralash alfabet — noto'g'ri); datetime → vaqt (yil, oy, farq, resample — 3.12); format (aniq — "01/02/2024" — 1-fevral yoki 2-yanvar? format hal qiladi). to_datetime (matn → sana), format (aniq), .dt (vaqt amallari). Matn → sana — to_datetime (format; vaqt amallari). Sana. to_datetime.

2.3. errors="coerce" (xato → NaN)

errors="coerce" (xato → NaN) — xatoni boshqarish: pd.to_numeric(df["x"], errors="coerce") (o'zgartirib bo'lmaydigan qiymat → NaN; "abc", "-" → NaN); errors="raise" (standart — xato ko'taradi; to'xtaydi), errors="ignore" (o'zgartirma — asl qoldir). Sabab: real ma'lumot aralash (["12", "34", "-", "abc"] — ba'zisi son emas); raise (butun to'xtaydi — bitta xato), coerce (xatoli → NaN — davom; keyin NaN hal 6.1). coerce (xato → NaN — davom; afzal), raise (to'xta), ignore (o'zgartirma). errors — coerce (xato → NaN; keyin 6.1). coerce. NaN.

2.4. Kategoriya turi (xotira)

Kategoriya turi (xotira) — samaradorlik: astype("category") (takrorlanuvchi matn — kategoriya; shahar, jins, daraja); xotira tejaydi (matn — har qator to'liq satr; kategoriya — kodlar + lug'at; 1M qator "Toshkent" — bir marta saqlanadi). Sabab: object (matn) — xotira ko'p (har katak satr); kategoriya — kam (noyob qiymatlar lug'at, kodlar massiv); takrorlanuvchi (kam noyob — shahar 3-4 xil; kategoriya foydali), noyob (email — har xil; kategoriya foydasiz). astype("category") (takrorlanuvchi matn — xotira), kod + lug'at (samarali), tez (guruh, taqqoslash). Kategoriya turi — astype("category") (xotira; takrorlanuvchi). Kategoriya. Xotira.

2.5. Tur tekshirish (dtypes)

Tur tekshirish (dtypes) — turni ko'rish: df.dtypes (har ustun turi — int64, float64, object, datetime64, category), df.info() (turlar + NaN + xotira — umumiy), df["x"].dtype (bir ustun). Sabab: birinchi qadam — turlarni tekshirish (o'zgartirishdan oldin — nima noto'g'ri; narx: object — matn, tuzat); object (matn yoki aralash — shubha), int/float (son), datetime (sana), category (kategoriya). dtypes (turlar), info (turlar + NaN + xotira), object shubha (son/sana matnmi?). Tur tekshirish — dtypes/info (turni ko'r; object shubha). Tekshirish. dtypes.

2.6. Tur amaliyoti

Tur amaliyoti: tekshirish (df.dtypes/df.info() — nima noto'g'ri; object shubha); matn → son (tozalab — str.replace(",", ""); pd.to_numeric(..., errors="coerce")); matn → sana (pd.to_datetime(..., format=) — vaqt amallari); object → kategoriya (takrorlanuvchi — astype("category") — xotira); coerce keyin (xato → NaN — hal 6.1); tekshir (df.dtypes — to'g'ri bo'ldimi). Tuzoqlar: astype xato (aralash — to_numeric coerce), format yo'q (noaniq sana — kun/oy), coerce yashirin NaN (tekshir), kategoriya noyob (email — foydasiz), int NaN bilan (float — NaN int'da yo'q). Amaliyot — tekshirish, o'zgartirish, coerce, tekshir. To'g'ri tur. Hisob.

2.7. Tur tuzoqlari

Tur o'zgartirish asosiy tuzoqlari: astype aralash matn (astype(int) — toza matn ("123") ishlaydi; aralash ("12", "-", "abc") — xato (ValueError); pd.to_numeric(errors="coerce") afzal — xato → NaN); tozalamay ("1,500", "$12", " 12 " — vergul/valyuta/bo'shliq; to_numeric xato yoki NaN; avval str.replace/strip); format yo'q (to_datetime formatsiz — noaniq ("01/02/2024" — 1-fevral yoki 2-yanvar?; AQSH oy oldin, Yevropa kun oldin); format= aniq); coerce yashirin NaN (errors="coerce" — xato → NaN; lekin necha NaN? (jimda ko'p yo'qolishi mumkin); keyin isna().sum() tekshir); int NaN bilan (astype(int) — NaN int'da yo'q (xato); NaN bor → float (yoki Int64 — nullable); NaN hal keyin); kategoriya noyob (astype("category") — takrorlanuvchi (shahar) foydali; noyob (email, id) — xotira ko'proq (lug'at + kodlar — foydasiz)); bool matn ("True"/"False" matn — astype(bool) hammasi True (bo'sh emas satr — True!); map({"True": True}) yoki == "True"); sana turli format (aralash format — to_datetime ba'zan xato; format="mixed" yoki tozala); downcast (katta int/float — pd.to_numeric(downcast="integer") xotira tejaydi). Sabab: tur o'zgartirish format/xato nozik (aralash, tozalamay, coerce, int NaN — xato yoki yashirin yo'qotish). Yechim: to_numeric coerce, tozala (replace), format, coerce keyin tekshir, float NaN bilan. Tuzoqlar — astype, tozalamay, format, coerce.

2.8. Tur o'zgartirish — to'g'ri turga keltirish

Tur o'zgartirish asosiy g'oyasi — to'g'ri turga keltirish: ma'lumot noto'g'ri turda (son matn "123", sana matn "2024-01-01", kategoriya object — CSV taxmin 3.3, iflos ma'lumot) → to'g'ri tur (hisob, vaqt, xotira uchun). Matn → son (pd.to_numeric/astype; tozalab — vergul/valyuta; errors="coerce" xato → NaN), matn → sana (pd.to_datetime — format; vaqt amallari 3.12), object → kategoriya (astype("category") — takrorlanuvchi; xotira), tekshirish (df.dtypes/df.info() — object shubha). Foydalanish: hisob (son — sum/mean; matn qo'shib bo'lmaydi), vaqt amallari (sana — oy/kun/farq; matn bo'lsa yo'q), xotira (kategoriya/to'g'ri tur — samarali). Tuzoqlar: astype aralash (to_numeric coerce), tozalamay (replace), format yo'q (noaniq sana), coerce yashirin NaN (tekshir), int NaN bilan (float), kategoriya noyob (foydasiz), bool matn ("False" — True!). Bu 3.3 (CSV), 3.12 (datetime), 6.1 (NaN — coerce), 6.9 (kategoriya kodlash), 6.11 (quvur) bilan. Tur o'zgartirish — to'g'ri turga (matn→son, matn→sana, object→kategoriya; hisob/vaqt/xotira). Tur. To'g'ri. Hisob.

3. Tez ma'lumotnoma

import pandas as pd

# TEKSHIRISH (birinchi):
df.dtypes          # har ustun turi
df.info()          # turlar + NaN + xotira

# MATN → SON:
df["x"] = df["x"].astype(float)                    # toza matn
df["x"] = pd.to_numeric(df["x"], errors="coerce")  # xato → NaN
# avval tozalash (vergul, valyuta, bo'shliq):
df["narx"] = df["narx"].str.replace(",", "").str.strip()
df["narx"] = pd.to_numeric(df["narx"], errors="coerce")

# MATN → SANA:
df["sana"] = pd.to_datetime(df["sana"], format="%Y-%m-%d")
df["sana"].dt.year, df["sana"].dt.month   # vaqt amallari (3.12)

# OBJECT → KATEGORIYA (takrorlanuvchi — xotira):
df["shahar"] = df["shahar"].astype("category")

# INT NaN bilan → float (yoki Int64 nullable):
df["yosh"] = df["yosh"].astype("Int64")   # NaN saqlaydi

QOIDA: tekshir (dtypes) · tozalab (replace) · coerce (xato→NaN) · format (sana)

Tur o'zgartirish xulosasi

Tur o'zgartirish — to'g'ri turga (hisob, vaqt, xotira)
Matn → son — to_numeric/astype (tozalab; coerce — xato→NaN)
Matn → sana — to_datetime (format; vaqt amallari)
Object → kategoriya — astype("category") (takrorlanuvchi — xotira)
Tekshirish — dtypes/info (object shubha — son/sana matnmi?)

4. Batafsil misollar

Misollar real pandas bilan (Python 3.14) ishlaydi.

Misol 1 — Matn → son (tozalab)

"""Matn → son (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({"narx": ["1200", "1,500", "$800", " 950 ", "-"]})

    print("=== 1. Asl tur (object — matn) ===")
    print(f"  tur: {df['narx'].dtype}")

    print("\n=== 2. Tozalash (vergul, valyuta, bo'shliq) ===")
    df["narx_toza"] = (df["narx"].str.replace(",", "")
                       .str.replace("$", "").str.strip())
    print(f"  tozalangan: {df['narx_toza'].tolist()}")

    print("\n=== 3. to_numeric (coerce — '-' → NaN) ===")
    df["narx_son"] = pd.to_numeric(df["narx_toza"], errors="coerce")
    print(f"  son: {df['narx_son'].tolist()}")
    print(f"  yangi tur: {df['narx_son'].dtype}")

    print("\n=== 4. Endi hisob ===")
    print(f"  jami: {df['narx_son'].sum()}")
    print("  ⭐ Matn → son (tozalab; hisob)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Asl tur (object — matn) ===
  tur: str

=== 2. Tozalash (vergul, valyuta, bo'shliq) ===
  tozalangan: ['1200', '1500', '800', '950', '-']

=== 3. to_numeric (coerce — '-' → NaN) ===
  son: [1200.0, 1500.0, 800.0, 950.0, nan]
  yangi tur: float64

=== 4. Endi hisob ===
  jami: 4450.0
  ⭐ Matn → son (tozalab; hisob)

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

Misol 2 — Matn → sana

"""Matn → sana (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({"sana": ["2024-01-15", "2024-03-20", "2024-06-10"]})

    print("=== 1. Asl tur (object) ===")
    print(f"  tur: {df['sana'].dtype}")

    print("\n=== 2. to_datetime ===")
    df["sana"] = pd.to_datetime(df["sana"], format="%Y-%m-%d")
    print(f"  yangi tur: {df['sana'].dtype}")

    print("\n=== 3. Vaqt amallari 3.12-bob ===")
    print(f"  yil: {df['sana'].dt.year.tolist()}")
    print(f"  oy: {df['sana'].dt.month.tolist()}")

    print("\n=== 4. Nega datetime ===")
    print("  matn: alfabet saralash (noto'g'ri)")
    print("  datetime: vaqt amallari (oy, kun, farq)")
    print("  ⭐ Matn → sana (vaqt amallari)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Asl tur (object) ===
  tur: str

=== 2. to_datetime ===
  yangi tur: datetime64[us]

=== 3. Vaqt amallari 3.12-bob ===
  yil: [2024, 2024, 2024]
  oy: [1, 3, 6]

=== 4. Nega datetime ===
  matn: alfabet saralash (noto'g'ri)
  datetime: vaqt amallari (oy, kun, farq)
  ⭐ Matn → sana (vaqt amallari)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — Kategoriya (xotira)

"""Kategoriya turi: xotira (real pandas)."""

import pandas as pd


def main() -> None:
    shaharlar = ["Toshkent", "Samarqand", "Buxoro"] * 1000
    df = pd.DataFrame({"shahar": shaharlar})

    print("=== 1. Object (matn) xotira ===")
    obj_xotira = df["shahar"].memory_usage(deep=True)
    print(f"  object: {obj_xotira} bayt")

    print("\n=== 2. Kategoriya turiga ===")
    df["shahar"] = df["shahar"].astype("category")
    print(f"  yangi tur: {df['shahar'].dtype}")

    print("\n=== 3. Kategoriya xotira ===")
    cat_xotira = df["shahar"].memory_usage(deep=True)
    print(f"  kategoriya: {cat_xotira} bayt")

    print("\n=== 4. Tejash ===")
    tejash = round((1 - cat_xotira / obj_xotira) * 100)
    print(f"  tejaldi: ~{tejash}% (takrorlanuvchi qiymat)")
    print("  ⭐ Kategoriya — xotira tejaydi (takrorlanuvchi)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Object (matn) xotira ===
  object: 170132 bayt

=== 2. Kategoriya turiga ===
  yangi tur: category

=== 3. Kategoriya xotira ===
  kategoriya: 3302 bayt

=== 4. Tejash ===
  tejaldi: ~98% (takrorlanuvchi qiymat)
  ⭐ Kategoriya — xotira tejaydi (takrorlanuvchi)

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — Tekshirish va int NaN

"""Tur tekshirish va int NaN (real pandas)."""

import numpy as np
import pandas as pd


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

    print("=== 1. dtypes (tekshirish) ===")
    print(df.dtypes.to_string())

    print("\n=== 2. narx object (matn — shubha) ===")
    df["narx"] = pd.to_numeric(df["narx"])
    print(f"  narx yangi tur: {df['narx'].dtype}")

    print("\n=== 3. int NaN bilan (xato) ===")
    print("  yosh NaN bor → astype(int) xato")
    df["yosh"] = df["yosh"].astype("Int64")   # nullable int
    print(f"  Int64 (NaN saqlaydi): {df['yosh'].tolist()}")

    print("\n=== 4. Yakuniy turlar ===")
    print(df.dtypes.to_string())
    print("  ⭐ Tekshirish (dtypes) + int NaN (Int64)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. dtypes (tekshirish) ===
yosh      float64
narx          str
shahar        str

=== 2. narx object (matn — shubha) ===
  narx yangi tur: int64

=== 3. int NaN bilan (xato) ===
  yosh NaN bor → astype(int) xato
  Int64 (NaN saqlaydi): [25, 30, <NA>, 45]

=== 4. Yakuniy turlar ===
yosh      Int64
narx      int64
shahar      str
  ⭐ Tekshirish (dtypes) + int NaN (Int64)

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

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

6. Keng tarqalgan xatolar va yechimlari

1. astype aralash matn

df["x"].astype(int)   # "-", "abc" → xato                         # ⚠️
pd.to_numeric(df["x"], errors="coerce")   # xato → NaN            # ✅

2. Tozalamay

pd.to_numeric(df["narx"])   # "1,500" → NaN                       # ⚠️
df["narx"].str.replace(",", "")   # avval tozala                 # ✅

3. Format yo'q (sana)

pd.to_datetime(df["sana"])   # "01/02/2024" noaniq                # ⚠️
pd.to_datetime(df["sana"], format="%d/%m/%Y")   # aniq           # ✅

4. Coerce yashirin NaN

pd.to_numeric(df["x"], errors="coerce")   # necha NaN?            # ⚠️
df["x"].isna().sum()   # keyin tekshir                            # ✅

5. int NaN bilan

df["yosh"].astype(int)   # NaN → xato                             # ⚠️
df["yosh"].astype("Int64")   # nullable (NaN saqlaydi)           # ✅

6. Kategoriya noyob

df["email"].astype("category")   # noyob (xotira ko'proq)         # ⚠️
df["shahar"].astype("category")   # takrorlanuvchi               # ✅

7. Bool matn

df["faol"].astype(bool)   # "False" → True! (bo'sh emas)          # ⚠️
df["faol"] = df["faol"] == "True"   # to'g'ri                    # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 3.3-dars (o'tilgan): CSV o'qish (tur taxmin)
• 3.12-dars (o'tilgan): Datetime (vaqt amallari)
• 6.1-dars (o'tilgan): NaN (coerce)
• 6.9-dars: Kategoriya kodlash
• 6.11-dars: Tozalash quvuri

8. Eng yaxshi amaliyotlar

1. Tekshir — df.dtypes (birinchi).

2. Matn → son — to_numeric (coerce).

3. Tozala — replace (vergul, valyuta).

4. Matn → sana — to_datetime (format).

5. Coerce — keyin NaN tekshir.

6. int NaN bilan — Int64.

7. Kategoriya — takrorlanuvchi (xotira).

8. Bool matn — == "True" (astype emas).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # tur o'zgartirish nima?
2.  # astype nima?
3.  # to_numeric nima?
4.  # to_datetime nima?
5.  # coerce nima?
6.  # dtypes nima?
7.  # kategoriya turi?
8.  # tozalash nega?
9.  # format nega (sana)?
10. # int NaN bilan?
11. # bool matn?
12. # nega tur muhim?

Vazifa 2: Xatolarni tuzating

1.  df["x"].astype(int)   # "-", "abc"

2.  pd.to_numeric(df["narx"])   # "1,500"

3.  pd.to_datetime(df["sana"])   # 01/02

4.  df["yosh"].astype(int)   # NaN

5.  df["faol"].astype(bool)   # "False"

1.  to_numeric(errors="coerce")

2.  str.replace(",", "") avval

3.  format="%d/%m/%Y"

4.  astype("Int64")

5.  df["faol"] == "True"

Vazifa 3: Matn → son

Modellang:

1. astype
2. to_numeric
3. Tozalash
4. coerce

Vazifa 4: Matn → sana

Modellang:

1. to_datetime
2. format
3. .dt amallari
4. Vaqt

Vazifa 5: Kategoriya va tekshirish

Modellang:

1. astype("category")
2. Xotira
3. dtypes
4. Int64

Vazifa 6: Integratsiya

Modellang:

1. CSV (3.3)
2. Datetime (3.12)
3. NaN (6.1)
4. Quvur (6.11)

Vazifa 7: O'ylash

Tur o'zgartirish oddiy ko'rinadi (astype), lekin real ma'lumotda ko'p tuzoq bor: aralash matn, vergul, noaniq sana format, int NaN bilan. errors="coerce" xatoni NaN ga aylantiradi — bu qulay, lekin xavfli (jimda ma'lumot yo'qoladi). Nima uchun "coerce jim yo'qotadi" muammosi tur o'zgartirishda ehtiyotkorlikni talab qiladi, va Data Scientist buni qanday nazorat qiladi?

Nimani mustahkamlaydi: 2.3, 2.7-bo'limlar.

Xulosa

Bu darsda tur o'zgartirishni o'rgandik.

Eng muhim uch fikr:

1. Matn → son va sana. Matn → son — pd.to_numeric(df["x"], errors="coerce") (xato → NaN) yoki astype(int/float) (toza); avval tozala (str.replace(",", "") vergul, valyuta, bo'shliq). Matn → sana — pd.to_datetime(df["sana"], format="%Y-%m-%d") (format aniq — noaniqlik yo'q); keyin vaqt amallari (.dt.year, .dt.month — 3.12).

2. Kategoriya va tekshirish. object → kategoriya — astype("category") (takrorlanuvchi matn — shahar, jins; xotira tejaydi; noyob — email — foydasiz). Tekshirish — df.dtypes/df.info() (birinchi qadam — nima noto'g'ri; object — son/sana matnmi shubha). int NaN bilan — astype("Int64") (nullable; astype(int) NaN'da xato).

3. To'g'ri turga keltirish. Ma'lumot noto'g'ri turda (CSV taxmin — 3.3; iflos) → to'g'ri tur (hisob — son; vaqt amallari — sana; xotira — kategoriya). errors="coerce" qulay (xato → NaN — davom) lekin jim yo'qotadi (nazorat — oldin-keyin isna().sum(); sabab ko'r; tozala avval). Tuzoqlar: astype aralash (to_numeric coerce), tozalamay (replace), format yo'q (noaniq sana), coerce yashirin NaN (tekshir), int NaN (Int64), kategoriya noyob (foydasiz), bool matn ("False" → True; == "True").

Keyingi darsda normalizatsiya (normalization)ni o'rganamiz: turli masshtabdagi ustunlarni bir masshtabga keltirish (yosh 0-100, daromad 0-100000 — model uchun; Min-Max 0-1); masofaga asoslangan modellar (KNN, ML — 20-qism) uchun shart.