6.7-dars: Matn tozalash

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

1. Kirish va motivatsiya

Matn ma'lumot eng iflos turlardan biri: " Ali " (bo'shliq), "ALI" va "ali" (katta-kichik harf), "Toshkent" va "toshkent " va "TOSHKENT" (bir shahar, uch ko'rinish), "+998 90 123-45-67" (telefon — turli format), "salom!!!" (ortiqcha belgi). Bu muammo: kompyuter "Ali" va "ali " ni turli deb biladi — guruhlaganda ikki guruh, dublikat topilmaydi 6.2-bob, birlashtirishda mos kelmaydi 3.9-bob. Matn tozalash (string cleaning) — matnni normal ko'rinishga keltirish: bo'shliqni olib tashlash (strip), bir registrga (lower/upper), belgilarni almashtirish (replace), namunani topish/o'zgartirish (regex). Bu darsda pandas .str metodlari va regex asoslari. Nega muhim? (1) Bir xillik — "Ali" = "ali " (guruh, dublikat); (2) Moslik — birlashtirish 3.9-bob, qidirish; (3) Format — telefon, email (standart). Bu dars matn tozalashni o'rgatadi — normal ko'rinishga keltirish.

Matn tozalash (string cleaning) — normal ko'rinishga: bo'shliq (str.strip() — bosh/oxir; str.replace(" ", "")), registr (str.lower()/str.upper() — bir xil), almashtirish (str.replace("eski", "yangi")), regex (str.replace(pat.., regex=True) — namuna; raqam, belgi), ajratish (str.split, str.extract), tekshirish (str.contains). Foydalanish: bir xillik (guruh/dublikat), moslik (birlashtirish), format (telefon/email). Bu 6.2 (dublikat — normallashtirish), 3.9 (merge), 3.6 (ustun bilan ishlash) bilan bog'liq. Matn tozalash — normal ko'rinishga. Matn. Bir xil.

Real vaziyat. Data Scientist ikki manbadan mijoz ma'lumotini birlashtirmoqchi (3.9 — merge; kalit: shahar). Iflos matn: 1-manba "Toshkent", 2-manba "toshkent " (kichik harf + bo'shliq), "TOSHKENT". Muammo: merge — "Toshkent" != "toshkent " (mos kelmaydi; birlashmaydi). Hal: ikki manbani normallashtir (str.strip().str.lower() — "toshkent"); endi mos keladi (merge ishlaydi). Data Scientist tozaladi (strip + lower), normallashtirdi (bir xil), birlashtirdi (merge). Matn tozalash — normal ko'rinishga.

Bu darsda matn tozalashni o'rganamiz.

Bu darsda:

• Bo'shliq va registr (strip, lower)
• Almashtirish (replace)
• Regex (namuna)
• Ajratish va tekshirish (split, contains)
• Matn normallashtirish (bir xillik)
• Matn tozalash amaliyoti
• Matn tozalash tuzoqlari
• Amaliy: matn tozalash

ℹ Misollar real pandas bilan (Python 3.14) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. Bo'shliq va registr (strip, lower)

Eng ko'p ishlatiladigan:

import pandas as pd

# strip — bosh/oxirdagi bo'shliqni olib tashlash
df["ism"] = df["ism"].str.strip()      # " Ali " → "Ali"

# lower/upper — bir registrga
df["ism"] = df["ism"].str.lower()      # "ALI" → "ali"
df["shahar"] = df["shahar"].str.upper()

# ikkalasi (zanjir)
df["ism"] = df["ism"].str.strip().str.lower()

Bo'shliq va registr (strip, lower) — eng ko'p: str.strip() (bosh/oxir bo'shliq — " Ali " → "Ali"; str.lstrip/rstrip — bir tomon), str.lower()/str.upper() (bir registr — "ALI" → "ali"); zanjir (str.strip().str.lower() — birga). Sabab: ko'rinmas bo'shliq (" Ali " — ko'z ko'rmaydi, lekin != "Ali"), registr ("ALI" != "ali" — kompyuter turli); tozalash → bir xil (guruh, dublikat, merge). strip (bo'shliq), lower (registr), .str (matn metodlari — har element). Bo'shliq va registr — strip/lower (bir xil). Strip. Lower.

2.2. Almashtirish (replace)

Belgilarni o'zgartirish:

import pandas as pd

# str.replace — belgi/matnni almashtirish
df["narx"] = df["narx"].str.replace(",", "")      # "1,500" → "1500"
df["tel"] = df["tel"].str.replace("-", "")        # "90-123" → "90123"

# bo'shliqni olib tashlash (butun matnda)
df["kod"] = df["kod"].str.replace(" ", "")

# bir nechta (zanjir)
df["x"] = df["x"].str.replace("$", "").str.replace(",", "")

Almashtirish (replace) — belgi o'zgartirish: str.replace("eski", "yangi") (belgi/matn almashtir — "1,500" → "1500" vergul; "90-123" → "90123" tire); butun matnda (str.replace(" ", "") — barcha bo'shliq; strip — faqat chekka); zanjir (bir necha replace). Sabab: ortiqcha belgi (vergul, valyuta, tire — son/format uchun olib tashla; 6.4 tur o'zgartirish oldin), standart format (telefon — tire/bo'shliq olib tashla). replace (belgi — eski→yangi), butun matn (strip — chekka), zanjir (ko'p belgi). Almashtirish — replace (belgi; format). Replace. Belgi.

2.3. Regex (namuna)

Regex (namuna — regular expression) — kuchli qidirish/almashtirish: str.replace(pattern, yangi, regex=True) (namuna bilan — r"\d+" raqamlar, r"[^\w\s]" maxsus belgi); str.extract(r"(\d+)") (namuna ajratish — telefondan raqam); str.contains(r"pattern") (namuna bormi). Sabab: aniq belgi emas (namuna — "barcha raqam", "harf bo'lmagan"; oddiy replace yetmaydi); regex — kuchli (murakkab namuna — email, telefon, kod). \d (raqam), \w (harf/raqam), \s (bo'shliq), [^...] (emas), + (bir yoki ko'p), regex=True (regex rejimi). Regex — namuna (raqam, belgi — kuchli). Regex. Namuna.

2.4. Ajratish va tekshirish (split, contains)

Ajratish va tekshirish (split, contains) — bo'lish/qidirish: str.split(",") (matnni bo'lish — "a,b,c" → ["a", "b", "c"]; expand=True — ustunlarga), str.split().str[0] (birinchi qism), str.contains("qism") (bormi? True/False — filtr; 3.5), str.startswith/str.endswith (boshlanadimi/tugaydimi), str.len() (uzunlik). Sabab: tarkibiy matn ("Familiya Ism" — ajrat; "a@b.uz" — email tekshir), filtr (contains — muayyan matn — 3.5). split (bo'lish — ustun/qism), contains (bormi — filtr), len (uzunlik). Ajratish/tekshirish — split/contains (bo'lish/qidirish). Split. Contains.

2.5. Matn normallashtirish (bir xillik)

Matn normallashtirish (bir xillik) — standart ko'rinish: turli ko'rinishni bir xilga ("Toshkent", "toshkent ", "TOSHKENT" → "toshkent"); qadamlar: strip (bo'shliq) → lower (registr) → replace (belgi) → ajrat/tuzat (kerak bo'lsa). Sabab: bir xillik (guruh — bir shahar bir guruh; dublikat — 6.2 topiladi; merge — 3.9 mos keladi); "kanonik shakl" (bir standart — barcha shu ko'rinishda). Strip → lower → replace (zanjir — normallashtirish), bir xil (guruh/dublikat/merge). Matn normallashtirish — bir xillik (strip+lower+replace; kanonik). Normallashtirish. Bir xil.

2.6. Matn tozalash amaliyoti

Matn tozalash amaliyoti: ko'rish (df["x"].unique() — turli ko'rinishlar; muammo); bo'shliq (str.strip() — chekka; str.replace(" ", "") — butun); registr (str.lower() — bir xil); belgi (str.replace — vergul/valyuta/tire); regex (murakkab namuna — raqam, maxsus belgi); normallashtirish (strip+lower+replace — bir xil; guruh/dublikat/merge oldin); tekshir (unique() — bir xil bo'ldimi). Tuzoqlar: NaN str xato (.str NaN'da — ehtiyot), ko'rinmas belgi (\t, \xa0 — strip yetmaydi), regex maxsus belgi (., * — qochirish), lower ma'no (ID — registr muhim), qism almashtirish (replace — qism mos). Amaliyot — ko'rish, tozalash, normallashtirish, tekshir. Matn. Bir xil.

2.7. Matn tozalash tuzoqlari

Matn tozalash asosiy tuzoqlari: NaN bilan .str (.str metodi NaN'da — NaN qaytaradi (xato emas, lekin natija NaN); yoki .str.strip() NaN'ni o'tkazib yuboradi; NaN hal 6.1 oldin yoki na= parametr); ko'rinmas belgi (str.strip() — oddiy bo'shliq ( ); lekin \t (tab), \xa0 (non-breaking space — HTML), \n — strip olib tashlamaydi (yoki strip() ba'zisini); regex r"\s+" yoki aniq belgi); regex maxsus belgi (., *, +, (, ), [ — regex'da maxsus ma'no; oddiy nuqta kerak — \. qochir; yoki regex=False); lower ma'noni buzadi (str.lower() — matn (shahar, ism) OK; lekin ID/kod ("AB123" — registr muhim; lower — buzadi); kontekst); qism almashtirish (str.replace("a", "b") — barcha "a" (so'z ichida ham; "salom" → "slbom"?; ehtiyot — aniq namuna yoki \b so'z chegarasi)); strip yetmaslik (strip() — faqat chekka; o'rtadagi bo'shliq ("a b") qoladi; replace(" ", "") — butun, lekin so'z orasi ham); registr birlashtirish ("Ali" va "ali" — lower bilan bir; lekin "O'g'li" — apostrof/harf; ehtiyot); inplace/tayinlash (df["x"].str.strip() — yangi; df["x"] = ... tayinla); unicode normallashtirish (bir xil ko'ringan harflar — turli unicode; unicodedata.normalize — chuqur). Sabab: matn tozalash NaN/belgi/registr nozik (NaN, ko'rinmas, regex, ma'no — xato yoki buziladi). Yechim: NaN hal, aniq belgi/regex, kontekst (ID lower emas), tayinla. Tuzoqlar — NaN, ko'rinmas belgi, regex, lower ma'no.

2.8. Matn tozalash — normal ko'rinishga keltirish

Matn tozalash asosiy g'oyasi — normal ko'rinishga keltirish: matn iflos (bo'shliq " Ali ", registr "ALI"/"ali", belgi "salom!!!", format "+998-90...") — kompyuter turli ko'rinishni turli deb biladi ("Ali" != "ali "); normal ko'rinish (bir xil — guruh/dublikat/merge). Bo'shliq/registr (str.strip(), str.lower() — eng ko'p), almashtirish (str.replace — belgi/format), regex (namuna — raqam, maxsus belgi; kuchli), ajratish/tekshirish (str.split, str.contains), normallashtirish (strip+lower+replace — kanonik shakl). Foydalanish: bir xillik ("Ali" = "ali " — guruh, dublikat 6.2), moslik (birlashtirish 3.9, qidirish), format (telefon/email — standart). Tuzoqlar: NaN str (hal oldin), ko'rinmas belgi (\t/\xa0 — regex), regex maxsus belgi (qochir), lower ma'no (ID — registr), qism almashtirish (aniq namuna). Bu 6.2 (dublikat — normallashtirish), 3.9 (merge), 3.6 (ustun), 6.4 (tur — replace oldin) bilan. Matn tozalash — normal ko'rinishga (strip/lower/replace/regex; bir xillik). Matn. Normal. Bir xil.

3. Tez ma'lumotnoma

import pandas as pd

# BO'SHLIQ va REGISTR (eng ko'p):
df["x"] = df["x"].str.strip()             # chekka bo'shliq
df["x"] = df["x"].str.lower()             # bir registr
df["x"] = df["x"].str.strip().str.lower() # zanjir (normallashtirish)

# ALMASHTIRISH (belgi/format):
df["narx"] = df["narx"].str.replace(",", "")   # vergul
df["tel"] = df["tel"].str.replace(" ", "")     # bo'shliq (butun)

# REGEX (namuna):
df["x"] = df["x"].str.replace(r"[^\w\s]", "", regex=True)  # maxsus belgi
df["raqam"] = df["tel"].str.extract(r"(\d+)")              # raqam ajrat
mask = df["email"].str.contains(r"@", na=False)            # bormi (filtr)

# AJRATISH va TEKSHIRISH:
df[["fam", "ism"]] = df["toliq"].str.split(" ", expand=True)
df["x"].str.contains("qism", na=False)   # bormi (NaN → False)

# NORMALLASHTIRISH (bir xillik — guruh/dublikat/merge oldin):
df["shahar"] = df["shahar"].str.strip().str.lower()

QOIDA: NaN hal (na=) · ko'rinmas belgi (regex) · ID lower emas · aniq namuna

Matn tozalash xulosasi

Matn tozalash — normal ko'rinishga (bir xillik: guruh/dublikat/merge)
Bo'shliq/registr — strip/lower (eng ko'p; ko'rinmas farq)
Almashtirish — replace (belgi, format — vergul/tire)
Regex — namuna (raqam, maxsus belgi; kuchli)
Normallashtirish — strip+lower+replace (kanonik; bir xil)

4. Batafsil misollar

Misollar real pandas bilan (Python 3.14) ishlaydi.

Misol 1 — Bo'shliq va registr

"""Bo'shliq va registr (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({"shahar": [" Toshkent", "toshkent ", "TOSHKENT", "Samarqand"]})

    print("=== 1. Iflos (turli ko'rinish) ===")
    print(f"  noyob: {df['shahar'].nunique()} (aslida 2 shahar!)")

    print("\n=== 2. strip (bo'shliq) ===")
    df["shahar"] = df["shahar"].str.strip()
    print(f"  strip: {df['shahar'].tolist()}")

    print("\n=== 3. lower (registr) ===")
    df["shahar"] = df["shahar"].str.lower()
    print(f"  lower: {df['shahar'].tolist()}")

    print("\n=== 4. Endi bir xil ===")
    print(f"  noyob: {df['shahar'].nunique()} (2 shahar — to'g'ri)")
    print("  ⭐ strip + lower — bir xillik")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Iflos (turli ko'rinish) ===
  noyob: 4 (aslida 2 shahar!)

=== 2. strip (bo'shliq) ===
  strip: ['Toshkent', 'toshkent', 'TOSHKENT', 'Samarqand']

=== 3. lower (registr) ===
  lower: ['toshkent', 'toshkent', 'toshkent', 'samarqand']

=== 4. Endi bir xil ===
  noyob: 2 (2 shahar — to'g'ri)
  ⭐ strip + lower — bir xillik

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

Misol 2 — Almashtirish (replace)

"""Almashtirish: replace (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "narx": ["1,200", "1,500", "980"],
        "tel": ["90-123-45-67", "91 234 56 78", "93-345-67-89"],
    })

    print("=== 1. Narx (vergul olib tashlash) ===")
    df["narx_toza"] = df["narx"].str.replace(",", "")
    print(f"  {df['narx_toza'].tolist()}")

    print("\n=== 2. Telefon (tire va bo'shliq) ===")
    df["tel_toza"] = df["tel"].str.replace("-", "").str.replace(" ", "")
    print(f"  {df['tel_toza'].tolist()}")

    print("\n=== 3. Endi songa 6.4-bob ===")
    narx_son = pd.to_numeric(df["narx_toza"])
    print(f"  jami narx: {narx_son.sum()}")

    print("\n=== 4. Standart format ===")
    print("  telefon: faqat raqam (bir xil)")
    print("  ⭐ replace — belgi/format tozalash")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Narx (vergul olib tashlash) ===
  ['1200', '1500', '980']

=== 2. Telefon (tire va bo'shliq) ===
  ['901234567', '912345678', '933456789']

=== 3. Endi songa 6.4-bob ===
  jami narx: 3680

=== 4. Standart format ===
  telefon: faqat raqam (bir xil)
  ⭐ replace — belgi/format tozalash

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — Regex (namuna)

"""Regex: namuna (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "matn": ["salom!!!", "hello???", "test..."],
        "tel": ["Tel: +998901234567", "Aloqa: 998912345678", "yo'q"],
    })

    print("=== 1. Maxsus belgi olib tashlash ===")
    df["toza"] = df["matn"].str.replace(r"[^\w\s]", "", regex=True)
    print(f"  {df['toza'].tolist()}")

    print("\n=== 2. Raqam ajratish (extract) ===")
    df["raqam"] = df["tel"].str.extract(r"(\d+)")
    print(f"  {df['raqam'].tolist()}")

    print("\n=== 3. contains (namuna bormi) ===")
    bor = df["tel"].str.contains(r"\d", na=False)
    print(f"  raqam bor: {bor.tolist()}")

    print("\n=== 4. Regex kuchi ===")
    print(r"  \d — raqam, \w — harf/raqam, [^..] — emas")
    print("  ⭐ Regex — namuna (murakkab)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Maxsus belgi olib tashlash ===
  ['salom', 'hello', 'test']

=== 2. Raqam ajratish (extract) ===
  ['998901234567', '998912345678', nan]

=== 3. contains (namuna bormi) ===
  raqam bor: [True, True, False]

=== 4. Regex kuchi ===
  \d — raqam, \w — harf/raqam, [^..] — emas
  ⭐ Regex — namuna (murakkab)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 4 — Ajratish va NaN

"""Ajratish va NaN str (real pandas)."""

import numpy as np
import pandas as pd


def main() -> None:
    df = pd.DataFrame({"toliq": ["Aliyev Ali", "Valiyev Vali", None]})

    print("=== 1. split (ajratish) ===")
    bolingan = df["toliq"].str.split(" ", expand=True)
    print(f"  familiya: {bolingan[0].tolist()}")

    print("\n=== 2. NaN bilan .str (ehtiyot) ===")
    print(f"  NaN → NaN qaytadi: {df['toliq'].str.upper().tolist()}")

    print("\n=== 3. contains na= (NaN → False) ===")
    bor = df["toliq"].str.contains("Ali", na=False)
    print(f"  'Ali' bor: {bor.tolist()}")

    print("\n=== 4. len (uzunlik) ===")
    uzunlik = df["toliq"].str.len()
    print(f"  uzunlik: {uzunlik.tolist()}")
    print("  ⭐ split/contains + NaN ehtiyot (na=)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. split (ajratish) ===
  familiya: ['Aliyev', 'Valiyev', nan]

=== 2. NaN bilan .str (ehtiyot) ===
  NaN → NaN qaytadi: ['ALIYEV ALI', 'VALIYEV VALI', nan]

=== 3. contains na= (NaN → False) ===
  'Ali' bor: [True, False, False]

=== 4. len (uzunlik) ===
  uzunlik: [10.0, 12.0, nan]
  ⭐ split/contains + NaN ehtiyot (na=)

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

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

6. Keng tarqalgan xatolar va yechimlari

1. Normallashtirmaslik (guruh)

df.groupby("shahar")   # "Toshkent" va "toshkent " — 2 guruh      # ⚠️
df["shahar"] = df["shahar"].str.strip().str.lower()   # avval    # ✅

2. strip o'rtadagi bo'shliq

df["x"].str.strip()   # "a  b" → "a  b" (o'rta qoladi)            # ⚠️
df["x"].str.replace(r"\s+", " ", regex=True)   # bir bo'shliq    # ✅

3. NaN'da .str

df["x"].str.contains("a")   # NaN → NaN (filtr xato)              # ⚠️
df["x"].str.contains("a", na=False)   # NaN → False              # ✅

4. Regex maxsus belgi

df["x"].str.replace(".", "", regex=True)   # . = har belgi!       # ⚠️
df["x"].str.replace(".", "", regex=False)   # aniq nuqta         # ✅

5. lower ID buzadi

df["kod"].str.lower()   # "AB123" → "ab123" (registr muhim)       # ⚠️
# ID/kod — lower qilma (kontekst)                                 # ✅

6. Ko'rinmas belgi

df["x"].str.strip()   # \xa0 (non-breaking space) qoladi          # ⚠️
df["x"].str.replace(r"\s+", " ", regex=True).str.strip()         # ✅

7. Tayinlashni unutish

df["x"].str.strip()   # df o'zgarmaydi                            # ⚠️
df["x"] = df["x"].str.strip()   # tayinla                        # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 6.2-dars (o'tilgan): Dublikat (normallashtirish)
• 3.9-dars (o'tilgan): Merge (moslik)
• 3.6-dars (o'tilgan): Ustun bilan ishlash
• 6.4-dars (o'tilgan): Tur (replace oldin)
• 6.11-dars: Tozalash quvuri

8. Eng yaxshi amaliyotlar

1. strip + lower — normallashtirish.

2. Guruh/merge oldin — normallashtir.

3. replace — belgi/format.

4. Regex — murakkab namuna.

5. NaN — na=False (contains).

6. ID/kod — lower qilma.

7. Ko'rinmas belgi — regex (\s+).

8. Tayinla — df["x"] = ....

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # matn tozalash nima?
2.  # strip nima?
3.  # lower nima?
4.  # replace nima?
5.  # regex nima?
6.  # split nima?
7.  # contains nima?
8.  # normallashtirish?
9.  # NaN'da .str?
10. # lower qachon xato?
11. # strip o'rtadagi?
12. # nega bir xillik?

Vazifa 2: Xatolarni tuzating

1.  df.groupby("shahar")   # "Toshkent" va "toshkent "

2.  df["x"].str.contains("a")   # NaN

3.  df["x"].str.replace(".", "", regex=True)

4.  df["kod"].str.lower()   # "AB123"

5.  df["x"].str.strip()   # o'zgarmaydi

1.  str.strip().str.lower() avval

2.  na=False

3.  regex=False (aniq nuqta)

4.  ID — lower qilma

5.  df["x"] = df["x"].str.strip()

Vazifa 3: Bo'shliq va registr

Modellang:

1. strip
2. lower
3. Zanjir
4. Bir xil

Vazifa 4: Almashtirish

Modellang:

1. replace
2. Belgi
3. Format
4. Regex

Vazifa 5: Normallashtirish

Modellang:

1. strip+lower
2. Kanonik
3. Guruh
4. Merge

Vazifa 6: Integratsiya

Modellang:

1. Dublikat (6.2)
2. Merge (3.9)
3. Tur (6.4)
4. Quvur (6.11)

Vazifa 7: O'ylash

Matn tozalash oddiy ko'rinadi (strip, lower), lekin u boshqa amallar (guruh, dublikat, birlashtirish) uchun oldindan kerak. Agar normallashtirmasangiz, "Toshkent" va "toshkent " ikki alohida guruh bo'ladi — statistika noto'g'ri. Nima uchun matn tozalash "ko'rinmas xato" manbai, va nima uchun u tahlildan oldin bajarilishi shart?

Nimani mustahkamlaydi: 2.5, 2.7-bo'limlar.

Xulosa

Bu darsda matn tozalashni o'rgandik.

Eng muhim uch fikr:

1. Bo'shliq, registr, almashtirish. str.strip() (chekka bo'shliq — " Ali " → "Ali"), str.lower()/str.upper() (bir registr — "ALI" → "ali"), str.replace("eski", "yangi") (belgi/format — vergul, tire; butun matn). .str metodlari (har element — 3.6).

2. Regex va ajratish. Regex (namuna — str.replace(r"[^\w\s]", "", regex=True) maxsus belgi; str.extract(r"(\d+)") raqam; \d raqam, \w harf/raqam, [^...] emas; kuchli — murakkab namuna). Ajratish/tekshirish — str.split (bo'lish — expand=True ustun), str.contains(..., na=False) (bormi — filtr; NaN → False).

3. Normal ko'rinishga. Normallashtirish — strip+lower+replace (kanonik shakl; "Toshkent"/"toshkent " → "toshkent"); bir xillik — guruh/dublikat 6.2-bob/merge 3.9-bob uchun oldin shart. Matn — ko'rinmas xato (bo'shliq/registr — ko'z aldanadi; jimda statistika buziladi). Tuzoqlar: NaN str (na=; hal oldin), ko'rinmas belgi (\t/\xa0 — regex \s+), regex maxsus belgi (. — regex=False yoki qochir), lower ID buzadi (registr muhim — kontekst), qism almashtirish (aniq namuna), strip o'rta bo'shliq (replace(r"\s+", " ")).

Keyingi darsda sana tozalash (date cleaning)ni o'rganamiz: iflos sana (turli format "01/02/2024", "2024-jan-01", matn) — pd.to_datetime bilan tozalash, format aniqlash, noto'g'ri sana (kelajak, imkonsiz) hal qilish (6.4 datetime ustida).