IlmHamroh
Python kursi/Malumot tahlili7/18-dars15 daqiqa
Mundarija (22)

24.7-dars: pandas — tanlash va filtrlash

24-QISM — MA'LUMOT TAHLILI · 7-dars

1. Kirish va motivatsiya

24.5–24.6 da DataFrame yaratdik va o'qidik. Endi tahlilning yuragi: kerakli ma'lumotni tanlash. Ma'lum qator (5-yozuv), ustun (narx), shartga mos qatorlar (100'dan qimmat mahsulotlar), ma'lum hujayra (Go narxi). Bu — pandas'da tanlash (selection) va filtrlash (filtering).

pandas ikki asosiy tanlash usuli beradi: loc (nom/belgi bilan — indeks va ustun nomi) va iloc (pozitsiya bilan — 0, 1, 2 raqami). Filtrlash — bool indeks (df[df.narx > 100] — shartga mos qatorlar), query (matn shart), isin (ro'yxatda), between (oraliq). Bu 24.3 (NumPy bool indeks) ning DataFrame versiyasi. Tanlash va filtrlash — ma'lumotdan xulosa chiqarishning birinchi qadami.

Real vaziyat. Bir tahlilda minglab tranzaksiyadan faqat "yirik summali va shubhali" larini topish kerak edi. Sikl va if bilan: uzun kod, sekin. pandas bool indeks bilan: df[(df.summa > 10000) & (df.status == "kutilmoqda")] — bir qatorda shartga mos hammasi. Filtrlash, tanlash — bir necha qatorda. Tahlilchi ma'lumotdan kerakli qismini tez ajratdi. Bool indeksni bilish — tahlilchining asosiy mahorati.

Bu darsda pandas tanlash va filtrlashni o'rganamiz.

Bu darsda:

  • loc (nom bilan)
  • iloc (pozitsiya bilan)
  • Bool indeks (filtr)
  • Bir necha shart (&, |)
  • isin, between
  • query (matn shart)
  • Shartli o'zgartirish (loc)
  • Amaliy: ma'lumot tanlash

ℹ Misollarda pandas (import pandas as pd) bilan sinaladi.

2. Nazariya — chuqur tushuntirish

2.1. loc (nom bilan)

loc — indeks va ustun nomi bilan:

python
df.loc["b", "nom"]         # qator "b", ustun "nom"
df.loc["b"]                # butun qator "b"
df.loc[:, "narx"]          # butun ustun "narx"
df.loc["a":"c"]            # qatorlar a dan c gacha (c KIRADI)
df.loc[["a", "c"], ["nom", "narx"]]  # ba'zi qator/ustun

loc — nom/belgi bilan tanlash: df.loc[qator_nomi, ustun_nomi]. df.loc["b", "nom"] (hujayra), df.loc["b"] (qator), df.loc[:, "narx"] (ustun). Kesish: df.loc["a":"c"] — locda oxiri kiradi (NumPy'dan farq!). Nomlangan indeks (sana, id) bilan ishlashda asosiy. Nom — o'qiluvchan 24.5-bob.

2.2. iloc (pozitsiya bilan)

iloc — pozitsiya (raqam) bilan:

python
df.iloc[0, 0]              # 0-qator, 0-ustun
df.iloc[2]                 # 2-qator (pozitsiya)
df.iloc[:, 1]              # 1-ustun (pozitsiya)
df.iloc[0:2]               # 0-1 qatorlar (2 KIRMAYDI)
df.iloc[[0, 2], [0, 1]]    # ba'zi pozitsiya

iloc — pozitsiya (0, 1, 2) bilan tanlash (NumPy kabi): df.iloc[qator_raqam, ustun_raqam]. df.iloc[0, 0] (birinchi hujayra), df.iloc[2] (uchinchi qator), df.iloc[:, 1] (ikkinchi ustun). Kesish: df.iloc[0:2] — oxiri kirmaydi (NumPy kabi). Indeks nomi noma'lum bo'lganda yoki pozitsiya kerak bo'lganda.

2.3. Bool indeks (filtr)

Shartga mos qatorlarni tanlash:

python
df[df["narx"] > 100]           # narx > 100 qatorlar
df[df["til"] == "uz"]          # til = uz
df["narx"] > 100               # bool Series (shart)

Bool indeks — shart bilan qator filtrlash (24.3 NumPy kabi): df[df["narx"] > 100] (narxi 100'dan katta qatorlar). Ichki df["narx"] > 100 — bool Series (har qator uchun True/False). Bu eng ko'p ishlatiladigan filtr usuli. Natija — shartga mos qatorlar (yangi DataFrame). Ma'lumot filtrlashning asosi.

2.4. Bir necha shart (&, |)

Murakkab shartlar:

python
df[(df["narx"] > 90) & (df["til"] == "uz")]   # VA
df[(df["narx"] < 90) | (df["narx"] > 140)]     # YOKI
df[~(df["til"] == "uz")]                        # EMAS (~)

Bir necha shart: & (VA), | (YOKI), ~ (EMAS) — qavs bilan ((df.narx > 90) & (df.til == "uz")), Python and/or emas (24.3 kabi). Har shart bool Series, &/| element-element birlashtiradi. Qavs muhim (& ustunligi yuqori). Real tahlilda ko'p shart (masalan, sana + summa + status).

2.5. isin, between

Foydali filtr metodlari:

python
df[df["til"].isin(["uz", "ru"])]     # ro'yxatda bor
df[df["narx"].between(90, 130)]       # oraliqda (ikkalasi kiradi)
df[df["nom"].str.startswith("P")]     # matn shart
df[df["nom"].str.contains("y")]       # ichida bor

Foydali filtrlar: .isin([ro'yxat]) (qiymat ro'yxatda bormi — ko'p == o'rniga), .between(a, b) (oraliqda — a <= x <= b), .str.startswith/.str.contains (matn shart — 04-qism satrlar). Bular ko'p shartni qisqartiradi (isin — ko'p | o'rniga). O'qiluvchan va qisqa.

2.6. query (matn shart)

Shartni matn sifatida:

python
df.query("narx > 100")
df.query("narx > 100 and til == 'uz'")
df.query("narx > @chegara")            # o'zgaruvchi (@)

query("shart") — shartni matn sifatida (SQL WHERE kabi): df.query("narx > 100"). Afzallik: qisqa, o'qiluvchan (and/or — Python kabi, qavs kam). @o'zgaruvchi — tashqi o'zgaruvchi. Bool indeksga muqobil — murakkab shartda o'qiluvchanroq. Ta'm masalasi (bool indeks yoki query).

2.7. Shartli o'zgartirish (loc)

loc bilan qiymat o'zgartirish:

python
df.loc[df["narx"] < 100, "narx"] = 99     # shartga mos narxni 99 ga
df.loc[df["til"] == "uz", "chegirma"] = 0.1  # yangi qiymat

Shartli o'zgartirish — df.loc[shart, ustun] = qiymat: df.loc[df["narx"] < 100, "narx"] = 99 (shartga mos qatorlarda narxni o'zgartir). loc bilan (muhim — df[shart]["ustun"] = ... SettingWithCopyWarning beradi, ishlamasligi mumkin). Bu ma'lumot tozalash 24.8-bob, toifalashda kerak. loc — xavfsiz o'zgartirish usuli.

2.8. loc vs iloc — qachan qaysi

Holat Usul
Nomlangan indeks (sana, id) loc
Pozitsiya (0, 1, 2) iloc
Shartli filtr Bool indeks / loc
Shartli o'zgartirish loc

loc — nom bilan (indeks/ustun nomi — o'qiluvchan, nomlangan ma'lumot); iloc — pozitsiya bilan (raqam — nom noma'lum bo'lganda). Filtr — bool indeks yoki loc[shart]. O'zgartirish — doim loc (xavfsiz). Qoida: nom bilan ishla (loc) — o'qiluvchan va ishonchli; pozitsiya faqat kerak bo'lganda (iloc). Bu 24.5 (nomlangan ma'lumot) tamoyilining davomi.

3. Tez ma'lumotnoma

python
import pandas as pd

# loc (nom bilan):
df.loc["b", "nom"]           # hujayra
df.loc["b"]                  # qator · df.loc[:, "narx"]  # ustun
df.loc["a":"c"]              # kesish (oxiri KIRADI)

# iloc (pozitsiya bilan):
df.iloc[0, 0]; df.iloc[2]; df.iloc[:, 1]
df.iloc[0:2]                 # kesish (oxiri KIRMAYDI)

# bool indeks (filtr):
df[df["narx"] > 100]
df[(df["narx"] > 90) & (df["til"] == "uz")]   # VA (& , qavs)
df[df["til"].isin(["uz", "ru"])]              # ro'yxatda
df[df["narx"].between(90, 130)]               # oraliq

# query:
df.query("narx > 100 and til == 'uz'")

# shartli o'zgartirish (loc bilan):
df.loc[df["narx"] < 100, "narx"] = 99

Tanlash xulosasi

loc: nom bilan (oxiri kiradi) · iloc: pozitsiya (oxiri kirmaydi)
bool: df[df.a>x] · &/|/~ (qavs) · isin/between · query (matn)
o'zgartirish: df.loc[shart, ustun] = qiymat

4. Batafsil misollar

Misollarda pandas (import pandas as pd) bilan sinaladi.

Misol 1 — loc va iloc

python
"""loc (nom bilan): hujayra, qator, ustun; iloc (pozitsiya bilan); kesish farqi."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    df = pd.DataFrame(
        {"nom": ["Python", "Go", "Rust", "PHP"], "narx": [100, 120, 150, 80]},
        index=["a", "b", "c", "d"],
    )

    print("=== 1. loc (nom bilan) ===")
    print(f"  df.loc['b','nom'] = {df.loc['b', 'nom']}")
    print(f"  df.loc['c','narx'] = {df.loc['c', 'narx']}")
    print(f"  df.loc['b'] (qator) = {df.loc['b'].to_dict()}")

    print("\n=== 2. iloc (pozitsiya bilan) ===")
    print(f"  df.iloc[0,0] = {df.iloc[0, 0]}")
    print(f"  df.iloc[2,1] = {df.iloc[2, 1]}")

    print("\n=== 3. Kesish farqi ===")
    print(f"  loc['a':'c'] (c KIRADI): {df.loc['a':'c'].index.tolist()}")
    print(f"  iloc[0:2] (2 KIRMAYDI): {df.iloc[0:2].index.tolist()}")

    print("\n=== 4. Ustun tanlash ===")
    print(f"  loc[:,'narx']: {df.loc[:, 'narx'].tolist()}")
    print(f"  iloc[:,0]: {df.iloc[:, 0].tolist()}")
    print("  ⭐ loc — nom (oxiri kiradi), iloc — pozitsiya (kirmaydi)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. loc (nom bilan) ===
  df.loc['b','nom'] = Go
  df.loc['c','narx'] = 150
  df.loc['b'] (qator) = {'nom': 'Go', 'narx': 120}

=== 2. iloc (pozitsiya bilan) ===
  df.iloc[0,0] = Python
  df.iloc[2,1] = 150

=== 3. Kesish farqi ===
  loc['a':'c'] (c KIRADI): ['a', 'b', 'c']
  iloc[0:2] (2 KIRMAYDI): ['a', 'b']

=== 4. Ustun tanlash ===
  loc[:,'narx']: [100, 120, 150, 80]
  iloc[:,0]: ['Python', 'Go', 'Rust', 'PHP']
  ⭐ loc — nom (oxiri kiradi), iloc — pozitsiya (kirmaydi)

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

Misol 2 — Bool indeks (filtr)

python
"""bool indeks: df[df.narx>100]; bir necha shart (&, |, ~); qavs bilan."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "nom": ["Python", "Go", "Rust", "PHP", "Ruby"],
        "narx": [100, 120, 150, 80, 90],
        "til": ["uz", "en", "en", "uz", "en"],
    })

    print("=== 1. Oddiy filtr (narx > 100) ===")
    print(f"  {df[df['narx'] > 100]['nom'].tolist()}")

    print("\n=== 2. VA (&) — ikki shart ===")
    r = df[(df["narx"] > 85) & (df["til"] == "en")]
    print(f"  narx>85 va til=en: {r['nom'].tolist()}")

    print("\n=== 3. YOKI (|) ===")
    r = df[(df["narx"] < 90) | (df["narx"] > 140)]
    print(f"  arzon yoki qimmat: {r['nom'].tolist()}")

    print("\n=== 4. EMAS (~) va sanash ===")
    r = df[~(df["til"] == "uz")]
    print(f"  uz emas: {r['nom'].tolist()}")
    print(f"  narx>100 soni: {(df['narx'] > 100).sum()}")
    print("  ⭐ bool indeks — shartga mos qatorlar (&/|/~, qavs)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Oddiy filtr (narx > 100) ===
  ['Go', 'Rust']

=== 2. VA (&) — ikki shart ===
  narx>85 va til=en: ['Go', 'Rust', 'Ruby']

=== 3. YOKI (|) ===
  arzon yoki qimmat: ['Rust', 'PHP']

=== 4. EMAS (~) va sanash ===
  uz emas: ['Go', 'Rust', 'Ruby']
  narx>100 soni: 2
  ⭐ bool indeks — shartga mos qatorlar (&/|/~, qavs)

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

Misol 3 — isin, between, query

python
"""isin (ro'yxatda); between (oraliq); query (matn shart); str metodlari."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "nom": ["Python", "Go", "Rust", "PHP", "Ruby"],
        "narx": [100, 120, 150, 80, 90],
        "til": ["uz", "en", "ru", "uz", "en"],
    })

    print("=== 1. isin (ro'yxatda) ===")
    r = df[df["til"].isin(["uz", "ru"])]
    print(f"  til uz yoki ru: {r['nom'].tolist()}")

    print("\n=== 2. between (oraliq) ===")
    r = df[df["narx"].between(90, 130)]
    print(f"  narx 90-130: {r['nom'].tolist()}")

    print("\n=== 3. query (matn shart) ===")
    r = df.query("narx > 100 and til == 'en'")
    print(f"  narx>100 va en: {r['nom'].tolist()}")

    print("\n=== 4. str metodlari (matn) ===")
    r = df[df["nom"].str.contains("y")]
    print(f"  nomida 'y': {r['nom'].tolist()}")
    print("  ⭐ isin/between/query/str — qulay filtr usullari")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. isin (ro'yxatda) ===
  til uz yoki ru: ['Python', 'Rust', 'PHP']

=== 2. between (oraliq) ===
  narx 90-130: ['Python', 'Go', 'Ruby']

=== 3. query (matn shart) ===
  narx>100 va en: ['Go']

=== 4. str metodlari (matn) ===
  nomida 'y': ['Python', 'Ruby']
  ⭐ isin/between/query/str — qulay filtr usullari

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

Misol 4 — Amaliy: buyurtmalar tahlili

Real misol: buyurtmalar jadvali — filtr (yirik buyurtmalar), shartli o'zgartirish (loc), tanlash, statistika. Bu — ma'lumot tanlash va o'zgartirishning namunasi.

python
"""to'liq tanlash: buyurtmalar, bool filtr, loc shartli o'zgartirish, isin, statistika."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "mijoz": ["Ali", "Vali", "Guli", "Ali", "Vali", "Sam"],
        "summa": [5000, 15000, 3000, 25000, 8000, 12000],
        "status": ["yakun", "kutilmoqda", "yakun", "kutilmoqda", "yakun", "kutilmoqda"],
    })

    print("=== 1. Yirik buyurtmalar (summa > 10000) ===")
    yirik = df[df["summa"] > 10000]
    print(f"  {yirik[['mijoz', 'summa']].to_dict(orient='records')}")

    print("\n=== 2. Yirik VA kutilmoqda (& shart) ===")
    r = df[(df["summa"] > 10000) & (df["status"] == "kutilmoqda")]
    print(f"  {r['mijoz'].tolist()}, jami: {r['summa'].sum()}")

    print("\n=== 3. Shartli o'zgartirish (loc — chegirma) ===")
    df["chegirma"] = 0
    df.loc[df["summa"] > 10000, "chegirma"] = 10       # yirikka 10%
    print(f"  chegirmalar: {df['chegirma'].tolist()}")

    print("\n=== 4. isin va statistika ===")
    faol = df[df["mijoz"].isin(["Ali", "Vali"])]
    print(f"  Ali+Vali buyurtmalar: {len(faol)}, jami: {faol['summa'].sum()}")
    print(f"  eng yirik: {df.loc[df['summa'].idxmax(), 'mijoz']}")
    print("  ⭐ filtr + loc o'zgartirish — ma'lumot tanlash amaliyoti")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Yirik buyurtmalar (summa > 10000) ===
  [{'mijoz': 'Vali', 'summa': 15000}, {'mijoz': 'Ali', 'summa': 25000}, {'mijoz': 'Sam', 'summa': 12000}]

=== 2. Yirik VA kutilmoqda (& shart) ===
  ['Vali', 'Ali', 'Sam'], jami: 52000

=== 3. Shartli o'zgartirish (loc — chegirma) ===
  chegirmalar: [0, 10, 0, 10, 0, 10]

=== 4. isin va statistika ===
  Ali+Vali buyurtmalar: 4, jami: 53000
  eng yirik: Ali
  ⭐ filtr + loc o'zgartirish — ma'lumot tanlash amaliyoti

Nima ko'rsatdi: 2.1–2.8-bo'limlar.

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

Noto'g'ri fikr To'g'risi
"loc = iloc" loc — nom, iloc — pozitsiya
"loc kesish oxiri kirmaydi" locda kiradi (iloc kirmaydi)
"and bilan shart" & (qavs bilan)
"df[shart][ustun]=x ishlaydi" loc (SettingWithCopy)
"isin — bir qiymat" Ro'yxat (ko'p ==)
"query sekin/keraksiz" O'qiluvchan (murakkab shart)
"Filtr aslni o'zgartiradi" Yangi DataFrame (nusxa)
"Pozitsiya doim ishlaydi" Nomlangan indeksda loc

6. Keng tarqalgan xatolar va yechimlari

1. and/or bool indeksda

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

2. Qavssiz &

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

3. df[shart][ustun] = x (chain)

python
df[df.a > 0]["b"] = 5            # ⚠️ SettingWithCopyWarning
df.loc[df.a > 0, "b"] = 5        # ✅

4. loc/iloc kesish chalkashtirish

python
df.loc["a":"c"]   # c KIRADI
df.iloc[0:3]      # 3 KIRMAYDI                # ✅ farqni bil

5. locga pozitsiya

python
df.loc[0]         # indeks "0" bo'lsa ok, aks holda xato
df.iloc[0]        # ✅ pozitsiya uchun

6. Ko'p == (isin o'rniga)

python
df[(df.til=="uz")|(df.til=="ru")]   # uzun
df[df.til.isin(["uz","ru"])]        # ✅ qisqa

7. Filtr natijasini asl deb o'ylash

python
df[df.a > 0]      # yangi DataFrame (asl o'zgarmaydi)
df = df[df.a > 0] # ✅ saqlash kerak bo'lsa

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 24.3-dars (o'tilgan): NumPy bool indeks — asos
  • 24.5-dars (o'tilgan): DataFrame — tanlash manbai
  • 24.8-dars: Tozalash — loc bilan o'zgartirish
  • 24.9-dars: Guruhlash — filtrlangan ma'lumot
  • 23-qism (o'tilgan): SQL WHERE — filtr o'xshashi

8. Eng yaxshi amaliyotlar

  1. Nom bilan — loc, pozitsiya — iloc.

  2. Filtr — bool indeks (df[df.a > x]).

  3. Ko'p shart — &/|/~ qavs bilan.

  4. O'zgartirish — doim loc (SettingWithCopy).

  5. Ko'p == o'rniga isin.

  6. Oraliq — between.

  7. Murakkab shart — query (o'qiluvchan).

  8. Filtr — nusxa (saqlash kerak bo'lsa tayinla).

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # loc nima?
2.  # iloc nima?
3.  # loc/iloc kesish farqi?
4.  # bool indeks nima?
5.  # & va | qanday?
6.  # ~ nima?
7.  # isin nima?
8.  # between nima?
9.  # query nima?
10. # shartli o'zgartirish?
11. # SettingWithCopy nima?
12. # filtr aslni o'zgartiradimi?
Javoblar
  1. Nom (belgi) bilan tanlash
  2. Pozitsiya (raqam) bilan tanlash
  3. loc oxiri kiradi, iloc kirmaydi
  4. Shartga mos qatorlarni tanlash
  5. VA / YOKI (qavs bilan)
  6. EMAS
  7. Ro'yxatda bormi
  8. Oraliqda (ikkalasi kiradi)
  9. Shartni matn sifatida
  10. df.loc[shart, ustun] = qiymat
  11. View'ga yozish ogohlantirishi
  12. Yo'q (yangi DataFrame)

Vazifa 2: Xatolarni tuzating

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

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

3.  df[df.a>0]["b"] = 5            # loc

4.  df.loc[0]  # pozitsiya kerak    # iloc

5.  df[(df.t=="uz")|(df.t=="ru")]  # isin
Javoblar
python
1.  df[(df.a>1) & (df.b<2)]

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

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

4.  df.iloc[0]

5.  df[df.t.isin(["uz", "ru"])]

Vazifa 3: loc/iloc

Tanlash:

  1. loc (nom)
  2. iloc (pozitsiya)
  3. Kesish farqi
  4. Ustun tanlash

Vazifa 4: Bool indeks

Filtr:

  1. Oddiy shart
  2. & (VA)
  3. | (YOKI)
  4. ~ (EMAS)

Vazifa 5: Metodlar

Filtr:

  1. isin
  2. between
  3. query
  4. str.contains

Vazifa 6: Amaliy

Tahlil:

  1. Filtr (bool)
  2. loc o'zgartirish
  3. isin
  4. Statistika

Vazifa 7: O'ylash

pandas ikki tanlash usuli beradi: loc (nom bilan — df.loc["2024-01", "narx"]) va iloc (pozitsiya bilan — df.iloc[0, 2]). Bool indeks filtrlash SQL WHERE'ga o'xshaydi. Nima uchun "nom bilan tanlash" (label-based) pozitsiyadan afzalroq (ko'p holda), va bu 24.5 dagi "nomlangan ma'lumot" tamoyilining davomi — nega df.loc[shart, ustun] = x df[shart][ustun] = x dan xavfsizroq?

Javob

Qisqa javob: loc (nom bilan) pozitsiyadan (iloc) afzalroq, chunki: o'qiluvchan (df.loc["2024-01", "narx"] — aniq; df.iloc[0, 2] — nima?), chidamli (ustun tartibi o'zgarsa, nom ishlaydi; pozitsiya buziladi). Bu 24.5 (nomlangan ma'lumot) davomi. df.loc[shart, ustun] = x df[shart][ustun] = x dan xavfsizroq, chunki: df[shart]["ustun"] = x ikki qadam (avval df[shart] — nusxa yoki view? noaniq; keyin unga yozish) — pandas ogohlantiradi (SettingWithCopyWarning) va ba'zan ishlamaydi (nusxaga yoziladi, asl o'zgarmaydi). df.loc[shart, ustun] = x — bir amal (aniq, ishonchli). "Aniq, bir amal" — noaniq, ikki qadamdan yaxshi.

1. Nom vs pozitsiya

iloc (pozitsiya) loc (nom)
df.iloc[0, 2] df.loc["a", "narx"]
"0, 2 nima?" aniq
Tartib o'zgarsa buziladi Nom ishlaydi

2. Chidamlik

Ustun qo'shilsa/tartib o'zgarsa: pozitsiya (iloc[:, 2]) — noto'g'ri ustun; nom (loc[:, "narx"]) — to'g'ri. Nom — o'zgarishga chidamli.

3. loc o'zgartirish xavfsizligi

df[shart]["ustun"] = x:

  • df[shart] — nusxa yoki view? (noaniq)
  • Unga yozish — nusxaga bo'lsa, asl o'zgarmaydi (jimgina xato!)
  • SettingWithCopyWarning ogohlantiradi

df.loc[shart, "ustun"] = x:

  • Bir amal (aniq)
  • Aslga yoziladi (ishonchli)

4. "Bir amal, aniq"

Ikki qadam (df[shart] keyin [ustun]=) — oraliqda noaniqlik (nusxa?). Bir amal (loc[shart, ustun]=) — aniq, ishonchli. "Aniq, atomik amal — noaniq, bosqichli emas".

5. Muhandislik saboqlari

  1. Nom — o'qiluvchan, chidamli (pozitsiya emas)
  2. loc o'zgartirish — bir amal (xavfsiz)
  3. Chain ([][]=) — noaniq (nusxa?)
  4. Nomlangan ma'lumot tamoyili 24.5-bob davomi

6. Xulosa

  1. loc (nom) — o'qiluvchan, chidamli
  2. iloc — faqat pozitsiya kerak bo'lganda
  3. df.loc[shart, ustun]=x — xavfsiz (bir amal)
  4. Chain — SettingWithCopy (noaniq)

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.

Xulosa

Bu darsda pandas tanlash va filtrlashni o'rgandik.

Eng muhim uch fikr:

  1. loc (nom) va iloc (pozitsiya). loc — indeks va ustun nomi bilan: df.loc[qator_nomi, ustun_nomi] (df.loc["b", "nom"] — hujayra, df.loc["b"] — qator, df.loc[:, "narx"] — ustun). Kesishda oxiri kiradi (df.loc["a":"c"] — c ham). iloc — pozitsiya (0, 1, 2) bilan (NumPy kabi): df.iloc[0, 0], df.iloc[2], kesishda oxiri kirmaydi. Qoida: nom bilan ishla (loc — o'qiluvchan, chidamli), pozitsiya faqat kerak bo'lganda (iloc).

  2. Bool indeks va filtr metodlari. Bool indeks — shart bilan qator filtrlash: df[df["narx"] > 100]. Bir necha shart: & (VA), | (YOKI), ~ (EMAS) — qavs bilan ((df.narx > 90) & (df.til == "uz")), Python and/or emas. Foydali metodlar: .isin([ro'yxat]) (ko'p == o'rniga), .between(a, b) (oraliq), .str.contains/.str.startswith (matn), query("narx > 100 and til == 'uz'") (matn shart — o'qiluvchan). Filtr — yangi DataFrame (asl o'zgarmaydi).

  3. Shartli o'zgartirish va loc xavfsizligi. Shartli o'zgartirish — df.loc[shart, ustun] = qiymat (df.loc[df["narx"] < 100, "narx"] = 99). loc bilan muhim: df[shart]["ustun"] = x (chain) SettingWithCopyWarning beradi va ba'zan ishlamaydi (nusxaga yoziladi) — df.loc[shart, ustun] = x bir amal (aniq, ishonchli). loc (nom bilan) pozitsiyadan afzalroq — o'qiluvchan (df.loc["2024-01", "narx"] vs df.iloc[0, 2]), chidamli (ustun tartibi o'zgarsa ishlaydi). Bu 24.5 (nomlangan ma'lumot) tamoyilining davomi — SQL WHERE'ga o'xshash filtr.

Keyingi darsda pandas: tozalash ni o'rganamiz: bo'sh qiymatlar, dublikatlar, noto'g'ri turlar — real "iflos" ma'lumotni tahlilga tayyorlash.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!