IlmHamroh
Data Science va sun'iy intellekt/Pandas5/14-dars17 daqiqa
Mundarija (22)

3.5-dars: Filtrlash

3-QISM — PANDAS · 5-dars

1. Kirish va motivatsiya

Data Science ishining katta qismi — filtrlash: butun ma'lumotdan kerakli qismini ajratish. "Faqat Toshkentdagi mijozlar", "18 yoshdan katta va 65 yoshdan kichik", "narxi 100 dan yuqori mahsulotlar", "shu 5 ta shahar". NumPy'da boolean indekslashni 2.9-bob, o'tgan darsda .loc bilan shartni ko'rdik; endi Pandas'ning barcha filtrlash usullarini to'liq o'rganamiz: oddiy shart (df[df["yosh"] > 18]), ko'p shart (&, |), isin (ro'yxatda bormi), between (oraliq), matn filtri (.str.contains). Nega muhim? (1) Ma'lumotni ajratish — deyarli har tahlil filtrdan boshlanadi; (2) Tozalash — noto'g'ri/kerakmas qatorlarni olib tashlash (6-qism); (3) Tahlil — guruhlarni solishtirish (Toshkent vs Samarqand). Filtrlash — Data Science'ning eng ko'p bajariladigan amali. Bu dars filtrlashni to'liq o'rgatadi — ma'lumotni ajratish.

Filtrlash — shart bo'yicha qator ajratish: oddiy shart (df[df["yosh"] > 18] — boolean), ko'p shart (& VA, | YOKI, ~ EMAS — qavs bilan), isin (ro'yxatda bor-mi — df[df["shahar"].isin([...])]), between (oraliq — df[df["yosh"].between(18, 65)]), matn filtr (.str.contains — matn ichida), .loc (shart + ustun — 3.4). Foydalanish: ma'lumot ajratish, tozalash, tahlil. Bu 2.9 (NumPy shart), 3.4 (loc) bilan bog'liq. Filtr — shart bo'yicha. isin/between. Ajratish.

Real vaziyat. Data Scientist 10000 mijoz DataFrame'i bilan ishlar edi. Turli filtrlar kerak edi: Toshkent mijozlari — df[df["shahar"] == "Toshkent"]; ishlovchi yosh (18-65) — df[df["yosh"].between(18, 65)]; uch shahar — df[df["shahar"].isin(["Toshkent", "Samarqand", "Buxoro"])]; VIP (yosh > 30 VA xarid > 1000) — df[(df["yosh"] > 30) & (df["xarid"] > 1000)]; ismi "A" bilan — df[df["ism"].str.startswith("A")]. Har filtr ma'lumotni kerakli qismiga kesdi (guruh, tahlil, tozalash). Filtrlash — Data Science eng ko'p amali (deyarli har tahlil filtrdan boshlanadi).

Bu darsda filtrlashni o'rganamiz.

Bu darsda:

  • Oddiy shart filtri
  • Ko'p shart (&, |, ~)
  • isin (ro'yxatda bormi)
  • between (oraliq)
  • Matn filtri (.str)
  • Filtr amaliyoti
  • Filtr tuzoqlari
  • Amaliy: filtr modeli

ℹ Misollar real pandas bilan (deterministik) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. Oddiy shart filtri

Boolean bilan qator ajratish:

python
import pandas as pd

df = pd.DataFrame({
    "ism": ["Ali", "Vali", "Guli"],
    "yosh": [25, 35, 28],
})

df["yosh"] > 30            # bool Series [F T F]
df[df["yosh"] > 30]        # 30 dan katta QATORLAR (filtr)
df[df["ism"] == "Ali"]     # ismi Ali

Oddiy shart filtri — boolean bilan qator ajratish: df["yosh"] > 30 (bool Series — 2.5/3.1), df[df["yosh"] > 30] (shart bajargan qatorlar — boolean indeks). Sabab: ma'lumotni shart bo'yicha ajratish (30 dan katta, Toshkentdagi — kerakli qism); bool Series filtr (True qatorlar olinadi). df[shart] — DataFrame (shart bajargan qatorlar). NumPy boolean 2.9-bob bilan bir xil g'oya (bool massiv — filtr). Natija — kichikroq DataFrame (shart bajarganlar). Oddiy shart — df[df["ustun"] > qiymat] (filtr). Boolean. Qator ajratish.

2.2. Ko'p shart (&, |, ~)

Bir nechta shart:

python
df = pd.DataFrame({"yosh": [25, 35, 28, 42], "xarid": [500, 1500, 800, 2000]})

# & (VA), | (YOKI), ~ (EMAS) — QAVS bilan!
df[(df["yosh"] > 30) & (df["xarid"] > 1000)]   # VA
df[(df["yosh"] < 25) | (df["xarid"] > 1800)]   # YOKI
df[~(df["yosh"] > 30)]                          # EMAS

# and/or ISHLAMAYDI (NumPy kabi — 2.9)

Ko'p shart (&, |, ~) — bir nechta shart: & (VA — ikki shart ham), | (YOKI — biri), ~ (EMAS); QAVS bilan ((shart1) & (shart2)). Sabab: ko'pincha ko'p shart (VIP — yosh > 30 VA xarid > 1000; oraliq — katta VA kichik); shartlar &/|/~ bilan. MUHIM (NumPy 2.9 kabi): Python and/or ishlamaydi (Series — "truth value ambiguous"); &/|/~ (element-wise); qavs shart (& ustuvorlik — (shart1) & (shart2)). Ko'p shart — &/|/~ (qavs bilan). and/or emas. Qavs.

2.3. isin (ro'yxatda bormi)

Ro'yxatda bor-mi:

python
df = pd.DataFrame({"shahar": ["Toshkent", "Samarqand", "Xiva", "Buxoro"]})

# isin — qiymat ro'yxatda bormi
shaharlar = ["Toshkent", "Samarqand", "Buxoro"]
df[df["shahar"].isin(shaharlar)]     # shu uch shahar

# ~isin — EMAS (ro'yxatda YO'Q)
df[~df["shahar"].isin(shaharlar)]    # Xiva

isin (ro'yxatda bor-mi) — qiymat ro'yxatda bor-mi tekshiradi: df[df["shahar"].isin(["Toshkent", "Samarqand"])] (shu shaharlar), ~df["shahar"].isin([...]) (ro'yxatda YO'Q). Sabab: ko'pincha ko'p qiymat tekshirish (uch shahar — == "T" | == "S" | == "B" uzun; isin([...]) qisqa); isin ro'yxat bilan (bir amalda — bir nechta qiymat). == (bitta), isin (ro'yxat — ko'p). ~isin (inkor — ro'yxatda yo'q). isin — ro'yxatda bor-mi (.isin([...])). Ko'p qiymat. Qisqa.

2.4. between (oraliq)

Oraliq (min-max):

python
df = pd.DataFrame({"yosh": [15, 25, 45, 70, 30]})

# between — oraliq (ikkalasi ham kiradi)
df[df["yosh"].between(18, 65)]    # 18-65 (ikkalasi kiradi)

# teng: (df["yosh"] >= 18) & (df["yosh"] <= 65)

between (oraliq) — min-max oraliq: df[df["yosh"].between(18, 65)] (18-65 orasi — ikkalasi kiradi, inclusive). Sabab: ko'pincha oraliq kerak (ishlovchi yosh 18-65; narx 100-500); between(a, b) qisqa ((x >= a) & (x <= b) o'rniga — o'qilishli). Standart ikki chegara ham kiradi (between(18, 65) — 18 va 65 ham; inclusive= bilan o'zgartirish mumkin). between — >= VA <= (qisqa). between — oraliq (.between(a, b), ikkalasi kiradi). Qisqa. Oraliq.

2.5. Matn filtri (.str)

Matn ustuni bo'yicha:

python
df = pd.DataFrame({"ism": ["Ali", "Anvar", "Vali", "Guli"]})

df[df["ism"].str.startswith("A")]    # "A" bilan boshlanadi
df[df["ism"].str.contains("li")]     # "li" bor
df[df["ism"].str.len() > 3]          # 3 harfdan uzun
df[df["ism"].str.lower() == "ali"]   # kichik harf bilan

Matn filtri (.str) — matn ustuni bo'yicha: df["ism"].str.startswith("A") ("A" bilan boshlanadi), .str.contains("li") ("li" bor), .str.len() > 3 (uzunlik), .str.lower() (kichik harf). Sabab: matn ma'lumotni matn bo'yicha filtrlash (ismi "A" bilan; email "@gmail" bor; kod "UZ" bilan); .str matn metodlari (vektorlashtirilgan — har qatorga). .str.contains (ichida bor), .str.startswith/endswith (boshi/oxiri), .str.lower/upper (registr). Matn tozalash (6-qism) uchun ham. Matn filtri — .str.contains/startswith (matn bo'yicha). Vektorlashtirilgan. Matn.

2.6. Filtr amaliyoti

Filtr amaliyoti: oddiy shart (df[df["ustun"] > qiymat]); ko'p shart (&/|/~ — qavs); isin (ro'yxat — ko'p qiymat); between (oraliq — min-max); .str (matn — contains/startswith); .loc[shart, ustun] (shart + ustun — 3.4); ~ (inkor — EMAS); natija (kichikroq DataFrame — shart bajarganlar). Tuzoqlar: and/or (Series — &/|), qavs unutish (ustuvorlik), indeks tarqoq (filtrdan keyin — reset_index), SettingWithCopy (.loc bilan o'zgartir), NaN (shart NaN'ni o'tkazib yuboradi). Amaliyot — shart, ko'p shart, isin, between, str. Ajratish. Boolean.

2.7. Filtr tuzoqlari

Filtr asosiy tuzoqlari: and/or (Series bilan and/or — "truth value ambiguous" xato; &/|/~ — 2.9); qavs unutish (df[df.a > 1 & df.b > 2] — & ustuvorlik, xato; (df.a > 1) & (df.b > 2)); indeks tarqoq (filtrdan keyin indeks saqlanadi (0, 2, 5 — asl); .iloc[0] (birinchi — pozitsiya), .loc[0] (nom — bor-yo'q); reset_index(drop=True) kerak bo'lsa — 3.4); SettingWithCopy (filtr natijasini o'zgartirish — df2 = df[shart].copy() yoki .loc; 2.13/3.4); NaN filtr (df[df.a > 0] — NaN qatorlar o'tkazib yuboriladi (nan > 0 False — 2.9); NaN kerak bo'lsa isna); isin tur (isin([1, 2]) — tur mos bo'lishi kerak; "1" (matn) vs 1 (son) — mos emas); matn NaN (.str.contains — NaN'da xato; na=False bilan). Sabab: filtr shart/indeks/NaN nozik (and/or, qavs, indeks, NaN — jim xato yoki noto'g'ri). Yechim: &/|, qavs, reset_index, .copy(). Tuzoqlar — and/or, qavs, indeks, NaN.

2.8. Filtrlash — ma'lumotni ajratish

Filtrlash asosiy g'oyasi — ma'lumotni ajratish: butun ma'lumotdan kerakli qismini olish (Toshkent mijozlari, 18-65 yosh, VIP — shart bo'yicha); Data Science'ning eng ko'p amali (deyarli har tahlil filtrdan boshlanadi). Usullar: oddiy shart (df[df["ustun"] > qiymat] — boolean), ko'p shart (&/|/~ — qavs; and/or emas), isin (ro'yxat — ko'p qiymat), between (oraliq — min-max), .str (matn — contains/startswith). Bu 2.9 (NumPy boolean) davomi (bir xil g'oya — bool Series filtr) va 3.4 (.loc shart + ustun) bilan. Data Science'da filtrlash doim (tahlil — guruh ajratish, solishtirish; tozalash — noto'g'ri qatorlar olib tashlash 6-qism; ML — namuna tanlash). Filtrlash — ma'lumotni ajratish (shart bo'yicha). Eng ko'p amal. Kerakli qism.

3. Tez ma'lumotnoma

python
import pandas as pd

# ODDIY SHART:
df[df["yosh"] > 30]              # 30 dan katta
df[df["ism"] == "Ali"]           # teng

# KO'P SHART (&, |, ~ — QAVS!):
df[(df["yosh"] > 30) & (df["xarid"] > 1000)]   # VA
df[(df["yosh"] < 25) | (df["xarid"] > 1800)]   # YOKI
df[~(df["yosh"] > 30)]                          # EMAS
#   and/or ISHLAMAYDI (2.9)

# isin (ro'yxatda bormi):
df[df["shahar"].isin(["Toshkent", "Buxoro"])]
df[~df["shahar"].isin([...])]    # EMAS

# between (oraliq — ikkalasi kiradi):
df[df["yosh"].between(18, 65)]

# MATN (.str):
df[df["ism"].str.contains("li")]
df[df["ism"].str.startswith("A")]

QOIDA: &/|/~ (and/or emas) · qavs · isin ro'yxat · between oraliq

Filtr xulosasi

Filtrlash — ma'lumotni ajratish (shart bo'yicha, eng ko'p amal)
Oddiy — df[df["ustun"] > qiymat] (boolean)
Ko'p shart — &, |, ~ (qavs bilan, and/or emas)
isin — ro'yxatda bormi · between — oraliq (ikkalasi kiradi)
.str — matn filtri (contains, startswith)

4. Batafsil misollar

Misollar real pandas bilan (deterministik) ishlaydi.

Misol 1 — Oddiy va ko'p shart

python
"""Oddiy va ko'p shart filtri (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "ism": ["Ali", "Vali", "Guli", "Hasan"],
        "yosh": [25, 35, 28, 42],
        "xarid": [500, 1500, 800, 2000],
    })

    print("=== 1. Oddiy shart ===")
    print(f"  30 dan katta: {list(df[df['yosh'] > 30]['ism'])}")

    print("\n=== 2. VA (&) ===")
    vip = df[(df["yosh"] > 30) & (df["xarid"] > 1000)]
    print(f"  VIP (yosh>30 & xarid>1000): {list(vip['ism'])}")

    print("\n=== 3. YOKI (|) ===")
    maxsus = df[(df["yosh"] < 27) | (df["xarid"] > 1800)]
    print(f"  yosh<27 | xarid>1800: {list(maxsus['ism'])}")

    print("\n=== 4. EMAS (~) ===")
    print(f"  30 dan katta EMAS: {list(df[~(df['yosh'] > 30)]['ism'])}")
    print("  ⭐ Filtr — shart bo'yicha ajratish (&, |, ~ qavs bilan)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Oddiy shart ===
  30 dan katta: ['Vali', 'Hasan']

=== 2. VA (&) ===
  VIP (yosh>30 & xarid>1000): ['Vali', 'Hasan']

=== 3. YOKI (|) ===
  yosh<27 | xarid>1800: ['Ali', 'Hasan']

=== 4. EMAS (~) ===
  30 dan katta EMAS: ['Ali', 'Guli']
  ⭐ Filtr — shart bo'yicha ajratish (&, |, ~ qavs bilan)

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

Misol 2 — isin

python
"""isin: ro'yxatda bormi (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "ism": ["Ali", "Vali", "Guli", "Hasan"],
        "shahar": ["Toshkent", "Samarqand", "Xiva", "Buxoro"],
    })

    print("=== 1. isin (uch shahar) ===")
    shaharlar = ["Toshkent", "Samarqand", "Buxoro"]
    tanlangan = df[df["shahar"].isin(shaharlar)]
    print(f"  ismlar: {list(tanlangan['ism'])}")

    print("\n=== 2. ~isin (EMAS) ===")
    print(f"  ro'yxatda YO'Q: {list(df[~df['shahar'].isin(shaharlar)]['ism'])}")

    print("\n=== 3. isin vs == ===")
    print(f"  isin soni: {df['shahar'].isin(shaharlar).sum()}")

    print("\n=== 4. Tushuntirish ===")
    print("  isin — ko'p qiymat (ro'yxat), == bitta")
    print("  ⭐ isin — ro'yxatda bormi (qisqa)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. isin (uch shahar) ===
  ismlar: ['Ali', 'Vali', 'Hasan']

=== 2. ~isin (EMAS) ===
  ro'yxatda YO'Q: ['Guli']

=== 3. isin vs == ===
  isin soni: 3

=== 4. Tushuntirish ===
  isin — ko'p qiymat (ro'yxat), == bitta
  ⭐ isin — ro'yxatda bormi (qisqa)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — between

python
"""between: oraliq (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "ism": ["Ali", "Vali", "Guli", "Hasan", "Nodir"],
        "yosh": [15, 25, 45, 70, 30],
    })

    print("=== 1. between (18-65) ===")
    ishlovchi = df[df["yosh"].between(18, 65)]
    print(f"  ishlovchi yosh: {list(ishlovchi['ism'])}")

    print("\n=== 2. Chegaralar kiradi ===")
    aniq = df[df["yosh"].between(25, 45)]
    print(f"  25-45 (ikkalasi kiradi): {list(aniq['yosh'])}")

    print("\n=== 3. Teng (& bilan) ===")
    teng = df[(df["yosh"] >= 18) & (df["yosh"] <= 65)]
    print(f"  & bilan bir xil: {len(teng) == len(ishlovchi)}")

    print("\n=== 4. Tushuntirish ===")
    print("  between — >= VA <= (qisqa, ikkalasi kiradi)")
    print("  ⭐ between — oraliq (min-max)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. between (18-65) ===
  ishlovchi yosh: ['Vali', 'Guli', 'Nodir']

=== 2. Chegaralar kiradi ===
  25-45 (ikkalasi kiradi): [25, 45, 30]

=== 3. Teng (& bilan) ===
  & bilan bir xil: True

=== 4. Tushuntirish ===
  between — >= VA <= (qisqa, ikkalasi kiradi)
  ⭐ between — oraliq (min-max)

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — Matn filtri (.str)

python
"""Matn filtri: .str (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "ism": ["Ali", "Anvar", "Vali", "Guli"],
        "email": ["ali@mail.uz", "anvar@gmail.com", "vali@mail.uz", "guli@gmail.com"],
    })

    print("=== 1. startswith ===")
    print(f"  'A' bilan: {list(df[df['ism'].str.startswith('A')]['ism'])}")

    print("\n=== 2. contains ===")
    gmail = df[df["email"].str.contains("gmail")]
    print(f"  gmail: {list(gmail['ism'])}")

    print("\n=== 3. len ===")
    print(f"  3 harfdan uzun: {list(df[df['ism'].str.len() > 3]['ism'])}")

    print("\n=== 4. lower ===")
    print(f"  'ali' (kichik): {list(df[df['ism'].str.lower() == 'ali']['ism'])}")
    print("  ⭐ Matn filtri — .str (contains, startswith)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. startswith ===
  'A' bilan: ['Ali', 'Anvar']

=== 2. contains ===
  gmail: ['Anvar', 'Guli']

=== 3. len ===
  3 harfdan uzun: ['Anvar', 'Vali', 'Guli']

=== 4. lower ===
  'ali' (kichik): ['Ali']
  ⭐ Matn filtri — .str (contains, startswith)

Nima ko'rsatdi: 2.5-bo'lim.

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

Noto'g'ri fikr To'g'risi
"and/or ishlaydi" &,
"qavs keraksiz" Qavs shart (ustuvorlik)
"== ro'yxat uchun" isin (ko'p qiymat)
"between oxiri kirmaydi" Ikkalasi kiradi
"matn filtri qiyin" .str (contains, startswith)
"filtr indeksni tiklaydi" Indeks saqlanadi (reset kerak)
"NaN filtrga kiradi" O'tkazib yuboriladi (nan>0 False)
"filtr asl o'zgartiradi" Yangi DataFrame

6. Keng tarqalgan xatolar va yechimlari

1. and/or

python
df[(df.a > 1) and (df.b > 2)]   # xato (ambiguous)            # ⚠️
df[(df.a > 1) & (df.b > 2)]     # &                            # ✅

2. Qavs unutish

python
df[df.a > 1 & df.b > 2]   # xato (& ustuvorlik)               # ⚠️
df[(df.a > 1) & (df.b > 2)]   # qavs                           # ✅

3. == o'rniga isin

python
df[(df.shahar=="T") | (df.shahar=="S") | (df.shahar=="B")]   # uzun # ⚠️
df[df.shahar.isin(["T", "S", "B"])]   # qisqa                 # ✅

4. Indeks tarqoq

python
df2 = df[df.yosh > 25]; df2.loc[0]   # indeks 0 yo'q bo'lishi mumkin # ⚠️
df2 = df[df.yosh > 25].reset_index(drop=True)   # tiklash      # ✅

5. Matn NaN

python
df[df.ism.str.contains("A")]   # NaN bo'lsa xato              # ⚠️
df[df.ism.str.contains("A", na=False)]   # NaN → False         # ✅

6. isin tur

python
df[df.kod.isin(["1", "2"])]   # kod son bo'lsa mos emas       # ⚠️
df[df.kod.isin([1, 2])]   # tur mos                            # ✅

7. Filtr natijasini o'zgartirish

python
df[df.yosh > 25]["kat"] = "X"   # SettingWithCopy             # ⚠️
df.loc[df.yosh > 25, "kat"] = "X"   # .loc                    # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 2.9-dars (o'tilgan): NumPy boolean indeks
  • 3.4-dars (o'tilgan): .loc (shart + ustun)
  • 3.8-dars: Guruhlash (filtr + guruh)
  • 6-qism: Tozalash (noto'g'ri qatorlarni filtrlash)
  • 4-qism: Statistika (guruhlarni solishtirish)

8. Eng yaxshi amaliyotlar

  1. df[shart] — oddiy filtr (boolean).

  2. &/|/~ — qavs bilan (and/or emas).

  3. isin — ko'p qiymat (ro'yxat).

  4. between — oraliq (qisqa).

  5. .str — matn filtri (contains).

  6. reset_index — filtrdan keyin (kerak bo'lsa).

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

  8. Filtrlash — ma'lumotni ajratish.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # oddiy filtr qanday?
2.  # df[shart] nima qaytaradi?
3.  # ko'p shart operatorlari?
4.  # and/or ishlaydimi?
5.  # qavs kerakmi?
6.  # isin nima?
7.  # between nima?
8.  # between oxiri kiradimi?
9.  # matn filtri?
10. # filtr indeksni tiklaydimi?
11. # NaN filtrga kiradimi?
12. # nega filtr muhim?
Javoblar
  1. df[df["ustun"] > qiymat]
  2. Shart bajargan qatorlar (DataFrame)
  3. &, |, ~
  4. Yo'q (&, |, ~)
  5. Ha (ustuvorlik)
  6. Ro'yxatda bormi
  7. Oraliq (min-max)
  8. Ha (ikkalasi kiradi)
  9. .str (contains, startswith)
  10. Yo'q (saqlanadi, reset kerak)
  11. Yo'q (o'tkazib yuboriladi)
  12. Ma'lumotni ajratish (eng ko'p amal)

Vazifa 2: Xatolarni tuzating

python
1.  df[(df.a>1) and (df.b>2)]   # and

2.  df[df.a>1 & df.b>2]   # qavs

3.  df[(df.s=="T")|(df.s=="S")]   # ko'p qiymat

4.  df2 = df[df.yosh>25]; df2.loc[0]   # indeks

5.  df[df.yosh>25]["kat"] = "X"   # o'zgartirish
Javoblar
python
1.  df[(df.a>1) & (df.b>2)]

2.  df[(df.a>1) & (df.b>2)]

3.  df[df.s.isin(["T", "S"])]

4.  df.reset_index(drop=True)

5.  df.loc[df.yosh>25, "kat"] = "X"

Vazifa 3: Oddiy filtr

Modellang:

  1. Shart
  2. Boolean
  3. Qatorlar
  4. Ajratish

Vazifa 4: Ko'p shart

Modellang:

  1. &
  2. |
  3. ~
  4. Qavs

Vazifa 5: isin/between

Modellang:

  1. isin
  2. Ro'yxat
  3. between
  4. Oraliq

Vazifa 6: Matn

Modellang:

  1. contains
  2. startswith
  3. len
  4. lower

Vazifa 7: O'ylash

Filtrlash Data Science'ning eng ko'p bajariladigan amallaridan biri, va Pandas uning uchun ko'p usul beradi (oddiy shart, isin, between, .str). Nima uchun bir xil natijaga ko'p yo'l bo'lishi (masalan between(18, 65) va (x>=18) & (x<=65)) foydali, va qanday qilib "o'qilishli kod" (isin, between) shunchaki "ishlaydigan kod" (uzun | zanjiri) dan muhimroq bo'lishi mumkin?

Javob

Qisqa javob: Filtrlash uchun ko'p usul (between va (x>=18)&(x<=65) bir natija) foydali, va o'qilishli kod (isin/between) ishlaydigan koddan (uzun |) muhimroq, chunki: (1) o'qilishlik — between(18, 65) aniq (o'qigan odam darrov tushunadi — oraliq); (x>=18) & (x<=65) ko'proq o'qish (chegaralar, operatorlar — sekinroq tushuniladi); isin([...]) maqsad (ro'yxatda — aniq); uzun | niyyat yashirin (nima tekshiriladi — o'qish kerak); (2) kod ko'proq o'qiladi — kod bir marta yoziladi, ko'p marta o'qiladi (o'zi keyin, jamoa, kelajakda); o'qilishli kod vaqt tejaydi (tez tushunish — debug, o'zgartirish); (3) xato kam — qisqa/aniq kod kam xato (uzun | — bir shart unutish, qavs xato; isin — bir amal, xato kam); (4) niyat — between/isin niyatni ko'rsatadi (oraliq, ro'yxat — nima qilinyapti); uzun | mexanikani (qanday — niyat noaniq). "Nega o'qilishlik > ishlaydigan": (a) qo'llab-quvvatlash — kod o'zgaradi (yangi shart, tuzatish — 6 oy keyin); o'qilishli oson (tushunib o'zgartirish), uzun/chalkash qiyin (qayta o'qish, xato); (b) jamoa — boshqalar o'qiydi (kod umumiy — jamoa tushunishi kerak; o'qilishli — hamkorlik); (c) o'z-o'zini hujjatlash — between/isin o'zi tushuntiradi (izoh kerak emas — nom aniq); uzun kod — izoh kerak (yoki chalkash); (d) kam xato — sodda kod (kam qism — kam xato joyi). "Nega ko'p yo'l foydali": turli kontekst (ba'zan between aniq — oraliq; ba'zan & moslashuvchan — murakkab shart; isin — ro'yxat); dasturchi eng aniqini tanlaydi (kontekstga — o'qilishli); ko'p yo'l moslashuvchanlik (har holatga mos). Saboqlar: o'qilishlik (aniq — tez tushunish); kod ko'p o'qiladi (bir marta yoz — o'qilishli tejaydi); niyat (between/isin — nima; uzun | — qanday); xato kam (sodda — kam xato). To'g'ri: o'qilishli usul (between/isin — aniq); ishlaydigan yetarli emas (o'qilishli ham). Muvozanat: ishlash (natija) + o'qilishlik (aniq) — ikkalasi, lekin o'qilishlik muhim (kod ko'p o'qiladi). Bu dasturlash donoligi ("kod odam uchun yoziladi, mashina uchun emas" — o'qilishlik; Python falsafa — "readability counts"). O'qilishli kod — professional (ishlaydigan — boshlanish; o'qilishli — usta).

1. Nega o'qilishlik foydali

  • Aniq (between — oraliq, tez tushunish)
  • Kod ko'p o'qiladi (bir marta yoz — o'qilishli tejaydi)
  • Xato kam (sodda — kam xato joyi)
  • Niyat (nima qilinyapti — aniq)

2. Nega o'qilishlik > ishlaydigan

  • Qo'llab-quvvatlash (o'zgartirish oson)
  • Jamoa (boshqalar o'qiydi)
  • O'z-o'zini hujjatlash (izoh kerak emas)
  • Kam xato (sodda)

3. Nega ko'p yo'l foydali

  • Turli kontekst (between oraliq, & murakkab, isin ro'yxat)
  • Eng aniqini tanlash (o'qilishli)
  • Moslashuvchanlik (har holatga)

4. O'qilishli vs uzun

O'qilishli Uzun/chalkash
between(18, 65) (x>=18)&(x<=65)
isin([...]) Uzun `
Niyat aniq Mexanika

5. Saboqlar

  1. O'qilishlik (aniq — tez tushunish)
  2. Kod ko'p o'qiladi (bir marta yoz)
  3. Niyat (between/isin — nima)
  4. Xato kam (sodda)

6. Xulosa

  1. O'qilishlik foydali (aniq, kam xato)
  2. Kod ko'p o'qiladi (o'qilishli tejaydi)
  3. Ko'p yo'l — kontekst (eng aniqini tanla)
  4. O'qilishli kod — professional (Python falsafa)

Nimani mustahkamlaydi: 2.6, 2.7-bo'limlar.

Xulosa

Bu darsda filtrlashni o'rgandik.

Eng muhim uch fikr:

  1. Oddiy va ko'p shart. Oddiy shart — df[df["yosh"] > 30] (boolean — shart bajargan qatorlar; NumPy 2.9 bilan bir xil g'oya). Ko'p shart — & (VA), | (YOKI), ~ (EMAS); qavs bilan ((shart1) & (shart2)); Python and/or ishlamaydi (Series — "truth value ambiguous"; &/|/~); & ustuvorlik (qavs shart).

  2. isin, between, matn. isin — qiymat ro'yxatda bor-mi (df[df["shahar"].isin([...])] — ko'p qiymat, == dan qisqa; ~isin inkor). between — oraliq (df[df["yosh"].between(18, 65)] — min-max, ikkalasi kiradi; >= VA <= qisqa). Matn filtri (.str) — startswith/contains/len/lower (matn bo'yicha — vektorlashtirilgan).

  3. Ma'lumotni ajratish. Filtrlash — ma'lumotni ajratish (butun ma'lumotdan kerakli qism — shart bo'yicha); Data Science'ning eng ko'p amali (deyarli har tahlil filtrdan). O'qilishli usul (isin/between) ishlaydigan koddan muhimroq (kod ko'p o'qiladi — Python "readability counts"). Data Science'da doim (tahlil — guruh; tozalash — noto'g'ri qatorlar 6-qism; ML — namuna). Tuzoqlar: and/or (&/|), qavs unutish, indeks tarqoq (reset_index), NaN (o'tkazib yuboriladi), SettingWithCopy (.loc).

Keyingi darsda ustunlar bilan ishlashni o'rganamiz: ustun qo'shish, o'chirish, nom o'zgartirish, tur o'zgartirish, apply — ustunlarni boshqarish.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
3.5-dars: Filtrlash — IlmHamroh