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

3.4-dars: Tanlash (loc va iloc)

3-QISM — PANDAS · 4-dars

1. Kirish va motivatsiya

DataFrame'dan ma'lumot olishning eng aniq va kuchli usuli — .loc va .iloc. NumPy'da a[1, 2] (qator, ustun) bor edi; Pandas'da bundan ham aniqroq ikkita usul: .loc (yorliq/nom bo'yicha — df.loc[0, "yosh"]) va .iloc (pozitsiya/raqam bo'yicha — df.iloc[0, 1]). Nima uchun ikkita? Chunki Pandas indeksi nom bo'lishi mumkin (masalan sana yoki ID), va shunda "0-qator" ikki ma'noli — nomi "0" bo'lgan qatormi yoki birinchi qatormi? .loc va .iloc bu chalkashlikni butunlay hal qiladi: .loc doim nom, .iloc doim pozitsiya. Nega muhim? (1) Aniqlik — chalkashliksiz tanlash (nom vs pozitsiya); (2) Kuch — qator, ustun, oraliq, shart — hammasi; (3) Xavfsizlik — o'zgartirishda .loc (SettingWithCopy oldini). Bu dars .loc va .iloc'ni chuqur o'rgatadi — ma'lumotga aniq kirish.

Tanlash (.loc/.iloc) — aniq kirish: .loc (yorliq/nom bo'yicha — df.loc[qator, ustun]), .iloc (pozitsiya/raqam bo'yicha — df.iloc[qator, ustun]), qator/ustun (bitta, ro'yxat, oraliq), shart bilan (.loc[shart] — filtr), o'zgartirish (.loc[shart, ustun] = qiymat — xavfsiz), farq (loc nom, iloc pozitsiya). Foydalanish: aniq tanlash, filtr, o'zgartirish. Bu 2.4 (NumPy indekslash), 3.5 (filtr) bilan bog'liq. loc — nom. iloc — pozitsiya. Aniq.

Real vaziyat. Data Scientist mijozlar DataFrame'i bilan ishlar edi (indeks — mijoz ID). Aniq qator kerak edi: ID 1005 mijoz — df.loc[1005] (nom bo'yicha — ID); birinchi 10 qator — df.iloc[:10] (pozitsiya). Aniq katak — df.loc[1005, "maosh"] (ID 1005 maoshi). Ustunlar — df.loc[:, ["ism", "yosh"]] (barcha qator, ikki ustun). Shart bilan — df.loc[df["yosh"] > 30, "maosh"] (30 dan katta mijozlar maoshi). O'zgartirish — df.loc[df["yosh"] < 18, "kategoriya"] = "yosh" (xavfsiz — SettingWithCopy yo'q). .loc/.iloc chalkashsiz tanladi (nom vs pozitsiya). Tanlash — aniq kirish (Pandas kuchi).

Bu darsda .loc va .iloc'ni o'rganamiz.

Bu darsda:

  • .loc (nom bo'yicha)
  • .iloc (pozitsiya bo'yicha)
  • Qator, ustun, katak
  • Shart bilan tanlash
  • Xavfsiz o'zgartirish
  • Tanlash amaliyoti
  • Tanlash tuzoqlari
  • Amaliy: tanlash modeli

ℹ Misollar real pandas bilan (deterministik) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. .loc (nom bo'yicha)

Yorliq/nom bo'yicha:

python
import pandas as pd

df = pd.DataFrame({
    "ism": ["Ali", "Vali", "Guli"],
    "yosh": [25, 30, 28],
}, index=["a", "b", "c"])

df.loc["a"]              # 'a' qator (Series)
df.loc["a", "yosh"]     # 'a' qator, yosh ustuni (25)
df.loc[["a", "c"]]      # 'a' va 'c' qatorlar
df.loc["a":"b"]         # 'a' dan 'b' gacha (loc — OXIRI KIRADI)

.loc (nom bo'yicha) — yorliq/indeks nom bo'yicha: df.loc["a"] (nomlangan qator — Series), df.loc["a", "yosh"] (qator × ustun — nom), df.loc[["a", "c"]] (ro'yxat), df.loc["a":"b"] (oraliq — OXIRI KIRADI, NumPy'dan farq!). Sabab: indeks nom bo'lsa (ID, sana — mazmunli) nom bilan kirish (df.loc[1005] — ID 1005); .loc doim nom (yorliq — chalkashsiz). MUHIM: .loc oraliqda oxiri kiradi ("a":"b" — a, b ikkalasi; NumPy/iloc — oxiri kirmaydi). loc — nom bo'yicha (df.loc[nom, ustun]). Oxiri kiradi. Yorliq.

2.2. .iloc (pozitsiya bo'yicha)

Pozitsiya/raqam bo'yicha:

python
df = pd.DataFrame({
    "ism": ["Ali", "Vali", "Guli"],
    "yosh": [25, 30, 28],
}, index=["a", "b", "c"])

df.iloc[0]              # 0-qator (birinchi — pozitsiya)
df.iloc[0, 1]          # 0-qator, 1-ustun (25)
df.iloc[[0, 2]]        # 0 va 2 qatorlar
df.iloc[0:2]           # 0-1 qator (iloc — OXIRI KIRMAYDI)

.iloc (pozitsiya bo'yicha) — raqam/o'rin bo'yicha: df.iloc[0] (birinchi qator — pozitsiya), df.iloc[0, 1] (qator × ustun — raqam), df.iloc[[0, 2]] (ro'yxat), df.iloc[0:2] (oraliq — OXIRI KIRMAYdI, NumPy kabi). Sabab: ba'zan pozitsiya kerak (birinchi 10 — df.iloc[:10]; oxirgi — df.iloc[-1]; indeksdan qat'i nazar); .iloc doim pozitsiya (0 dan — NumPy kabi, chalkashsiz). .iloc oraliq oxiri kirmaydi (0:2 — 0,1; NumPy/slice kabi — 2.4). iloc — pozitsiya bo'yicha (df.iloc[raqam, ustun]). Oxiri kirmaydi. 0 dan.

2.3. Qator, ustun, katak

Turli tanlovlar:

python
df = pd.DataFrame({"ism": ["Ali", "Vali"], "yosh": [25, 30], "shahar": ["T", "S"]})

# QATOR
df.loc[0]                    # bitta qator
df.loc[[0, 1]]               # ko'p qator

# USTUN (loc bilan)
df.loc[:, "yosh"]            # bitta ustun (: barcha qator)
df.loc[:, ["ism", "yosh"]]   # ko'p ustun

# KATAK (aniq)
df.loc[0, "yosh"]            # aniq qiymat (25)

# QATOR × USTUN blok
df.loc[[0, 1], ["ism", "yosh"]]

Qator, ustun, katak — turli tanlovlar: qator (df.loc[0] bitta, df.loc[[0, 1]] ko'p), ustun (df.loc[:, "yosh"] — : barcha qator, bitta ustun; df.loc[:, ["a", "b"]] ko'p), katak (df.loc[0, "yosh"] — aniq qiymat), blok (df.loc[[0, 1], ["a", "b"]] — qator × ustun). Sabab: ma'lumotga turli darajada kirish (bir qator — namuna; bir ustun — xususiyat; katak — aniq qiymat; blok — qism jadval); : (barcha — NumPy kabi 2.4). .loc[qator, ustun] (ikki o'lcham — nom). Qator/ustun/katak — .loc[qator, ustun] (: barcha). Turli daraja. Blok.

2.4. Shart bilan tanlash

.loc + shart (filtr):

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

# SHART bilan (boolean — 2.9 kabi)
df.loc[df["yosh"] > 30]                 # 30 dan katta qatorlar
df.loc[df["yosh"] > 30, "ism"]          # ular ismi (shart + ustun)
df.loc[(df["yosh"] > 25) & (df["yosh"] < 35)]   # &, | (qavs!)

Shart bilan tanlash — .loc + boolean (filtr): df.loc[df["yosh"] > 30] (shart bajargan qatorlar — boolean 2.9), df.loc[df["yosh"] > 30, "ism"] (shart + ustun — qaysi qator, qaysi ustun), df.loc[(shart1) & (shart2)] (&/| — qavs bilan, NumPy 2.9). Sabab: ko'pincha shart bo'yicha tanlash (30 dan katta mijozlar; oraliq — filtr) va ustun (ularning ismi — shart + ustun); .loc ikkisini birlashtiradi (.loc[shart, ustun]). Bu 3.5 (filtr) asosi. &/| (qavs — NumPy kabi). Shart bilan — .loc[shart, ustun] (filtr). Boolean. Ustun.

2.5. Xavfsiz o'zgartirish

Xavfsiz o'zgartirish — .loc bilan (SettingWithCopy oldini): df.loc[shart, ustun] = qiymat (shart bajarganlarni o'zgartir — xavfsiz):

python
df = pd.DataFrame({"ism": ["Ali", "Vali"], "yosh": [15, 30]})

# XATO usul (SettingWithCopyWarning)
df[df["yosh"] < 18]["kategoriya"] = "yosh"   # ogohlantirish!

# TO'G'RI usul (.loc)
df.loc[df["yosh"] < 18, "kategoriya"] = "yosh"   # xavfsiz

Sabab: DataFrame'ni zanjirlab o'zgartirish (df[shart]["ustun"] = ...) view/copy noaniq (SettingWithCopyWarning — o'zgartirmaydi yoki ogohlantiradi; 2.13 tuzoq); .loc bir amalda (df.loc[shart, ustun] = ... — aniq, xavfsiz). Bu Pandas'ning eng ko'p ogohlantirishi (SettingWithCopy — chalkash). Yechim: doim .loc o'zgartirishda (zanjir emas). Xavfsiz o'zgartirish — .loc[shart, ustun] = ... (SettingWithCopy oldini). Aniq. Xavfsiz.

2.6. Tanlash amaliyoti

Tanlash amaliyoti: .loc (nom — indeks/ustun nomi); .iloc (pozitsiya — raqam, 0 dan); qator/ustun/katak (.loc[qator, ustun]); : (barcha — df.loc[:, "ustun"]); shart (.loc[shart, ustun] — filtr, boolean 2.9); o'zgartirish (.loc[shart, ustun] = ... — xavfsiz); oraliq (loc oxiri kiradi, iloc kirmaydi); ro'yxat (.loc[["a", "b"]]). Tuzoqlar: loc vs iloc (nom vs pozitsiya — chalkash), oraliq (loc oxiri kiradi, iloc kirmaydi), SettingWithCopy (.loc bilan o'zgartir), zanjir (df[..][..] — noaniq). Amaliyot — loc/iloc, qator/ustun, shart, o'zgartirish. Nom vs pozitsiya. Aniq.

2.7. Tanlash tuzoqlari

Tanlash asosiy tuzoqlari: loc vs iloc chalkash (.loc nom, .iloc pozitsiya; indeks raqam bo'lsa .loc[0] va .iloc[0] turlicha bo'lishi mumkin — indeks [5, 6, 7] bo'lsa .loc[5] birinchi, .iloc[5] xato); oraliq oxiri (.loc["a":"c"] — c kiradi; .iloc[0:3] — 3 kirmaydi; NumPy'dan farq — chalkash); SettingWithCopyWarning (zanjir df[shart]["ustun"] = ... — ogohlantirish, o'zgartmaydi; .loc[shart, ustun] = ...); df[0] xato (df[0] — ustun nomi kutadi, 0 ustun yo'q — xato; qator uchun .iloc[0]); indeks reset (filtrdan keyin indeks tarqoq (0, 2, 5) — .iloc pozitsiya, .loc nom; reset_index kerak bo'lsa); skalyar vs Series (.loc[0, "ustun"] skalyar, .loc[0] Series — o'lcham); at/iat (bitta katak — .at/.iat tezroq, lekin .loc/.iloc yetadi). Sabab: tanlash nom/pozitsiya/oraliq nozik (loc vs iloc, oxiri, SettingWithCopy — jim xato yoki chalkash). Yechim: .loc nom, .iloc pozitsiya, .loc o'zgartirish. Tuzoqlar — loc/iloc, oraliq oxiri, SettingWithCopy.

2.8. Tanlash — ma'lumotga aniq kirish

Tanlash asosiy g'oyasi — ma'lumotga aniq kirish: DataFrame'dan qator/ustun/katak olish — chalkashsiz; .loc (nom bo'yicha — indeks/ustun nomi, df.loc["a", "yosh"]) va .iloc (pozitsiya bo'yicha — raqam, 0 dan — df.iloc[0, 1]). Ikki usul nega: Pandas indeksi nom bo'lishi mumkin (ID, sana — mazmunli); "0-qator" ikki ma'no (nomi "0"-mi yoki birinchi-mi); .loc/.iloc bu chalkashni hal qiladi (loc doim nom, iloc doim pozitsiya). Qator/ustun/katak/blok (.loc[qator, ustun], : barcha), shart (.loc[shart, ustun] — filtr 3.5), xavfsiz o'zgartirish (.loc[shart, ustun] = ... — SettingWithCopy oldini). Data Science'da doim tanlash (aniq qator/ustun — tahlil, tozalash, ML tayyorgarlik). Bu 2.4 (NumPy indekslash) davomi va 3.5 (filtr), butun Pandas uchun. Tanlash — ma'lumotga aniq kirish (.loc nom, .iloc pozitsiya). Aniq. Chalkashsiz.

3. Tez ma'lumotnoma

python
import pandas as pd
df = pd.DataFrame({"ism": ["Ali","Vali"], "yosh": [25,30]}, index=["a","b"])

# .loc (NOM bo'yicha):
df.loc["a"]              # qator (nom)
df.loc["a", "yosh"]      # katak (qator, ustun)
df.loc[:, "yosh"]        # ustun (: barcha qator)
df.loc["a":"b"]          # oraliq (OXIRI KIRADI)

# .iloc (POZITSIYA bo'yicha):
df.iloc[0]               # qator (0-birinchi)
df.iloc[0, 1]            # katak (raqam)
df.iloc[0:2]             # oraliq (OXIRI KIRMAYDI)

# SHART bilan (.loc):
df.loc[df["yosh"] > 25]              # filtr
df.loc[df["yosh"] > 25, "ism"]       # shart + ustun

# XAVFSIZ O'ZGARTIRISH (.loc):
df.loc[df["yosh"] < 18, "kat"] = "yosh"   # SettingWithCopy oldini

QOIDA: .loc nom (oxiri kiradi) · .iloc pozitsiya (oxiri kirmaydi) · .loc o'zgartir

Tanlash xulosasi

Tanlash — ma'lumotga aniq kirish (.loc nom, .iloc pozitsiya)
.loc — yorliq/nom (df.loc[nom, ustun], oxiri KIRADI)
.iloc — pozitsiya/raqam (df.iloc[raqam, ustun], oxiri kirmaydi)
Shart — .loc[shart, ustun] (filtr, boolean)
Xavfsiz — .loc[shart, ustun] = qiymat (SettingWithCopy oldini)

4. Batafsil misollar

Misollar real pandas bilan (deterministik) ishlaydi.

Misol 1 — .loc (nom bo'yicha)

python
"""'.loc': nom bo'yicha (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "ism": ["Ali", "Vali", "Guli"],
        "yosh": [25, 30, 28],
    }, index=["a", "b", "c"])

    print("=== 1. Qator (nom) ===")
    print(f"  df.loc['a'] ism: {df.loc['a', 'ism']}")

    print("\n=== 2. Katak ===")
    print(f"  df.loc['b', 'yosh']: {df.loc['b', 'yosh']}")

    print("\n=== 3. Ro'yxat ===")
    print(f"  df.loc[['a','c']] ismlar: {list(df.loc[['a', 'c'], 'ism'])}")

    print("\n=== 4. Oraliq (oxiri KIRADI) ===")
    print(f"  df.loc['a':'b'] qatorlar: {len(df.loc['a':'b'])} (a va b)")
    print("  ⭐ .loc — nom bo'yicha (oxiri kiradi)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Qator (nom) ===
  df.loc['a'] ism: Ali

=== 2. Katak ===
  df.loc['b', 'yosh']: 30

=== 3. Ro'yxat ===
  df.loc[['a','c']] ismlar: ['Ali', 'Guli']

=== 4. Oraliq (oxiri KIRADI) ===
  df.loc['a':'b'] qatorlar: 2 (a va b)
  ⭐ .loc — nom bo'yicha (oxiri kiradi)

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — .iloc (pozitsiya bo'yicha)

python
"""'.iloc': pozitsiya bo'yicha (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "ism": ["Ali", "Vali", "Guli"],
        "yosh": [25, 30, 28],
    }, index=["a", "b", "c"])

    print("=== 1. Qator (pozitsiya) ===")
    print(f"  df.iloc[0] ism: {df.iloc[0]['ism']} (birinchi)")

    print("\n=== 2. Katak (raqam) ===")
    print(f"  df.iloc[1, 1]: {df.iloc[1, 1]} (1-qator, 1-ustun)")

    print("\n=== 3. Oxirgi (-1) ===")
    print(f"  df.iloc[-1] ism: {df.iloc[-1]['ism']}")

    print("\n=== 4. Oraliq (oxiri KIRMAYDI) ===")
    print(f"  df.iloc[0:2] qatorlar: {len(df.iloc[0:2])} (0 va 1)")
    print("  ⭐ .iloc — pozitsiya bo'yicha (oxiri kirmaydi)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Qator (pozitsiya) ===
  df.iloc[0] ism: Ali (birinchi)

=== 2. Katak (raqam) ===
  df.iloc[1, 1]: 30 (1-qator, 1-ustun)

=== 3. Oxirgi (-1) ===
  df.iloc[-1] ism: Guli

=== 4. Oraliq (oxiri KIRMAYDI) ===
  df.iloc[0:2] qatorlar: 2 (0 va 1)
  ⭐ .iloc — pozitsiya bo'yicha (oxiri kirmaydi)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — Shart bilan tanlash

python
"""Shart bilan tanlash (real pandas)."""

import pandas as pd


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

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

    print("\n=== 2. Shart + ustun ===")
    print(f"  ular ismi: {list(df.loc[df['yosh'] > 30, 'ism'])}")

    print("\n=== 3. Ikki shart (&) ===")
    orta = df.loc[(df["yosh"] > 25) & (df["yosh"] < 40)]
    print(f"  25-40: {list(orta['ism'])}")

    print("\n=== 4. Katak (shart) ===")
    print(f"  eng yosh max: {df.loc[df['yosh'] < 30, 'yosh'].max()}")
    print("  ⭐ Shart bilan — .loc[shart, ustun] (filtr)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Shart (filtr) ===
  30 dan katta: ['Vali', 'Hasan']

=== 2. Shart + ustun ===
  ular ismi: ['Vali', 'Hasan']

=== 3. Ikki shart (&) ===
  25-40: ['Vali', 'Guli']

=== 4. Katak (shart) ===
  eng yosh max: 28
  ⭐ Shart bilan — .loc[shart, ustun] (filtr)

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — Xavfsiz o'zgartirish

python
"""Xavfsiz o'zgartirish: .loc (real pandas)."""

import pandas as pd


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

    print("=== 1. .loc bilan o'zgartirish ===")
    df.loc[df["yosh"] < 18, "kategoriya"] = "yosh"
    df.loc[df["yosh"] >= 18, "kategoriya"] = "katta"
    print(f"  kategoriyalar: {list(df['kategoriya'])}")

    print("\n=== 2. Katak o'zgartirish ===")
    df.loc[0, "yosh"] = 16
    print(f"  0-qator yosh: {df.loc[0, 'yosh']}")

    print("\n=== 3. Ustun hisoblash ===")
    df.loc[:, "yosh_2x"] = df["yosh"] * 2
    print(f"  yosh_2x: {list(df['yosh_2x'])}")

    print("\n=== 4. Xavfsizlik ===")
    print("  .loc — SettingWithCopy oldini (aniq)")
    print("  ⭐ Xavfsiz o'zgartirish — .loc[shart, ustun] = ...")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. .loc bilan o'zgartirish ===
  kategoriyalar: ['yosh', 'katta', 'yosh']

=== 2. Katak o'zgartirish ===
  0-qator yosh: 16

=== 3. Ustun hisoblash ===
  yosh_2x: [32, 60, 34]

=== 4. Xavfsizlik ===
  .loc — SettingWithCopy oldini (aniq)
  ⭐ Xavfsiz o'zgartirish — .loc[shart, ustun] = ...

Nima ko'rsatdi: 2.5-bo'lim.

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

Noto'g'ri fikr To'g'risi
".loc va .iloc bir xil" loc nom, iloc pozitsiya
".loc oxiri kirmaydi" Kiradi (iloc kirmaydi)
"df[0] — birinchi qator" Xato (df.iloc[0])
"o'zgartirish df[..][..]" .loc (SettingWithCopy)
".loc[0] — birinchi" Nom "0" (iloc[0] birinchi)
".iloc nom qabul qiladi" Faqat pozitsiya (raqam)
"shart faqat filtr" .loc[shart, ustun] ham
"loc/iloc keraksiz" Aniqlik (chalkashsiz)

6. Keng tarqalgan xatolar va yechimlari

1. loc vs iloc

python
df.loc[0]   # nom "0" (indeks raqam bo'lmasa xato)            # ⚠️
df.iloc[0]   # pozitsiya (doim birinchi)                       # ✅

2. Oraliq oxiri

python
df.loc["a":"c"]   # c KIRADI (kutilmasligi mumkin)            # ⚠️
df.iloc[0:3]   # 3 kirmaydi (NumPy kabi)                       # ✅

3. SettingWithCopy

python
df[df.yosh < 18]["kat"] = "yosh"   # ogohlantirish            # ⚠️
df.loc[df.yosh < 18, "kat"] = "yosh"   # .loc                 # ✅

4. df[0]

python
df[0]   # ustun "0" kutadi (xato)                             # ⚠️
df.iloc[0]   # qator                                           # ✅

5. Filtrdan keyin indeks

python
df2 = df[df.yosh > 25]; df2.iloc[0]   # pozitsiya (indeks tarqoq) # ⚠️
df2 = df2.reset_index(drop=True)   # indeks tiklash            # ✅

6. Skalyar vs Series

python
df.loc[0]   # Series (butun qator)                           # ⚠️
df.loc[0, "yosh"]   # skalyar (bitta qiymat)                  # ✅

7. iloc nom

python
df.iloc["a"]   # xato (iloc — raqam)                          # ⚠️
df.loc["a"]   # nom                                            # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 2.4-dars (o'tilgan): NumPy indekslash
  • 3.5-dars: Filtrlash (.loc + shart)
  • 3.7-dars: Yo'q qiymatlar (.loc bilan to'ldirish)
  • 6-qism: Tozalash (.loc bilan o'zgartirish)
  • 20-qism: ML (X, y tanlash — .loc/.iloc)

8. Eng yaxshi amaliyotlar

  1. .loc — nom, .iloc — pozitsiya (aniq).

  2. .loc oraliq oxiri kiradi, .iloc kirmaydi.

  3. .loc[shart, ustun] — shart + ustun.

  4. .loc bilan o'zgartir (SettingWithCopy oldini).

  5. df.iloc[0] — birinchi qator (df[0] emas).

  6. : — barcha (df.loc[:, "ustun"]).

  7. Filtrdan keyin reset_index (kerak bo'lsa).

  8. Tanlash — ma'lumotga aniq kirish.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # .loc nima?
2.  # .iloc nima?
3.  # nega ikkita?
4.  # .loc oraliq oxiri?
5.  # .iloc oraliq oxiri?
6.  # df.loc[0, "yosh"]?
7.  # df[0]?
8.  # shart bilan?
9.  # xavfsiz o'zgartirish?
10. # SettingWithCopy?
11. # : nima?
12. # nega aniqlik muhim?
Javoblar
  1. Nom bo'yicha tanlash
  2. Pozitsiya bo'yicha tanlash
  3. Nom vs pozitsiya (chalkashsiz)
  4. Kiradi
  5. Kirmaydi (NumPy kabi)
  6. Katak (0-qator, yosh)
  7. Xato (df.iloc[0])
  8. .loc[shart, ustun]
  9. .loc[shart, ustun] = ...
  10. Zanjir o'zgartirish ogohlantirishi
  11. Barcha (qator/ustun)
  12. Chalkashsiz tanlash (nom vs pozitsiya)

Vazifa 2: Xatolarni tuzating

python
1.  df.loc[0]   # birinchi qator (indeks raqam emas)

2.  df.loc["a":"c"]   # c kirmasin

3.  df[df.yosh < 18]["kat"] = "yosh"

4.  df[0]   # birinchi qator

5.  df.iloc["a"]   # nom
Javoblar
python
1.  df.iloc[0]   # pozitsiya

2.  df.iloc[0:2] yoki nom aniq

3.  df.loc[df.yosh < 18, "kat"] = "yosh"

4.  df.iloc[0]

5.  df.loc["a"]

Vazifa 3: .loc

Modellang:

  1. Nom
  2. Qator
  3. Ustun
  4. Oxiri kiradi

Vazifa 4: .iloc

Modellang:

  1. Pozitsiya
  2. Raqam
  3. 0 dan
  4. Oxiri kirmaydi

Vazifa 5: Shart

Modellang:

  1. Filtr
  2. Shart + ustun
  3. &, |
  4. Boolean

Vazifa 6: O'zgartirish

Modellang:

  1. .loc
  2. Xavfsiz
  3. SettingWithCopy
  4. Aniq

Vazifa 7: O'ylash

Pandas'da .loc (nom) va .iloc (pozitsiya) ikkita alohida tanlash usuli bor, NumPy'da esa faqat bitta (a[0] — pozitsiya). Nima uchun Pandas bu ikkita usulni ajratdi (nega bitta yetarli emas), va bu qanday qilib "indeks nom bo'lishi mumkin" degan Pandas xususiyati bilan bog'liq?

Javob

Qisqa javob: Pandas .loc (nom) va .iloc (pozitsiya) ajratdi, NumPy faqat pozitsiya — sabab indeks nom bo'lishi mumkin: (1) NumPy — faqat pozitsiya — NumPy indeks doim 0,1,2 (pozitsiya — nomi yo'q); a[0] aniq (birinchi — chalkash yo'q); bitta usul yetadi (faqat pozitsiya); (2) Pandas — nom + pozitsiya — Pandas indeks nom bo'lishi mumkin (ID, sana — index=["a", "b"] yoki [1005, 1006]); endi ikki ma'no (df[5] — nomi "5"-mi yoki 5-pozitsiya-mi?); noaniq; (3) ajratish hal qiladi — .loc (doim nom — df.loc[1005] ID 1005), .iloc (doim pozitsiya — df.iloc[5] 6-qator); chalkash yo'q (aniq — qaysi usul bilsa o'sha). "Nega bitta yetarli emas": (a) noaniqlik — indeks raqam bo'lsa ([5, 6, 7]) df[5] — nomi "5" (birinchi) yoki pozitsiya 5 (xato — yo'q)? noaniq; ikki usul kerak (aniqlik); (b) turli maqsad — ba'zan nom kerak (ID 1005 — mazmunli; .loc), ba'zan pozitsiya (birinchi 10 — .iloc[:10]; indeksdan qat'i nazar); ikki ehtiyoj; (c) indeks o'zgaradi — filtr/saralashdan keyin indeks tarqoq (0, 2, 5 — 3.5); .iloc[0] (birinchi — pozitsiya, doim ishlaydi), .loc[0] (nomi "0" — bor-yo'qligi noaniq); ikki usul turli holatda. "Indeks nom bilan bog'liq": Pandas nomlangan indeks (mazmunli — ID, sana; NumPy'dan farq — 3.1); nomlangan indeks kuch (mazmunli kirish — df.loc["2024-01-01"]), lekin ajratish talab qiladi (nom vs pozitsiya — .loc/.iloc); NumPy nomsiz (faqat pozitsiya — bitta usul yetadi). Saboqlar: NumPy pozitsiya (bitta usul); Pandas nom + pozitsiya (ikki usul — .loc/.iloc); ajratish aniqlik (chalkash yo'q); nomlangan indeks sababi (mazmun — ID/sana). To'g'ri: .loc nom (mazmunli — ID), .iloc pozitsiya (o'rin — birinchi); doim aniq usul. Muvozanat: kuch (nomlangan indeks — mazmun) + aniqlik (ajratish — .loc/.iloc) — ikkalasi; nomlangan indeks kuch beradi (mazmun), ajratish chalkashni oldini oladi. Bu Pandas dizayn (nomlangan indeks — kuch; .loc/.iloc — aniqlik); NumPy soddaroq (nomsiz — bitta usul), Pandas kuchliroq (nom — ikki usul).

1. Nega NumPy bitta usul

  • Indeks doim pozitsiya (0,1,2 — nomsiz)
  • a[0] aniq (birinchi — chalkash yo'q)
  • Bitta usul yetadi

2. Nega Pandas ikki usul

  • Indeks nom bo'lishi mumkin (ID, sana)
  • df[5] noaniq (nom "5" yoki pozitsiya?)
  • .loc nom, .iloc pozitsiya (aniq)

3. Nega bitta yetarli emas

  • Noaniqlik (raqam indeks — nom yoki pozitsiya?)
  • Turli maqsad (nom — ID; pozitsiya — birinchi 10)
  • Indeks tarqoq (filtrdan keyin — .iloc pozitsiya)

4. Indeks nom bilan bog'liq

NumPy Pandas
Nomsiz (pozitsiya) Nomlangan (ID, sana)
Bitta usul (a[0]) Ikki usul (.loc/.iloc)

5. Saboqlar

  1. NumPy pozitsiya (bitta usul)
  2. Pandas nom + pozitsiya (ikki usul)
  3. Ajratish — aniqlik (chalkash yo'q)
  4. Nomlangan indeks sababi (mazmun)

6. Xulosa

  1. NumPy — pozitsiya (nomsiz — bitta usul)
  2. Pandas — nom bo'lishi mumkin (ikki usul)
  3. .loc/.iloc — aniqlik (chalkash yo'q)
  4. Nomlangan indeks — kuch + ajratish

Nimani mustahkamlaydi: 2.1, 2.2-bo'limlar.

Xulosa

Bu darsda .loc va .iloc'ni o'rgandik.

Eng muhim uch fikr:

  1. .loc va .iloc. .loc — nom bo'yicha tanlash (yorliq/indeks nom — df.loc["a", "yosh"]); oraliq oxiri KIRADI ("a":"b" — a, b ikkalasi). .iloc — pozitsiya bo'yicha (raqam, 0 dan — df.iloc[0, 1]); oraliq oxiri KIRMAYdI (0:2 — 0,1; NumPy kabi). Ikki usul nega: Pandas indeksi nom bo'lishi mumkin (ID/sana — "0-qator" ikki ma'no); .loc/.iloc chalkashni hal qiladi.

  2. Qator, ustun, shart. Qator/ustun/katak — .loc[qator, ustun] (bitta, ro'yxat, oraliq, blok); : (barcha — df.loc[:, "ustun"]). Shart bilan — .loc[df["yosh"] > 30, "ism"] (shart + ustun — filtr, boolean 2.9; &/| qavs bilan); 3.5 (filtr) asosi.

  3. Xavfsiz va aniq. Xavfsiz o'zgartirish — .loc[shart, ustun] = qiymat (SettingWithCopy oldini — zanjir df[..][..] = ogohlantirish beradi, .loc aniq/xavfsiz). Tanlash — ma'lumotga aniq kirish (.loc nom, .iloc pozitsiya — chalkashsiz); Data Science'da doim (qator/ustun — tahlil, tozalash, ML). NumPy bitta usul (nomsiz — pozitsiya), Pandas ikki usul (nomlangan indeks — nom + pozitsiya). Tuzoqlar: loc vs iloc (nom vs pozitsiya), oraliq oxiri (loc kiradi, iloc kirmaydi), SettingWithCopy (.loc), df[0] xato (.iloc[0]).

Keyingi darsda filtrlashni o'rganamiz: shart bo'yicha qatorlarni tanlash (df[df["yosh"] > 18]), ko'p shart, isin, between — real ma'lumotni ajratish.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
3.4-dars: Tanlash (loc va iloc) — IlmHamroh