3.6-dars: Ustunlar bilan ishlash

3-QISM — PANDAS · 6-dars

1. Kirish va motivatsiya

Ma'lumotni o'qib, tanlab, filtrladik. Endi uni o'zgartirish kerak: yangi ustun qo'shish (hisoblangan qiymat — masalan summa = narx × miqdor), keraksiz ustunni o'chirish, ustun nomini tuzatish (bo'sh joy, katta harf), ustun turini o'zgartirish (matn → son), va har elementga funksiya qo'llash (apply). Bu — ustunlar bilan ishlash — ma'lumotni tayyorlash va boyitishning asosiy amallari. Real ma'lumot hech qachon to'g'ri ko'rinishda kelmaydi: ustun nomlari chalkash, turlar noto'g'ri, kerakli xususiyatlar hisoblanmagan. Nega muhim? (1) Ma'lumot muhandisligi — yangi xususiyatlar yaratish (ML uchun); (2) Tozalash — nom/tur tuzatish (6-qism); (3) Boyitish — mavjud ustunlardan yangi ma'no. Bu dars ustunlar bilan ishlashni o'rgatadi — ma'lumotni tayyorlash va boyitish.

Ustunlar bilan ishlash — ustun boshqarish: qo'shish (df["yangi"] = ... — hisoblangan), o'chirish (drop — ustun/qator), nom o'zgartirish (rename — ustun nomi), tur o'zgartirish (astype — matn→son), apply (har elementga funksiya), map (Series — qiymat almashtirish), vektorlashtirilgan (ustun amallari — 3.1). Foydalanish: yangi xususiyat, tozalash, boyitish. Bu 3.2 (DataFrame), 6-qism (tozalash) bilan bog'liq. Ustun — qo'shish/o'chirish/nom/tur. apply. Boyitish.

Real vaziyat. Data Scientist savdo DataFrame'i bilan ishlar edi (narx, miqdor ustunlari). Yangi ustun — df["summa"] = df["narx"] * df["miqdor"] (hisoblangan — vektorlashtirilgan); keraksiz o'chirish — df.drop(columns=["izoh"]); nom tuzatish — df.rename(columns={"narx ": "narx"}) (bo'sh joy); tur — df["narx"] = df["narx"].astype(float) (matn → son); apply — df["kategoriya"] = df["summa"].apply(lambda x: "katta" if x > 1000 else "kichik") (har elementga funksiya). Ustunlar bilan ishlash ma'lumotni tayyorladi va boyitdi (yangi xususiyat, toza nom/tur). Ustun — ma'lumot muhandisligi asosi (ML, tahlil uchun).

Bu darsda ustunlar bilan ishlashni o'rganamiz.

Bu darsda:

• Ustun qo'shish (hisoblangan)
• O'chirish (drop)
• Nom o'zgartirish (rename)
• Tur o'zgartirish (astype)
• apply va map
• Ustun amaliyoti
• Ustun tuzoqlari
• Amaliy: ustun modeli

ℹ Misollar real pandas bilan (deterministik) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. Ustun qo'shish (hisoblangan)

Yangi ustun:

import pandas as pd

df = pd.DataFrame({"narx": [100, 200], "miqdor": [3, 5]})

# HISOBLANGAN ustun (vektorlashtirilgan)
df["summa"] = df["narx"] * df["miqdor"]     # [300, 1000]
df["arzon"] = df["narx"] < 150               # bool ustun
df["soliq"] = df["summa"] * 0.12             # foiz

# DOIMIY qiymat
df["valyuta"] = "UZS"                        # hamma qatorga

Ustun qo'shish (hisoblangan) — yangi ustun: df["summa"] = df["narx"] * df["miqdor"] (hisoblangan — vektorlashtirilgan, ustunlar ustida 3.1), df["arzon"] = df["narx"] < 150 (bool ustun), df["valyuta"] = "UZS" (doimiy — hamma qatorga). Sabab: ma'lumotni boyitish (mavjud ustunlardan yangi ma'no — summa, foiz; ML xususiyat); yangi ustun oson (df["yangi"] = ifoda). Vektorlashtirilgan (ustunlar — siklsiz, tez); doimiy (bir qiymat — hamma qatorga). Ustun qo'shish — df["yangi"] = ifoda (hisoblangan). Vektorlashtirilgan. Boyitish.

2.2. O'chirish (drop)

Ustun/qator o'chirish:

df = pd.DataFrame({"a": [1, 2], "b": [3, 4], "c": [5, 6]})

# USTUN o'chirish (columns)
df.drop(columns=["b"])              # b ustunsiz (yangi)
df.drop(columns=["a", "c"])         # bir nechta

# QATOR o'chirish (index)
df.drop(index=[0])                  # 0-qator o'chirildi

# JOYIDA (inplace) yoki yangi
df = df.drop(columns=["b"])         # natijani saqlash

O'chirish (drop) — ustun/qator: df.drop(columns=["b"]) (ustun o'chirish — columns=), df.drop(index=[0]) (qator — index=). Sabab: keraksiz ustun/qator (izoh, takror, xato qatorlar — tozalash); drop olib tashlaydi. columns= (ustun), index= (qator) — aniq. Yangi DataFrame qaytaradi (asl saqlanadi — df = df.drop(...) natija saqlash, yoki inplace=True). O'chirish — drop(columns=) ustun, drop(index=) qator. Yangi. Keraksiz.

2.3. Nom o'zgartirish (rename)

Ustun/indeks nomi:

df = pd.DataFrame({"narx ": [100], "Miqdor": [5]})

# rename — dict {eski: yangi}
df.rename(columns={"narx ": "narx", "Miqdor": "miqdor"})

# hamma ustunni bir xil funksiya bilan
df.columns = df.columns.str.strip().str.lower()   # bo'sh joy, kichik

# indeks nomi ham
df.rename(index={0: "birinchi"})

Nom o'zgartirish (rename) — ustun/indeks nomi: df.rename(columns={"eski": "yangi"}) (dict — eski: yangi), df.columns = df.columns.str.strip().str.lower() (hamma ustun — bo'sh joy olib tashlash, kichik harf). Sabab: real ma'lumot nomlari chalkash (bo'sh joy "narx ", katta harf "Narx", uzun nom — noqulay); rename tuzatadi (dict — aniq; yoki .str — hamma). Toza nom muhim (kirish oson — df["narx"]; bo'sh joy — df["narx "] xato). Nom o'zgartirish — rename(columns={}) dict, .str hamma. Toza nom. Tuzatish.

2.4. Tur o'zgartirish (astype)

Ustun turi:

df = pd.DataFrame({"narx": ["100", "200"], "yosh": [25.0, 30.0]})

# astype — tur o'zgartirish (NumPy 2.3 kabi)
df["narx"] = df["narx"].astype(int)        # matn → son
df["yosh"] = df["yosh"].astype(int)        # float → int

# kategoriya (xotira tejash)
df["shahar"] = df["shahar"].astype("category")

# to_numeric (xatoni boshqarish)
pd.to_numeric(df["narx"], errors="coerce")  # xato → NaN

Tur o'zgartirish (astype) — ustun turi: df["narx"].astype(int) (matn → son — NumPy 2.3 kabi), astype(float), astype("category") (kategoriya — xotira tejash, takrorlanuvchi matn). Sabab: real ma'lumot noto'g'ri tur (CSV — son matn "100"; matematik amal xato); astype tuzatadi (matn → son). pd.to_numeric(errors="coerce") — xato qiymatni NaN qiladi ("abc" → NaN; astype xato beradi). category (takrorlanuvchi matn — xotira). Tur o'zgartirish — astype (matn→son), to_numeric (xato→NaN). Tuzatish. Tozalash.

2.5. apply va map

Har elementga funksiya:

df = pd.DataFrame({"summa": [500, 1500, 800]})

# apply — har elementga funksiya (Series)
df["kat"] = df["summa"].apply(lambda x: "katta" if x > 1000 else "kichik")

# map — qiymat almashtirish (dict)
holat = {"katta": "VIP", "kichik": "oddiy"}
df["daraja"] = df["kat"].map(holat)

# apply DataFrame (qator/ustun bo'yicha)
df.apply(lambda ustun: ustun.max())   # har ustun max

apply va map — funksiya qo'llash: apply (Series — har elementga funksiya; df["summa"].apply(lambda x: ...) — murakkab mantiq), map (Series — qiymat almashtirish; dict bilan {"eski": "yangi"}). Sabab: ba'zan vektorlashtirib bo'lmaydi (murakkab shart, o'z funksiya — apply); qiymat almashtirish (kategoriya → kod, dict — map). apply (funksiya — moslashuvchan, lekin sekinroq — sikl kabi), map (dict/funksiya — Series). Iloji bo'lsa vektorlashtir (apply sekinroq — 2.12). apply/map — funksiya (apply), almashtirish (map). Moslashuvchan. Sekinroq.

2.6. Ustun amaliyoti

Ustun amaliyoti: qo'shish (df["yangi"] = ifoda — vektorlashtirilgan); o'chirish (drop(columns=)); nom (rename(columns={}), .str.strip().str.lower()); tur (astype, to_numeric); apply (murakkab funksiya), map (dict almashtirish); vektorlashtir (iloji bo'lsa — apply emas, 2.12); natija saqlash (df = df.drop(...) yoki inplace). Tuzoqlar: apply sekin (vektorlashtir), drop natija (saqla yoki inplace), nom bo'sh joy (.str.strip), tur (matn son — to_numeric xato), SettingWithCopy (.loc). Amaliyot — qo'shish, o'chirish, nom, tur, apply. Boyitish. Tozalash.

2.7. Ustun tuzoqlari

Ustun asosiy tuzoqlari: apply sekin (apply — Python sikl kabi (har element funksiya); vektorlashtirib bo'lsa df["a"] * 2 tez; apply faqat murakkab mantiq — 2.12); drop natija (df.drop(columns=["b"]) — yangi DataFrame, asl o'zgarmaydi; df = df.drop(...) yoki inplace=True); nom bo'sh joy ("narx " — ko'rinmas bo'sh joy, df["narx"] xato; .str.strip()); tur astype xato ("abc".astype(int) — xato; to_numeric(errors="coerce") — NaN); SettingWithCopy (df[shart]["ustun"] = ... — ogohlantirish; .loc — 3.4); map yo'q qiymat (map — dict da yo'q kalit → NaN; ehtiyot); ustun tartibi (df[["b", "a"]] — tartib o'zgartirish; yangi ustun oxirga qo'shiladi); zanjir o'zgartirish (df.drop().rename() — zanjir; yoki alohida). Sabab: ustun funksiya/tur/nom nozik (apply sekin, drop natija, nom bo'sh joy — jim xato yoki sekin). Yechim: vektorlashtir, natija saqla, .str.strip, to_numeric. Tuzoqlar — apply sekin, drop natija, nom, tur.

2.8. Ustunlar — ma'lumotni tayyorlash va boyitish

Ustunlar bilan ishlash asosiy g'oyasi — ma'lumotni tayyorlash va boyitish: real ma'lumot to'g'ri ko'rinishda kelmaydi (nom chalkash, tur noto'g'ri, xususiyat hisoblanmagan); ustunlar bilan ishlash ma'lumotni tuzatadi va boyitadi (yangi ustun — boyitish; nom/tur — tozalash). Qo'shish (df["yangi"] = ifoda — hisoblangan, vektorlashtirilgan), o'chirish (drop — keraksiz), nom (rename — chalkash tuzatish), tur (astype/to_numeric — matn→son), apply/map (murakkab funksiya/almashtirish). Bu ma'lumot muhandisligi (feature engineering — yangi xususiyat ML uchun; 20-qism) va tozalash (6-qism) asosi. Data Science'da doim (real ma'lumot — tayyorlash; yangi xususiyat — model). Bu 3.2 (DataFrame) davomi va 6-qism (tozalash), 20-qism (ML — xususiyat) uchun. Ustunlar — ma'lumotni tayyorlash va boyitish (qo'shish/o'chirish/nom/tur/apply). Muhandislik. Tozalash.

3. Tez ma'lumotnoma

import pandas as pd

# QO'SHISH (hisoblangan, vektorlashtirilgan):
df["summa"] = df["narx"] * df["miqdor"]
df["arzon"] = df["narx"] < 150       # bool ustun
df["valyuta"] = "UZS"                 # doimiy

# O'CHIRISH (yangi DataFrame):
df.drop(columns=["b"])               # ustun
df.drop(index=[0])                   # qator
df = df.drop(columns=["b"])          # natijani saqla

# NOM O'ZGARTIRISH:
df.rename(columns={"eski": "yangi"})
df.columns = df.columns.str.strip().str.lower()

# TUR O'ZGARTIRISH:
df["narx"] = df["narx"].astype(int)          # matn → son
pd.to_numeric(df["narx"], errors="coerce")   # xato → NaN

# apply / map:
df["kat"] = df["summa"].apply(lambda x: "katta" if x>1000 else "kichik")
df["kod"] = df["kat"].map({"katta": 1, "kichik": 0})

QOIDA: vektorlashtir (apply emas) · drop natijani saqla · .str.strip nom · to_numeric xato

Ustun xulosasi

Ustunlar — ma'lumotni tayyorlash va boyitish
Qo'shish — df["yangi"] = ifoda (hisoblangan, vektorlashtirilgan)
O'chirish — drop(columns=/index=) (yangi DataFrame)
Nom — rename(columns={}) · .str.strip().str.lower()
Tur — astype (matn→son) · to_numeric (xato→NaN)
apply/map — funksiya/almashtirish (sekinroq, vektorlashtir afzal)

4. Batafsil misollar

Misollar real pandas bilan (deterministik) ishlaydi.

Misol 1 — Ustun qo'shish

"""Ustun qo'shish (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "narx": [100, 200, 150],
        "miqdor": [3, 5, 2],
    })

    print("=== 1. Hisoblangan ustun ===")
    df["summa"] = df["narx"] * df["miqdor"]
    print(f"  summa: {list(df['summa'])}")

    print("\n=== 2. Bool ustun ===")
    df["arzon"] = df["narx"] < 150
    print(f"  arzon: {list(df['arzon'])}")

    print("\n=== 3. Foiz ===")
    df["soliq"] = (df["summa"] * 0.12).round(1)
    print(f"  soliq: {list(df['soliq'])}")

    print("\n=== 4. Doimiy ===")
    df["valyuta"] = "UZS"
    print(f"  valyuta: {list(df['valyuta'])}")
    print("  ⭐ Ustun qo'shish — hisoblangan (vektorlashtirilgan)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Hisoblangan ustun ===
  summa: [300, 1000, 300]

=== 2. Bool ustun ===
  arzon: [True, False, False]

=== 3. Foiz ===
  soliq: [36.0, 120.0, 36.0]

=== 4. Doimiy ===
  valyuta: ['UZS', 'UZS', 'UZS']
  ⭐ Ustun qo'shish — hisoblangan (vektorlashtirilgan)

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — O'chirish va nom

"""O'chirish va nom (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "narx ": [100, 200],
        "Miqdor": [3, 5],
        "izoh": ["a", "b"],
    })

    print("=== 1. Nom tuzatish (strip, lower) ===")
    df.columns = df.columns.str.strip().str.lower()
    print(f"  ustunlar: {list(df.columns)}")

    print("\n=== 2. Ustun o'chirish ===")
    df2 = df.drop(columns=["izoh"])
    print(f"  izohsiz: {list(df2.columns)}")

    print("\n=== 3. rename (aniq) ===")
    df3 = df.rename(columns={"miqdor": "soni"})
    print(f"  rename: {list(df3.columns)}")

    print("\n=== 4. Qator o'chirish ===")
    df4 = df.drop(index=[0])
    print(f"  qatorlar soni: {len(df4)}")
    print("  ⭐ O'chirish (drop) va nom (rename/.str)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Nom tuzatish (strip, lower) ===
  ustunlar: ['narx', 'miqdor', 'izoh']

=== 2. Ustun o'chirish ===
  izohsiz: ['narx', 'miqdor']

=== 3. rename (aniq) ===
  rename: ['narx', 'soni', 'izoh']

=== 4. Qator o'chirish ===
  qatorlar soni: 1
  ⭐ O'chirish (drop) va nom (rename/.str)

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

Misol 3 — Tur o'zgartirish

"""Tur o'zgartirish (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "narx": ["100", "200", "150"],
        "yosh": [25.0, 30.0, 28.0],
    })

    print("=== 1. Boshlang'ich turlar ===")
    print(f"  narx: {df['narx'].dtype}, yosh: {df['yosh'].dtype}")

    print("\n=== 2. Matn → son ===")
    df["narx"] = df["narx"].astype(int)
    print(f"  narx endi: {df['narx'].dtype}, yig'indi: {df['narx'].sum()}")

    print("\n=== 3. Float → int ===")
    df["yosh"] = df["yosh"].astype(int)
    print(f"  yosh: {list(df['yosh'])}")

    print("\n=== 4. to_numeric (xato → NaN) ===")
    aralash = pd.Series(["10", "abc", "30"])
    natija = pd.to_numeric(aralash, errors="coerce")
    print(f"  xato → NaN: {natija.isna().sum()} ta NaN")
    print("  ⭐ Tur o'zgartirish — astype, to_numeric")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Boshlang'ich turlar ===
  narx: str, yosh: float64

=== 2. Matn → son ===
  narx endi: int64, yig'indi: 450

=== 3. Float → int ===
  yosh: [25, 30, 28]

=== 4. to_numeric (xato → NaN) ===
  xato → NaN: 1 ta NaN
  ⭐ Tur o'zgartirish — astype, to_numeric

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — apply va map

"""apply va map (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({"summa": [500, 1500, 800, 2000]})

    print("=== 1. apply (funksiya) ===")
    df["kat"] = df["summa"].apply(lambda x: "katta" if x > 1000 else "kichik")
    print(f"  kategoriya: {list(df['kat'])}")

    print("\n=== 2. map (dict almashtirish) ===")
    df["kod"] = df["kat"].map({"katta": 1, "kichik": 0})
    print(f"  kod: {list(df['kod'])}")

    print("\n=== 3. apply (matematik) ===")
    df["bonus"] = df["summa"].apply(lambda x: x * 0.1)
    print(f"  bonus: {list(df['bonus'])}")

    print("\n=== 4. Vektorlashtirilgan (afzal) ===")
    df["bonus2"] = df["summa"] * 0.1
    print(f"  bir xil (tezroq): {list(df['bonus2']) == list(df['bonus'])}")
    print("  ⭐ apply (funksiya), map (almashtirish)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. apply (funksiya) ===
  kategoriya: ['kichik', 'katta', 'kichik', 'katta']

=== 2. map (dict almashtirish) ===
  kod: [0, 1, 0, 1]

=== 3. apply (matematik) ===
  bonus: [50.0, 150.0, 80.0, 200.0]

=== 4. Vektorlashtirilgan (afzal) ===
  bir xil (tezroq): True
  ⭐ apply (funksiya), map (almashtirish)

Nima ko'rsatdi: 2.5-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. apply sekin

df["a2"] = df["a"].apply(lambda x: x * 2)   # sekin          # ⚠️
df["a2"] = df["a"] * 2   # vektorlashtir (tez)                # ✅

2. drop natijasi

df.drop(columns=["b"])   # asl o'zgarmaydi                    # ⚠️
df = df.drop(columns=["b"])   # natijani saqla                # ✅

3. Nom bo'sh joy

df["narx"]   # "narx " (bo'sh joy) — xato                    # ⚠️
df.columns = df.columns.str.strip()   # tozalash              # ✅

4. astype xato

df["a"].astype(int)   # "abc" bo'lsa xato                     # ⚠️
pd.to_numeric(df["a"], errors="coerce")   # xato → NaN        # ✅

5. map yo'q qiymat

df["k"].map({"a": 1})   # "b" bo'lsa → NaN                    # ⚠️
df["k"].map({"a": 1, "b": 2})   # to'liq dict                 # ✅

6. SettingWithCopy

df[df.a > 1]["b"] = 0   # ogohlantirish                       # ⚠️
df.loc[df.a > 1, "b"] = 0   # .loc                            # ✅

7. apply DataFrame axis

df.apply(func)   # ustun bo'yicha (axis=0)                    # ⚠️
df.apply(func, axis=1)   # qator bo'yicha                      # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 3.2-dars (o'tilgan): DataFrame (ustun)
• 3.7-dars: Yo'q qiymatlar (tur, NaN)
• 6-qism: Tozalash (nom, tur, apply)
• 20-qism: ML (feature engineering — yangi ustun)
• 4-qism: Statistika (hisoblangan ustunlar)

8. Eng yaxshi amaliyotlar

1. Yangi ustun — df["yangi"] = ifoda (vektorlashtirilgan).

2. drop — natijani saqla (yangi DataFrame).

3. Nom — .str.strip().str.lower() (toza).

4. Tur — astype, xato bo'lsa to_numeric.

5. apply — faqat murakkab (vektorlashtir afzal).

6. map — to'liq dict (yo'q → NaN).

7. .loc bilan o'zgartir (SettingWithCopy).

8. Ustunlar — tayyorlash va boyitish.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # yangi ustun qanday?
2.  # hisoblangan ustun?
3.  # drop nima?
4.  # drop asl o'zgartiradimi?
5.  # rename nima?
6.  # nom bo'sh joy?
7.  # astype nima?
8.  # to_numeric nima uchun?
9.  # apply nima?
10. # apply tez yoki sekin?
11. # map nima?
12. # nega ustun ishi muhim?

Vazifa 2: Xatolarni tuzating

1.  df["a"].apply(lambda x: x*2)   # tez kerak

2.  df.drop(columns=["b"])   # asl o'zgarmaydi

3.  df["narx "]   # bo'sh joy

4.  df["a"].astype(int)   # "abc" bor

5.  df[df.a>1]["b"] = 0   # o'zgartirish

1.  df["a"] * 2   # vektorlashtir

2.  df = df.drop(columns=["b"])

3.  df.columns.str.strip()

4.  pd.to_numeric(df["a"], errors="coerce")

5.  df.loc[df.a>1, "b"] = 0

Vazifa 3: Qo'shish

Modellang:

1. Hisoblangan
2. Bool
3. Doimiy
4. Vektorlashtirilgan

Vazifa 4: O'chirish/nom

Modellang:

1. drop
2. columns/index
3. rename
4. .str

Vazifa 5: Tur

Modellang:

1. astype
2. matn→son
3. to_numeric
4. category

Vazifa 6: apply/map

Modellang:

1. apply
2. map
3. Funksiya
4. Sekin

Vazifa 7: O'ylash

Pandas'da yangi ustun yaratishning ikki yo'li bor: vektorlashtirilgan (df["a"] = df["b"] * 2) va apply (df["a"] = df["b"].apply(lambda x: x*2)). Ikkalasi bir xil natija beradi, lekin vektorlashtirilgan ancha tez. Nima uchun apply sekin (NumPy siklga o'xshab), va nega u baribir mavjud/kerak — qachon apply haqiqatan kerak bo'ladi?

Nimani mustahkamlaydi: 2.5, 2.7-bo'limlar.

Xulosa

Bu darsda ustunlar bilan ishlashni o'rgandik.

Eng muhim uch fikr:

1. Qo'shish va o'chirish. Ustun qo'shish — df["summa"] = df["narx"] * df["miqdor"] (hisoblangan — vektorlashtirilgan, ustunlar ustida), bool ustun (df["narx"] < 150), doimiy (df["valyuta"] = "UZS"). O'chirish — df.drop(columns=["b"]) (ustun), df.drop(index=[0]) (qator); yangi DataFrame (natija saqla — df = df.drop(...) yoki inplace).

2. Nom va tur. Nom o'zgartirish — df.rename(columns={"eski": "yangi"}) (dict), df.columns = df.columns.str.strip().str.lower() (hamma — bo'sh joy/registr; chalkash nom tuzatish). Tur o'zgartirish — df["narx"].astype(int) (matn → son — NumPy 2.3), pd.to_numeric(errors="coerce") (xato → NaN), astype("category") (xotira).

3. apply va boyitish. apply/map — apply (Series — har elementga funksiya, murakkab mantiq; sekin — Python sikl kabi, vektorlashtir afzal), map (dict almashtirish — {"eski": "yangi"}). Ustunlar — ma'lumotni tayyorlash va boyitish (nom/tur — tozalash; yangi ustun — boyitish, feature engineering); ma'lumot muhandisligi (ML — 20-qism) va tozalash (6-qism) asosi. apply sekin (Python funksiya), lekin murakkab mantiq/matn/tashqi funksiya uchun kerak (iloji bo'lsa vektorlashtir — 2.12). Tuzoqlar: apply sekin, drop natija, nom bo'sh joy, astype xato (to_numeric), SettingWithCopy (.loc).

Keyingi darsda yo'q qiymatlar (NaN)ni o'rganamiz: real ma'lumotning eng katta muammosi — yo'q qiymatlarni topish (isna), o'chirish (dropna), to'ldirish (fillna).