6.8-dars: Sana tozalash

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

1. Kirish va motivatsiya

Sana (date) ma'lumotning eng chalkash turlaridan biri: "2024-01-15", "15/01/2024", "01/15/2024", "15-Jan-2024", "January 15, 2024" — bir sana, besh format. Bundan tashqari noaniqlik: "01/02/2024" — 1-fevralmi (kun/oy) yoki 2-yanvarmi (oy/kun)? Mamlakatga bog'liq (AQSH — oy/kun; Yevropa — kun/oy). Va noto'g'ri sana: kelajakdagi tug'ilgan sana, imkonsiz sana ("2024-13-45"), yosh 200. 6.4-darsda pd.to_datetime bilan matnni sanaga o'tkazdik; endi chuqurroq: turli formatni tozalash, format aniqlash, noto'g'ri sanani hal qilish, va vaqt zonasi asoslari. Nega muhim? (1) Format — turli ko'rinish (bir standart); (2) Noaniqlik — kun/oy tartibi (format ko'rsatish); (3) Noto'g'ri — kelajak, imkonsiz (tekshirish). Bu dars sana tozalashni o'rgatadi — to'g'ri va bir xil sanaga.

Sana tozalash (date cleaning) — to'g'ri va bir xil sanaga: pd.to_datetime (matn → datetime; 6.4, 3.12), format (format="%d/%m/%Y" — noaniqlik hal; kun/oy tartibi), turli format (format="mixed" yoki dayfirst=), errors="coerce" (noto'g'ri → NaT), noto'g'ri sana (kelajak, imkonsiz — tekshir/o'chir), vaqt zonasi (tz — asoslar). Foydalanish: sanani bir standartga, vaqt amallari 3.12-bob. Bu 6.4 (tur — to_datetime), 3.12 (datetime amallari), 6.1 (NaN/NaT) bilan bog'liq. Sana tozalash — to'g'ri va bir xil. Sana. Format.

Real vaziyat. Data Scientist ikki tizimdan buyurtma ma'lumotini birlashtirmoqchi. Iflos sana: 1-tizim "2024-01-15" (ISO), 2-tizim "15/01/2024" (kun/oy), ba'zi qatorda "2025-06-01" (kelajak — xato) va "2024-13-01" (13-oy — imkonsiz). Muammo: turli format (birlashtirib bo'lmaydi), noto'g'ri sana (kelajak buyurtma — mantiqsiz). Hal: pd.to_datetime(sana, format=..., errors="coerce") (format aniq — noaniqlik yo'q; imkonsiz → NaT), keyin tekshir (kelajak sana — df[df["sana"] > bugun] — o'chir/tuzat). Data Scientist standartlashtirdi (to_datetime), tekshirdi (kelajak/imkonsiz), tozaladi. Sana tozalash — to'g'ri va bir xil.

Bu darsda sana tozalashni o'rganamiz.

Bu darsda:

• to_datetime va format (noaniqlik)
• Turli format (mixed, dayfirst)
• errors="coerce" (noto'g'ri → NaT)
• Noto'g'ri sana (kelajak, imkonsiz)
• Vaqt zonasi (asoslar)
• Sana tozalash amaliyoti
• Sana tozalash tuzoqlari
• Amaliy: sana tozalash

ℹ Misollar real pandas bilan (Python 3.14) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. to_datetime va format (noaniqlik)

Format ko'rsatish:

import pandas as pd

# format ko'rsatish (noaniqlikni hal qiladi)
pd.to_datetime(df["sana"], format="%Y-%m-%d")   # 2024-01-15
pd.to_datetime(df["sana"], format="%d/%m/%Y")   # 15/01/2024 (kun/oy)
pd.to_datetime(df["sana"], format="%m/%d/%Y")   # 01/15/2024 (oy/kun)

# format kodlari: %Y yil, %m oy, %d kun, %H soat, %M daqiqa

to_datetime va format (noaniqlik) — aniq ko'rsatish: pd.to_datetime(df["sana"], format=...) — format ko'rsatish (%Y yil, %m oy, %d kun, %H soat, %M daqiqa); noaniqlik hal ("01/02/2024" — %d/%m/%Y (1-fevral) yoki %m/%d/%Y (2-yanvar)?; format aniqlaydi). Sabab: to_datetime formatsiz — taxmin qiladi (noaniq — "01/02" kun/oy yoki oy/kun?; noto'g'ri talqin); format — aniq (chalkashlik yo'q; tezroq ham); AQSH (oy/kun), Yevropa (kun/oy) — format kerak. format (aniq — noaniqlik yo'q), kodlar (%Y/%m/%d), taxmin (formatsiz — xavfli). to_datetime + format — aniq (noaniqlik hal). Format. Aniq.

2.2. Turli format (mixed, dayfirst)

Aralash formatlar:

import pandas as pd

# turli formatlar aralash (bir ustunda)
pd.to_datetime(df["sana"], format="mixed")   # har qatorga moslashadi

# dayfirst — kun oldinmi (Yevropa)
pd.to_datetime(df["sana"], dayfirst=True)    # 15/01/2024 → kun/oy

# aralash + xato boshqarish
pd.to_datetime(df["sana"], format="mixed", errors="coerce")

Turli format (mixed, dayfirst) — aralash: format="mixed" (har qator turli format — pandas har biriga moslashadi; sekinroq, lekin aralash uchun), dayfirst=True (kun oldin — "15/01/2024" kun/oy; Yevropa), yearfirst=True (yil oldin). Sabab: real ma'lumot aralash (turli tizim — turli format bir ustunda); mixed (har qatorga — moslashadi), dayfirst (noaniqlik — kun/oy hal). mixed (aralash format), dayfirst (kun oldin — Yevropa), sekin (mixed — har qator tekshir). Turli format — mixed/dayfirst (aralash; kun oldin). Mixed. dayfirst.

2.3. errors="coerce" (noto'g'ri → NaT)

errors="coerce" (noto'g'ri → NaT) — xato boshqarish: pd.to_datetime(..., errors="coerce") (o'zgartirib bo'lmaydigan → NaT — Not a Time; sana NaN'i); "2024-13-45" (13-oy, 45-kun — imkonsiz) → NaT, "salom" → NaT. Sabab: real ma'lumot buziq (imkonsiz sana, matn, bo'sh); raise (standart — xato, to'xta), coerce (buziq → NaT — davom; keyin hal 6.1). coerce (noto'g'ri → NaT — davom), NaT (sana NaN), keyin hal (NaT — 6.1 kabi). errors — coerce (noto'g'ri → NaT). coerce. NaT.

2.4. Noto'g'ri sana (kelajak, imkonsiz)

Noto'g'ri sana (kelajak, imkonsiz) — mantiqiy tekshirish: imkonsiz ("2024-13-45" — 13-oy; to_datetime NaT — coerce), mantiqsiz (kelajakda tug'ilgan sana; buyurtma kelajakda; yosh 200 — 1824-yilda tug'ilgan); kelajak (df[df["sana"] > pd.Timestamp.now()] — bugundan keyin), juda eski (df[df["sana"] < "1900-01-01"]). Sabab: to_datetime formati to'g'ri, lekin mantiqi noto'g'ri (kelajak sana — sintaksis to'g'ri, ma'no xato); domen (buyurtma — o'tmish; tug'ilgan — o'tmish, oqilona yosh). Imkonsiz (NaT — coerce), kelajak (> now), juda eski (< 1900), domen (mantiq). Noto'g'ri sana — kelajak/imkonsiz (mantiqiy tekshir). Noto'g'ri. Mantiq.

2.5. Vaqt zonasi (asoslar)

Vaqt zonasi (asoslar) — tz: datetime vaqt zonasiz (naive) yoki zona bilan (aware); dt.tz_localize("UTC") (zona qo'sh), dt.tz_convert("Asia/Tashkent") (zona o'zgartir). Sabab: global ma'lumot (turli zona — server UTC, foydalanuvchi mahalliy; taqqoslash — bir zona); ko'p holatda bir zona (yoki naive — mahalliy deb faraz); muammo (turli zona aralash — vaqt farqi noto'g'ri). tz_localize (zona qo'sh), tz_convert (o'zgartir), UTC (standart — server). Vaqt zonasi — tz (localize/convert; global). Zona. UTC.

2.6. Sana tozalash amaliyoti

Sana tozalash amaliyoti: ko'rish (df["sana"].head() — format; turlimi); to_datetime (format= aniq — noaniqlik; yoki mixed/dayfirst — aralash); coerce (errors="coerce" — imkonsiz → NaT); mantiqiy tekshir (kelajak > now, eski < 1900, yosh — domen); NaT hal (6.1 — o'chir/to'ldir/belgila); vaqt amallari (.dt.year/month/dayofweek — 3.12); tekshir (.dt ishlaydimi; NaT soni). Tuzoqlar: format noaniq (taxmin — kun/oy), dayfirst unut (Yevropa noto'g'ri), coerce yashirin NaT (tekshir), kelajak e'tiborsiz (mantiq), zona aralash (bir zona). Amaliyot — ko'rish, to_datetime, coerce, mantiq. Sana. Bir xil.

2.7. Sana tozalash tuzoqlari

Sana tozalash asosiy tuzoqlari: format noaniq (to_datetime formatsiz — "01/02/2024" taxmin (kun/oy yoki oy/kun? AQSH oy oldin, Yevropa kun oldin); noto'g'ri talqin — 1-fevral yoki 2-yanvar?; format= yoki dayfirst=); dayfirst unut (Yevropa format ("15/01/2024" — kun/oy) — dayfirst=True yoki format; unutsa — "15/01" xato (15-oy yo'q — NaT yoki noto'g'ri)); coerce yashirin NaT (errors="coerce" — buziq → NaT; necha NaT? (jimda ko'p yo'qolishi mumkin); isna().sum() tekshir); kelajak/imkonsiz e'tiborsiz (to_datetime format to'g'ri, lekin mantiq noto'g'ri (kelajak tug'ilgan sana — sintaksis OK; ma'no xato); domen tekshir — kelajak > now, eski < 1900, yosh 200); vaqt zonasi aralash (turli zona — vaqt farqi noto'g'ri (UTC vs mahalliy; 5 soat farq); bir zonaga keltir — tz_convert); 2 raqamli yil ("01/02/24" — 24-yil? 2024? 1924?; noaniq — %y (2 raqam) xavfli; to'liq yil afzal); matn oy ("15-Jan-2024" — %b (qisqa) yoki %B (to'liq); til — inglizcha; o'zbekcha oy — qo'lda); NaT amallar (NaT bilan .dt — NaT qaytaradi; hal keyin); string saralash (sana matn bo'lsa — alfabet saralash ("02/01" < "15/01" — noto'g'ri); datetime — to'g'ri; avval o'zgartir). Sabab: sana tozalash format/mantiq/zona nozik (noaniq, kelajak, zona — noto'g'ri). Yechim: format aniq, dayfirst, coerce tekshir, mantiqiy tekshir (kelajak), bir zona. Tuzoqlar — format noaniq, dayfirst, coerce, kelajak.

2.8. Sana tozalash — to'g'ri va bir xil sanaga

Sana tozalash asosiy g'oyasi — to'g'ri va bir xil sanaga: sana chalkash (turli format "2024-01-15"/"15/01/2024"; noaniqlik "01/02" kun/oy?; noto'g'ri — kelajak, imkonsiz "2024-13-45") → to'g'ri va bir xil (datetime — vaqt amallari 3.12; standart). pd.to_datetime (matn → datetime; 6.4), format (format="%d/%m/%Y" — noaniqlik hal; mixed/dayfirst — aralash), errors="coerce" (imkonsiz → NaT), noto'g'ri sana (kelajak > now, imkonsiz — mantiqiy tekshir; domen), vaqt zonasi (tz_localize/tz_convert — global; bir zona). Foydalanish: sanani bir standartga (turli format → datetime; birlashtirish/saralash), vaqt amallari (.dt.year/month — 3.12; matn bo'lsa yo'q). Tuzoqlar: format noaniq (taxmin — kun/oy; format=), dayfirst unut (Yevropa), coerce yashirin NaT (tekshir), kelajak/imkonsiz (mantiq — domen), zona aralash (bir zona), 2 raqamli yil (%y xavfli), string saralash (avval datetime). Bu 6.4 (tur — to_datetime), 3.12 (datetime amallari), 6.1 (NaT/NaN), 6.7 (matn tozalash) bilan. Sana tozalash — to'g'ri va bir xil (format, coerce, mantiqiy tekshir). Sana. Format. Mantiq.

3. Tez ma'lumotnoma

import pandas as pd

# TO_DATETIME + FORMAT (noaniqlik hal):
pd.to_datetime(df["sana"], format="%Y-%m-%d")   # ISO
pd.to_datetime(df["sana"], format="%d/%m/%Y")   # kun/oy (Yevropa)
#   %Y yil · %m oy · %d kun · %H soat · %M daqiqa · %b/%B matn oy

# TURLI FORMAT (aralash):
pd.to_datetime(df["sana"], format="mixed")       # har qatorga
pd.to_datetime(df["sana"], dayfirst=True)        # kun oldin

# XATO BOSHQARISH (imkonsiz → NaT):
pd.to_datetime(df["sana"], errors="coerce")      # buzuq → NaT
df["sana"].isna().sum()   # necha NaT (tekshir)

# NOTO'G'RI SANA (mantiqiy tekshirish):
df[df["sana"] > pd.Timestamp.now()]      # kelajak (xato)
df[df["sana"] < "1900-01-01"]            # juda eski

# VAQT ZONASI:
df["sana"].dt.tz_localize("UTC")                 # zona qo'sh
df["sana"].dt.tz_convert("Asia/Tashkent")        # zona o'zgartir

QOIDA: format aniq · dayfirst (Yevropa) · coerce tekshir · mantiq (kelajak)

Sana tozalash xulosasi

Sana tozalash — to'g'ri va bir xil sanaga (datetime — vaqt amallari)
to_datetime + format — noaniqlik hal (kun/oy tartibi)
Turli format — mixed / dayfirst (aralash)
coerce — imkonsiz → NaT (tekshir — necha NaT)
Noto'g'ri sana — kelajak, imkonsiz (mantiqiy tekshirish; domen)

4. Batafsil misollar

Misollar real pandas bilan (Python 3.14) ishlaydi.

Misol 1 — to_datetime va format

"""to_datetime va format (real pandas)."""

import pandas as pd


def main() -> None:
    print("=== 1. ISO format ===")
    iso = pd.to_datetime(pd.Series(["2024-01-15", "2024-03-20"]), format="%Y-%m-%d")
    print(f"  {iso.dt.strftime('%Y-%m-%d').tolist()}")

    print("\n=== 2. Kun/oy (Yevropa) ===")
    yevropa = pd.to_datetime(pd.Series(["15/01/2024", "20/03/2024"]), format="%d/%m/%Y")
    print(f"  oylar: {yevropa.dt.month.tolist()} (1, 3 — to'g'ri)")

    print("\n=== 3. Noaniqlik (01/02) ===")
    kun_oy = pd.to_datetime(pd.Series(["01/02/2024"]), format="%d/%m/%Y")
    oy_kun = pd.to_datetime(pd.Series(["01/02/2024"]), format="%m/%d/%Y")
    print(f"  %d/%m/%Y: {kun_oy.dt.strftime('%d-%B').tolist()} (1-fevral)")
    print(f"  %m/%d/%Y: {oy_kun.dt.strftime('%d-%B').tolist()} (2-yanvar)")

    print("\n=== 4. Format hal qiladi ===")
    print("  formatsiz — taxmin (noaniq); format — aniq")
    print("  ⭐ format — noaniqlikni hal qiladi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. ISO format ===
  ['2024-01-15', '2024-03-20']

=== 2. Kun/oy (Yevropa) ===
  oylar: [1, 3] (1, 3 — to'g'ri)

=== 3. Noaniqlik (01/02) ===
  %d/%m/%Y: ['01-February'] (1-fevral)
  %m/%d/%Y: ['02-January'] (2-yanvar)

=== 4. Format hal qiladi ===
  formatsiz — taxmin (noaniq); format — aniq
  ⭐ format — noaniqlikni hal qiladi

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — Turli format (mixed)

"""Turli format: mixed (real pandas)."""

import pandas as pd


def main() -> None:
    # aralash format (turli tizim)
    sanalar = pd.Series(["2024-01-15", "20/03/2024", "2024-06-10"])

    print("=== 1. Aralash format ===")
    print(f"  {sanalar.tolist()}")

    print("\n=== 2. format='mixed' ===")
    mixed = pd.to_datetime(sanalar, format="mixed", dayfirst=True)
    print(f"  natija: {mixed.dt.strftime('%Y-%m-%d').tolist()}")

    print("\n=== 3. Har qatorga moslashdi ===")
    print(f"  oylar: {mixed.dt.month.tolist()}")

    print("\n=== 4. Endi bir standart ===")
    print("  turli format → bir datetime (saralash, birlashtirish)")
    print("  ⭐ mixed — aralash formatni moslaydi")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Aralash format ===
  ['2024-01-15', '20/03/2024', '2024-06-10']

=== 2. format='mixed' ===
  natija: ['2024-01-15', '2024-03-20', '2024-10-06']

=== 3. Har qatorga moslashdi ===
  oylar: [1, 3, 10]

=== 4. Endi bir standart ===
  turli format → bir datetime (saralash, birlashtirish)
  ⭐ mixed — aralash formatni moslaydi

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — coerce va noto'g'ri sana

"""coerce va noto'g'ri sana (real pandas)."""

import pandas as pd


def main() -> None:
    sanalar = pd.Series(["2024-01-15", "2024-13-45", "salom", "2024-06-10"])

    print("=== 1. coerce (imkonsiz → NaT) ===")
    toza = pd.to_datetime(sanalar, format="%Y-%m-%d", errors="coerce")
    print(f"  {toza.dt.strftime('%Y-%m-%d').tolist()}")

    print("\n=== 2. NaT soni ===")
    print(f"  NaT (buzuq): {int(toza.isna().sum())}")

    print("\n=== 3. Kelajak sana (mantiqiy) ===")
    df = pd.DataFrame({"sana": pd.to_datetime(["2020-01-01", "2099-01-01"])})
    kelajak = df[df["sana"] > pd.Timestamp("2026-01-01")]
    print(f"  kelajak sanalar: {kelajak['sana'].dt.year.tolist()}")

    print("\n=== 4. Xulosa ===")
    print("  coerce — imkonsiz → NaT; mantiq — kelajak tekshir")
    print("  ⭐ coerce + mantiqiy tekshirish")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. coerce (imkonsiz → NaT) ===
  ['2024-01-15', nan, nan, '2024-06-10']

=== 2. NaT soni ===
  NaT (buzuq): 2

=== 3. Kelajak sana (mantiqiy) ===
  kelajak sanalar: [2099]

=== 4. Xulosa ===
  coerce — imkonsiz → NaT; mantiq — kelajak tekshir
  ⭐ coerce + mantiqiy tekshirish

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

Misol 4 — Vaqt amallari (tozalangandan keyin)

"""Vaqt amallari: tozalangandan keyin (real pandas)."""

import pandas as pd


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

    print("=== 1. Tozalash (format) ===")
    df["sana"] = pd.to_datetime(df["sana"], format="%d/%m/%Y")
    print(f"  tur: {df['sana'].dtype}")

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

    print("\n=== 3. Saralash (datetime — to'g'ri) ===")
    saralangan = df.sort_values("sana")
    print(f"  saralangan oylar: {saralangan['sana'].dt.month.tolist()}")

    print("\n=== 4. Nega tozalash oldin ===")
    print("  matn — alfabet saralash (noto'g'ri); datetime — to'g'ri")
    print("  ⭐ Tozalangan sana — vaqt amallari")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Tozalash (format) ===
  tur: datetime64[us]

=== 2. Vaqt amallari 3.12-bob ===
  yil: [2024, 2024, 2024]
  oy: [1, 6, 12]
  hafta kuni: [0, 3, 1]

=== 3. Saralash (datetime — to'g'ri) ===
  saralangan oylar: [1, 6, 12]

=== 4. Nega tozalash oldin ===
  matn — alfabet saralash (noto'g'ri); datetime — to'g'ri
  ⭐ Tozalangan sana — vaqt amallari

Nima ko'rsatdi: 2.6-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. Format noaniq

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

2. dayfirst unutish

pd.to_datetime(df["sana"])   # "15/01/2024" — 15-oy? (xato)       # ⚠️
pd.to_datetime(df["sana"], dayfirst=True)   # kun oldin          # ✅

3. coerce yashirin NaT

pd.to_datetime(df["sana"], errors="coerce")   # necha NaT?        # ⚠️
df["sana"].isna().sum()   # keyin tekshir                         # ✅

4. Kelajak sana

# format to'g'ri, kelajak tug'ilgan sana (mantiq xato)            # ⚠️
df[df["sana"] > pd.Timestamp.now()]   # kelajak tekshir          # ✅

5. Zona aralash

# UTC va mahalliy aralash (vaqt farqi noto'g'ri)                  # ⚠️
df["sana"].dt.tz_convert("Asia/Tashkent")   # bir zona           # ✅

6. 2 raqamli yil

pd.to_datetime("01/02/24", format="%d/%m/%y")   # 24 — 2024? 1924? # ⚠️
# to'liq yil (%Y) afzal                                           # ✅

7. Matn saralash

df.sort_values("sana")   # matn — alfabet (02/01 < 15/01 xato)    # ⚠️
df["sana"] = pd.to_datetime(...); df.sort_values("sana")         # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 6.4-dars (o'tilgan): Tur (to_datetime)
• 3.12-dars (o'tilgan): Datetime (vaqt amallari)
• 6.1-dars (o'tilgan): NaN/NaT
• 6.7-dars (o'tilgan): Matn tozalash
• 6.11-dars: Tozalash quvuri

8. Eng yaxshi amaliyotlar

1. Format — aniq (format=).

2. dayfirst — Yevropa (kun oldin).

3. coerce — imkonsiz → NaT (tekshir).

4. Mantiqiy tekshir — kelajak, imkonsiz.

5. To'liq yil — %Y (%y emas).

6. Bir zona — tz_convert.

7. datetime — saralashdan oldin.

8. NaT — 6.1 kabi hal.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # sana tozalash nima?
2.  # to_datetime nima?
3.  # format nega?
4.  # 01/02 noaniqligi?
5.  # mixed nima?
6.  # dayfirst nima?
7.  # coerce (sana)?
8.  # NaT nima?
9.  # kelajak sana?
10. # zona nima?
11. # 2 raqamli yil?
12. # nega tozalash?

Vazifa 2: Xatolarni tuzating

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

2.  pd.to_datetime(df["sana"])   # 15/01/2024

3.  pd.to_datetime(df["sana"], errors="coerce")

4.  # kelajak tug'ilgan sana

5.  df.sort_values("sana")   # matn

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

2.  dayfirst=True

3.  isna().sum() tekshir

4.  df[df["sana"] > now]

5.  to_datetime avval

Vazifa 3: Format

Modellang:

1. to_datetime
2. format kodlari
3. Noaniqlik
4. Aniq

Vazifa 4: Turli format

Modellang:

1. mixed
2. dayfirst
3. Aralash
4. Bir standart

Vazifa 5: Noto'g'ri sana

Modellang:

1. coerce (imkonsiz)
2. NaT
3. Kelajak
4. Mantiq

Vazifa 6: Integratsiya

Modellang:

1. Tur (6.4)
2. Datetime (3.12)
3. NaT (6.1)
4. Quvur (6.11)

Vazifa 7: O'ylash

Sana "01/02/2024" ikki xil o'qilishi mumkin: 1-fevral (kun/oy — Yevropa) yoki 2-yanvar (oy/kun — AQSH). pd.to_datetime formatsiz taxmin qiladi — va noto'g'ri talqin qilishi mumkin. Nima uchun bu "noaniqlik" sana ma'lumotining eng xavfli xususiyati, va nima uchun format har doim aniq ko'rsatilishi kerak?

Nimani mustahkamlaydi: 2.1, 2.7-bo'limlar.

Xulosa

Bu darsda sana tozalashni o'rgandik.

Eng muhim uch fikr:

1. to_datetime va format. pd.to_datetime(df["sana"], format=...) (matn → datetime; 6.4); format (%Y yil, %m oy, %d kun; %d/%m/%Y kun/oy, %m/%d/%Y oy/kun) noaniqlikni hal qiladi ("01/02/2024" — 1-fevral yoki 2-yanvar?; formatsiz taxmin — jim noto'g'ri).

2. Turli format va coerce. format="mixed" (aralash format — har qatorga moslashadi), dayfirst=True (kun oldin — Yevropa). errors="coerce" (imkonsiz sana "2024-13-45" → NaT; keyin isna().sum() tekshir — yashirin NaT). Noto'g'ri sana (kelajak > now, imkonsiz, juda eski < 1900) — format to'g'ri, mantiq noto'g'ri (domen tekshir).

3. To'g'ri va bir xil. Sana tozalash — chalkash (turli format, noaniqlik, noto'g'ri) → to'g'ri va bir xil (datetime — vaqt amallari 3.12; birlashtirish/saralash). Vaqt zonasi (tz_convert — global; bir zona). Noaniqlik — sana eng xavfli xususiyat (jim noto'g'ri — format doim aniq). Tuzoqlar: format noaniq (taxmin), dayfirst unut (Yevropa), coerce yashirin NaT (tekshir), kelajak/imkonsiz (mantiq — domen), zona aralash (bir zona), 2 raqamli yil (%y — 24 → 2024? noaniq), matn saralash (alfabet — avval datetime).

Keyingi darsda kategoriya kodlash (categorical encoding)ni o'rganamiz: kategoriya matnni (shahar, jins) modelga songa aylantirish — Label Encoding (0,1,2), One-Hot Encoding (har kategoriya — ustun); model faqat son qabul qiladi (matn emas).