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

3.8-dars: Guruhlash (groupby)

3-QISM — PANDAS · 8-dars

1. Kirish va motivatsiya

Data Science tahlilining eng kuchli vositasi — guruhlash (groupby). "Har shahar bo'yicha o'rtacha maosh", "har kategoriya bo'yicha jami savdo", "har oy bo'yicha mijozlar soni". Bu — ma'lumotni guruhlarga bo'lib, har guruh uchun statistika hisoblash. Excel'dagi pivot jadval, SQL'dagi GROUP BY — Pandas'da bu groupby. G'oya oddiy va kuchli: bo'l — hisobla — birlashtir (split-apply-combine): ma'lumotni ustun bo'yicha guruhlarga bo'l, har guruhga funksiya (mean, sum, count) qo'lla, natijalarni bir jadvalga birlashtir. Nega muhim? (1) Taqqoslash — guruhlarni solishtirish (Toshkent vs Samarqand); (2) Xulosa — katta ma'lumotdan guruh darajasidagi ma'no; (3) Naqsh topish — kategoriyalar bo'yicha farqlar. groupby — Data Science tahlilning yuragi. Bu dars guruhlashni o'rgatadi — guruh darajasidagi tahlil.

Guruhlash (groupby) — guruhlarga bo'lib hisob: groupby (ustun bo'yicha guruh — df.groupby("shahar")), agregatsiya (guruhga funksiya — mean/sum/count/max), split-apply-combine (bo'l-hisobla-birlashtir), ko'p ustun (groupby(["shahar", "jins"])), agg (bir nechta funksiya), guruh soni (count/size), filtrlangan guruh. Foydalanish: guruh tahlil, taqqoslash, xulosa. Bu 2.8 (NumPy agregatsiya), 3.5 (filtr) bilan bog'liq. groupby — bo'l-hisobla-birlashtir. Guruh. Tahlil.

Real vaziyat. Data Scientist do'kon savdo ma'lumoti bilan ishlar edi (shahar, kategoriya, summa — 10000 qator). Savollarga javob kerak edi: har shahar bo'yicha jami savdo — df.groupby("shahar")["summa"].sum(); har kategoriya o'rtacha narx — df.groupby("kategoriya")["narx"].mean(); har shahar × kategoriya — df.groupby(["shahar", "kategoriya"])["summa"].sum(); guruh soni — df.groupby("shahar").size(). groupby bo'l-hisobla-birlashtir qildi (10000 qator → shahar darajasidagi xulosa — 5 shahar, jami savdo). Guruhlash naqshni ochdi (Toshkent eng ko'p, elektronika eng qimmat). groupby — Data Science tahlil yuragi (guruh darajasidagi ma'no).

Bu darsda groupby'ni o'rganamiz.

Bu darsda:

  • groupby (bo'l-hisobla-birlashtir)
  • Agregatsiya (mean, sum, count)
  • Ko'p ustun bo'yicha
  • agg (bir nechta funksiya)
  • Guruhlangan natija bilan ishlash
  • groupby amaliyoti
  • groupby tuzoqlari
  • Amaliy: guruh modeli

ℹ Misollar real pandas bilan (deterministik) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. groupby (bo'l-hisobla-birlashtir)

Guruhlarga bo'lib hisob:

python
import pandas as pd

df = pd.DataFrame({
    "shahar": ["T", "S", "T", "S", "T"],
    "summa": [100, 200, 150, 250, 120],
})

# groupby — ustun bo'yicha guruh + funksiya
df.groupby("shahar")["summa"].sum()
# shahar
# S    450   (200 + 250)
# T    370   (100 + 150 + 120)

# G'OYA: bo'l (shahar) — hisobla (sum) — birlashtir (jadval)

groupby (bo'l-hisobla-birlashtir) — guruhlarga bo'lib hisob: df.groupby("shahar")["summa"].sum() (shahar bo'yicha guruh, summani yig'). G'oya — split-apply-combine: (1) bo'l (split — shahar bo'yicha guruhlar: T, S), (2) hisobla (apply — har guruhga funksiya: sum), (3) birlashtir (combine — natijalar bir jadvalda). Sabab: guruh darajasidagi xulosa (har shahar jami — 10000 qator → 5 shahar; naqsh); groupby buni avtomatik (bo'l-hisobla-birlashtir). Natija — Series (indeks — guruhlar). groupby — bo'l-hisobla-birlashtir (groupby("ustun")["ustun"].funksiya). Guruh. Xulosa.

2.2. Agregatsiya (mean, sum, count)

Guruhga funksiya:

python
df = pd.DataFrame({
    "shahar": ["T", "S", "T", "S"],
    "summa": [100, 200, 150, 250],
})

df.groupby("shahar")["summa"].sum()     # jami
df.groupby("shahar")["summa"].mean()    # o'rtacha
df.groupby("shahar")["summa"].count()   # soni (NaN emas)
df.groupby("shahar")["summa"].max()     # eng katta
df.groupby("shahar").size()             # guruh o'lchami

Agregatsiya (mean, sum, count) — guruhga funksiya: groupby("shahar")["summa"].sum() (jami), .mean() (o'rtacha), .count() (soni — NaN emas), .max()/.min() (chegara), .size() (guruh o'lchami — barcha qator, NaN ham). Sabab: har guruh uchun statistika (jami savdo, o'rtacha narx, mijoz soni — 2.8 agregatsiya, lekin guruh bo'yicha); funksiya har guruhga alohida. sum/mean/count/max (2.8 kabi). count (NaN emas), size (barcha — NaN ham). Agregatsiya — guruhga funksiya (sum/mean/count). Statistika. Guruh.

2.3. Ko'p ustun bo'yicha

Bir nechta ustunda guruh:

python
df = pd.DataFrame({
    "shahar": ["T", "T", "S", "S"],
    "jins": ["M", "F", "M", "F"],
    "summa": [100, 150, 200, 250],
})

# ko'p ustun (ro'yxat)
df.groupby(["shahar", "jins"])["summa"].sum()
# shahar  jins
# S       F       250
#         M       200
# T       F       150
#         M       100

Ko'p ustun bo'yicha — bir nechta ustunda guruh: df.groupby(["shahar", "jins"])["summa"].sum() (shahar × jins — har kombinatsiya: T-M, T-F, S-M, S-F). Sabab: ba'zan ko'p o'lchamli guruh (har shahar VA har jins — batafsil tahlil; Toshkent erkaklar, Toshkent ayollar); groupby([...]) ro'yxat bilan (ko'p ustun). Natija — ko'p darajali indeks (MultiIndex — shahar, jins). Batafsil (kombinatsiyalar). Ko'p ustun — groupby([...]) (kombinatsiya). Ko'p o'lcham. MultiIndex.

2.4. agg (bir nechta funksiya)

Bir vaqtda ko'p funksiya:

python
df = pd.DataFrame({"shahar": ["T", "S", "T"], "summa": [100, 200, 150]})

# agg — bir nechta funksiya
df.groupby("shahar")["summa"].agg(["sum", "mean", "count"])
#         sum   mean  count
# shahar
# S       200  200.0      1
# T       250  125.0      2

# har ustunga boshqa funksiya
df.groupby("shahar").agg({"summa": "sum", "narx": "mean"})

agg (bir nechta funksiya) — bir vaqtda ko'p statistika: df.groupby("shahar")["summa"].agg(["sum", "mean", "count"]) (jami, o'rtacha, soni — bir jadvalda), df.groupby("shahar").agg({"summa": "sum", "narx": "mean"}) (har ustunga boshqa funksiya — dict). Sabab: ko'pincha bir nechta statistika kerak (jami VA o'rtacha VA soni — bir marta); agg ro'yxat (bir ustun, ko'p funksiya) yoki dict (har ustun, o'z funksiya). Bir amalda to'liq xulosa (batafsil hisobot). agg — ko'p funksiya (ro'yxat/dict). Bir amalda. To'liq.

2.5. Guruhlangan natija bilan ishlash

Guruhlangan natija bilan ishlash — natija Series/DataFrame: groupby natijasi (indeks — guruhlar) — saralash (.sort_values() — eng ko'p/kam), filtr ([natija > 100] — shart), reset_index (indeks → ustun — oddiy DataFrame), vizualizatsiya (grafik — 5-qism). Sabab: guruh natijasi tayyor emas (xom xulosa — tartiblash, filtr, ko'rsatish kerak); natija oddiy Series/DataFrame (barcha amallar ishlaydi — sort, filter). reset_index (guruh indeks → ustun — CSV/grafik uchun); sort_values (reyting — eng ko'p savdo shahar). Guruh natija — Series/DataFrame (sort/filter/reset_index). Xulosa. Tayyorlash.

2.6. groupby amaliyoti

groupby amaliyoti: groupby("ustun") (guruh — bo'l); agregatsiya (sum/mean/count/size — hisobla); ko'p ustun (groupby([...]) — kombinatsiya); agg (ko'p funksiya — ro'yxat/dict); natija (sort/filter/reset_index — tayyorlash); size vs count (size — barcha, count — NaN emas); saralash (sort_values — reyting). Tuzoqlar: size vs count (NaN), MultiIndex (ko'p ustun — reset_index), NaN guruh (o'tkaziladi), natija Series (reset_index), sekin (katta ma'lumot — samaradorlik). Amaliyot — groupby, agregatsiya, ko'p ustun, agg. Bo'l-hisobla-birlashtir. Guruh.

2.7. groupby tuzoqlari

groupby asosiy tuzoqlari: size vs count (size — guruh barcha qator (NaN ham); count — NaN emas qiymatlar; farqli — NaN bo'lsa); MultiIndex (ko'p ustun groupby([...]) — natija ko'p darajali indeks; kirish/CSV qiyin; reset_index() — oddiy ustun); NaN guruh (guruhlash ustunida NaN — o'tkazib yuboriladi (guruh emas); dropna=False bilan saqlash); natija Series (groupby(...).sum() — Series (indeks guruh); DataFrame kerak bo'lsa reset_index()); guruh ustunini tanlash (groupby("a")["b"].sum() — b hisoblanadi; groupby("a").sum() — barcha son ustun); saralanmagan (natija guruh nom bo'yicha; reyting uchun sort_values); agg nom (agg(["sum", "mean"]) — ustun nomi funksiya; noaniq bo'lsa agg(jami=("summa", "sum"))). Sabab: groupby natija/NaN/indeks nozik (size/count, MultiIndex, NaN — jim xato yoki chalkash). Yechim: size/count farqi, reset_index, dropna=False, sort_values. Tuzoqlar — size/count, MultiIndex, NaN, natija.

2.8. groupby — guruh darajasidagi tahlil

groupby asosiy g'oyasi — guruh darajasidagi tahlil: katta ma'lumotni guruhlarga bo'lib (shahar, kategoriya, oy) har guruh uchun statistika (o'rtacha, jami, soni); Data Science tahlilining eng kuchli vositasi (Excel pivot, SQL GROUP BY). G'oya — split-apply-combine (bo'l — guruhlar; hisobla — funksiya; birlashtir — jadval). groupby (guruh), agregatsiya (sum/mean/count — 2.8, lekin guruh bo'yicha), ko'p ustun (kombinatsiya — MultiIndex), agg (ko'p funksiya). Natija — guruh darajasidagi xulosa (10000 qator → 5 shahar; taqqoslash, naqsh). Data Science'da doim (guruhlarni solishtirish — Toshkent vs Samarqand; kategoriya farqi; oy bo'yicha trend). Bu 2.8 (agregatsiya) davomi (guruh bo'yicha) va 3.13 (pivot), butun tahlil uchun. groupby — guruh darajasidagi tahlil (bo'l-hisobla-birlashtir). Eng kuchli. Xulosa.

3. Tez ma'lumotnoma

python
import pandas as pd

# groupby (bo'l-hisobla-birlashtir):
df.groupby("shahar")["summa"].sum()     # har shahar jami
df.groupby("shahar")["summa"].mean()    # o'rtacha
df.groupby("shahar")["summa"].count()   # soni (NaN emas)
df.groupby("shahar").size()             # guruh o'lchami (barcha)

# KO'P USTUN (kombinatsiya, MultiIndex):
df.groupby(["shahar", "jins"])["summa"].sum()

# agg (bir nechta funksiya):
df.groupby("shahar")["summa"].agg(["sum", "mean", "count"])
df.groupby("shahar").agg({"summa": "sum", "narx": "mean"})

# NATIJA BILAN ISHLASH:
natija = df.groupby("shahar")["summa"].sum()
natija.sort_values(ascending=False)      # reyting
natija.reset_index()                      # ustunga (DataFrame)

QOIDA: bo'l-hisobla-birlashtir · size (barcha) count (NaN emas) · reset_index

groupby xulosasi

groupby — guruh darajasidagi tahlil (bo'l-hisobla-birlashtir)
Split-apply-combine — bo'l (guruh) → hisobla (funksiya) → birlashtir
Agregatsiya — sum/mean/count/size (guruh bo'yicha)
Ko'p ustun — groupby([...]) (kombinatsiya, MultiIndex)
agg — ko'p funksiya (ro'yxat/dict) · reset_index (DataFrame)

4. Batafsil misollar

Misollar real pandas bilan (deterministik) ishlaydi.

Misol 1 — groupby asoslari

python
"""groupby: bo'l-hisobla-birlashtir (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "shahar": ["T", "S", "T", "S", "T"],
        "summa": [100, 200, 150, 250, 120],
    })

    print("=== 1. Jami (sum) ===")
    print(f"  {df.groupby('shahar')['summa'].sum().to_dict()}")

    print("\n=== 2. O'rtacha (mean) ===")
    print(f"  {df.groupby('shahar')['summa'].mean().to_dict()}")

    print("\n=== 3. Soni (count) ===")
    print(f"  {df.groupby('shahar')['summa'].count().to_dict()}")

    print("\n=== 4. Guruh o'lchami (size) ===")
    print(f"  {df.groupby('shahar').size().to_dict()}")
    print("  ⭐ groupby — bo'l-hisobla-birlashtir")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Jami (sum) ===
  {'S': 450, 'T': 370}

=== 2. O'rtacha (mean) ===
  {'S': 225.0, 'T': 123.33333333333333}

=== 3. Soni (count) ===
  {'S': 2, 'T': 3}

=== 4. Guruh o'lchami (size) ===
  {'S': 2, 'T': 3}
  ⭐ groupby — bo'l-hisobla-birlashtir

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

Misol 2 — Ko'p ustun bo'yicha

python
"""Ko'p ustun bo'yicha guruhlash (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "shahar": ["T", "T", "S", "S"],
        "jins": ["M", "F", "M", "F"],
        "summa": [100, 150, 200, 250],
    })

    print("=== 1. Shahar × jins ===")
    natija = df.groupby(["shahar", "jins"])["summa"].sum()
    print(f"  T-M: {natija[('T', 'M')]}, S-F: {natija[('S', 'F')]}")

    print("\n=== 2. Guruhlar soni ===")
    print(f"  guruhlar: {len(natija)}")

    print("\n=== 3. reset_index (DataFrame) ===")
    tekis = natija.reset_index()
    print(f"  ustunlar: {list(tekis.columns)}")

    print("\n=== 4. Faqat shahar ===")
    print(f"  shahar jami: {df.groupby('shahar')['summa'].sum().to_dict()}")
    print("  ⭐ Ko'p ustun — kombinatsiya (MultiIndex)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Shahar × jins ===
  T-M: 100, S-F: 250

=== 2. Guruhlar soni ===
  guruhlar: 4

=== 3. reset_index (DataFrame) ===
  ustunlar: ['shahar', 'jins', 'summa']

=== 4. Faqat shahar ===
  shahar jami: {'S': 450, 'T': 250}
  ⭐ Ko'p ustun — kombinatsiya (MultiIndex)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — agg (ko'p funksiya)

python
"""agg: ko'p funksiya (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "shahar": ["T", "S", "T", "S", "T"],
        "summa": [100, 200, 150, 250, 120],
    })

    print("=== 1. Ro'yxat (bir ustun) ===")
    natija = df.groupby("shahar")["summa"].agg(["sum", "mean", "count"])
    print(f"  T jami: {natija.loc['T', 'sum']}, T o'rtacha: {natija.loc['T', 'mean']}")

    print("\n=== 2. Min va max ===")
    n2 = df.groupby("shahar")["summa"].agg(["min", "max"])
    print(f"  T min: {n2.loc['T', 'min']}, T max: {n2.loc['T', 'max']}")

    print("\n=== 3. Nomlangan agg ===")
    n3 = df.groupby("shahar")["summa"].agg(jami="sum", ortacha="mean")
    print(f"  ustunlar: {list(n3.columns)}")

    print("\n=== 4. Ustunlar ===")
    print(f"  agg ustunlari: {list(natija.columns)}")
    print("  ⭐ agg — bir nechta funksiya (ro'yxat/dict)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Ro'yxat (bir ustun) ===
  T jami: 370, T o'rtacha: 123.33333333333333

=== 2. Min va max ===
  T min: 100, T max: 150

=== 3. Nomlangan agg ===
  ustunlar: ['jami', 'ortacha']

=== 4. Ustunlar ===
  agg ustunlari: ['sum', 'mean', 'count']
  ⭐ agg — bir nechta funksiya (ro'yxat/dict)

Nima ko'rsatdi: 2.4-bo'lim.

Misol 4 — Natija bilan ishlash (reyting)

python
"""Guruh natijasi: reyting (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "shahar": ["T", "S", "B", "T", "S", "B", "T"],
        "summa": [100, 200, 50, 150, 250, 80, 120],
    })

    print("=== 1. Har shahar jami ===")
    jami = df.groupby("shahar")["summa"].sum()
    print(f"  {jami.to_dict()}")

    print("\n=== 2. Reyting (sort) ===")
    reyting = jami.sort_values(ascending=False)
    print(f"  eng ko'p: {reyting.index[0]} ({reyting.iloc[0]})")

    print("\n=== 3. Filtr (> 200) ===")
    print(f"  200 dan katta: {list(jami[jami > 200].index)}")

    print("\n=== 4. reset_index ===")
    tekis = jami.reset_index()
    print(f"  DataFrame ustunlari: {list(tekis.columns)}")
    print("  ⭐ Natija — sort/filter/reset_index (tayyorlash)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. Har shahar jami ===
  {'B': 130, 'S': 450, 'T': 370}

=== 2. Reyting (sort) ===
  eng ko'p: S (450)

=== 3. Filtr (> 200) ===
  200 dan katta: ['S', 'T']

=== 4. reset_index ===
  DataFrame ustunlari: ['shahar', 'summa']
  ⭐ Natija — sort/filter/reset_index (tayyorlash)

Nima ko'rsatdi: 2.5-bo'lim.

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

Noto'g'ri fikr To'g'risi
"groupby — filtr" Guruhlab hisoblash
"size va count bir xil" size barcha, count NaN emas
"groupby natija tayyor" Sort/reset_index kerak
"ko'p ustun oddiy indeks" MultiIndex
"NaN guruh bo'ladi" O'tkaziladi (dropna=False saqlaydi)
"agg bitta funksiya" Ko'p funksiya (ro'yxat/dict)
"natija DataFrame" Series (reset_index → DataFrame)
"groupby saralaydi" Nom bo'yicha (sort_values kerak)

6. Keng tarqalgan xatolar va yechimlari

1. size vs count

python
df.groupby("a")["b"].count()   # NaN emas qiymatlar          # ⚠️
df.groupby("a").size()   # barcha qator (NaN ham)             # ✅

2. MultiIndex

python
df.groupby(["a", "b"]).sum()   # MultiIndex (kirish qiyin)   # ⚠️
df.groupby(["a", "b"]).sum().reset_index()   # oddiy ustun    # ✅

3. NaN guruh

python
df.groupby("shahar").sum()   # NaN shahar o'tkaziladi        # ⚠️
df.groupby("shahar", dropna=False).sum()   # NaN saqlanadi    # ✅

4. Natija Series

python
natija = df.groupby("a")["b"].sum()   # Series               # ⚠️
natija.reset_index()   # DataFrame (CSV/grafik)               # ✅

5. Saralanmagan

python
df.groupby("a")["b"].sum()   # nom bo'yicha (reyting emas)    # ⚠️
df.groupby("a")["b"].sum().sort_values(ascending=False)       # ✅

6. Ustun tanlash

python
df.groupby("a").sum()   # barcha son ustun                   # ⚠️
df.groupby("a")["b"].sum()   # faqat b                        # ✅

7. agg nom noaniq

python
df.groupby("a")["b"].agg(["sum", "sum"])   # takror nom       # ⚠️
df.groupby("a")["b"].agg(jami="sum", o="mean")   # nomlangan  # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 2.8-dars (o'tilgan): NumPy agregatsiya (mean, sum)
  • 3.5-dars (o'tilgan): Filtrlash
  • 3.13-dars: Pivot (guruhlash — jadval)
  • 4-qism: Statistika (guruhlarni solishtirish)
  • 5-qism: Vizualizatsiya (guruh natijasi — grafik)

8. Eng yaxshi amaliyotlar

  1. groupby("ustun")["ustun"].funksiya (guruh + hisob).

  2. sum/mean/count — guruh statistikasi.

  3. size (barcha) vs count (NaN emas).

  4. Ko'p ustun — groupby([...]) (kombinatsiya).

  5. agg — ko'p funksiya (ro'yxat/dict).

  6. reset_index — DataFrame (natija bilan ishlash).

  7. sort_values — reyting.

  8. groupby — guruh darajasidagi tahlil.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # groupby nima?
2.  # split-apply-combine?
3.  # agregatsiya nima?
4.  # size vs count?
5.  # ko'p ustun?
6.  # MultiIndex nima?
7.  # agg nima?
8.  # natija Series yoki DataFrame?
9.  # reset_index nima uchun?
10. # NaN guruh?
11. # saralash?
12. # nega groupby kuchli?
Javoblar
  1. Guruhlab hisoblash
  2. Bo'l-hisobla-birlashtir
  3. Guruhga funksiya (sum/mean)
  4. size barcha, count NaN emas
  5. groupby([...]) (kombinatsiya)
  6. Ko'p darajali indeks
  7. Ko'p funksiya (ro'yxat/dict)
  8. Series (reset_index → DataFrame)
  9. Guruh indeks → ustun
  10. O'tkaziladi (dropna=False saqlaydi)
  11. sort_values (reyting)
  12. Guruh darajasidagi tahlil (taqqoslash)

Vazifa 2: Xatolarni tuzating

python
1.  df.groupby("a")["b"].count()   # barcha kerak

2.  df.groupby(["a","b"]).sum()   # oddiy ustun

3.  df.groupby("s").sum()   # NaN shahar

4.  natija = df.groupby("a")["b"].sum()   # DataFrame kerak

5.  df.groupby("a")["b"].sum()   # reyting
Javoblar
python
1.  df.groupby("a").size()

2.  ....reset_index()

3.  dropna=False

4.  ....reset_index()

5.  ....sort_values(ascending=False)

Vazifa 3: groupby

Modellang:

  1. Bo'l
  2. Hisobla
  3. Birlashtir
  4. Guruh

Vazifa 4: Agregatsiya

Modellang:

  1. sum
  2. mean
  3. count
  4. size

Vazifa 5: Ko'p ustun

Modellang:

  1. Ro'yxat
  2. Kombinatsiya
  3. MultiIndex
  4. reset_index

Vazifa 6: agg

Modellang:

  1. Ro'yxat
  2. Dict
  3. Ko'p funksiya
  4. Nomlangan

Vazifa 7: O'ylash

groupby "split-apply-combine" (bo'l-hisobla-birlashtir) naqshiga asoslanadi. Nima uchun bu uch bosqichli fikrlash Data Science'da shunchalik kuchli va universal (SQL GROUP BY, Excel pivot, MapReduce — hammasi shu naqsh), va nega u "har guruh uchun alohida hisoblash"ni sikl yozmasdan qiladi?

Javob

Qisqa javob: "Split-apply-combine" (bo'l-hisobla-birlashtir) kuchli va universal, chunki: (1) tabiiy fikrlash — inson guruh bo'yicha o'ylaydi ("har shahar qancha sotdi" — tabiiy savol); split-apply-combine bu savolni to'g'ridan ifodalaydi (bo'l — shaharlar; hisobla — savdo; birlashtir — jadval); (2) umumiy naqsh — ko'p vazifa shu shakl (har guruh statistikasi — savdo, foydalanuvchi, vaqt); bir naqsh ko'p holatga (universal); (3) ajratilgan bosqichlar — bo'l (guruhlash mantiqi), hisobla (funksiya), birlashtir (yig'ish) — mustaqil (har birini alohida o'ylash — sodda; funksiya o'zgaradi — sum/mean/count); (4) ekotizim — SQL (GROUP BY), Excel (pivot), Pandas (groupby), MapReduce (katta ma'lumot) — hammasi shu naqsh (bir fikrlash — ko'p vosita); o'rgangan bir marta — hamma joyda. "Nega sikl yozmasdan": (a) deklarativ — split-apply-combine nima kerak (guruh, funksiya — natija), qanday emas (sikl, indeks — mexanika); foydalanuvchi niyat (Pandas mexanikani bajaradi); (b) abstraksiya — "har guruh uchun" yashirin (Pandas guruhlarni topadi, sikl ichida bajaradi — foydalanuvchi ko'rmaydi); sikl qo'lda (guruhlarni top, har biriga funksiya, natija yig' — ko'p kod, xato); (c) vektorlashtirilgan — Pandas ichda tez (C — 2.12; qo'l sikl sekin); (d) o'qilishli — groupby("shahar")["summa"].sum() bir qator (niyat aniq); sikl 10 qator (chalkash). "Nega uch bosqich":

  • bo'l (split) — ma'lumotni guruhlarga (mantiqiy bo'linish — shahar, kategoriya);
  • hisobla (apply) — har guruhga mustaqil funksiya (sum, mean — o'zgaruvchan);
  • birlashtir (combine) — natijalar bir jadvalda (xulosa). Ajratish moslashuvchan (funksiya o'zgaradi — sum yoki mean; bir naqsh). Saboqlar: split-apply-combine tabiiy (guruh bo'yicha fikrlash); universal (SQL/Excel/Pandas — bir naqsh); deklarativ (nima — sikl emas); ajratilgan bosqich (mustaqil — moslashuvchan). To'g'ri: guruh bo'yicha o'yla (split-apply-combine); groupby (Pandas — sikl emas). Muvozanat: soddalik (deklarativ — niyat) + kuch (ko'p funksiya, katta ma'lumot) — ikkalasi. Bu Data Science asosiy naqsh (guruh tahlil — hamma joyda; bir marta o'rgan — universal). "Bo'l-hisobla-birlashtir" — fikrlash usuli (nafaqat Pandas — SQL, Excel, katta ma'lumot).

1. Nega naqsh kuchli

  • Tabiiy fikrlash (guruh bo'yicha savol)
  • Umumiy naqsh (ko'p vazifa — bir shakl)
  • Ajratilgan bosqich (mustaqil — moslashuvchan)
  • Ekotizim (SQL/Excel/Pandas — bir naqsh)

2. Nega sikl yozmasdan

  • Deklarativ (nima — qanday emas)
  • Abstraksiya ("har guruh" yashirin)
  • Vektorlashtirilgan (tez — C)
  • O'qilishli (bir qator — niyat)

3. Uch bosqich

Bosqich Ish
Bo'l (split) Guruhlarga (shahar)
Hisobla (apply) Funksiya (sum)
Birlashtir (combine) Jadval (xulosa)

4. Universal (bir naqsh)

Vosita Shakl
SQL GROUP BY
Excel Pivot
Pandas groupby
Katta ma'lumot MapReduce

5. Saboqlar

  1. Split-apply-combine tabiiy (guruh fikrlash)
  2. Universal (SQL/Excel/Pandas)
  3. Deklarativ (nima — sikl emas)
  4. Ajratilgan bosqich (moslashuvchan)

6. Xulosa

  1. Naqsh kuchli (tabiiy, universal)
  2. Sikl yozmasdan (deklarativ — niyat)
  3. Uch bosqich (bo'l-hisobla-birlashtir)
  4. Fikrlash usuli (hamma joyda)

Nimani mustahkamlaydi: 2.1, 2.8-bo'limlar.

Xulosa

Bu darsda groupby'ni o'rgandik.

Eng muhim uch fikr:

  1. groupby va agregatsiya. groupby — guruhlarga bo'lib hisob: df.groupby("shahar")["summa"].sum() (shahar bo'yicha guruh, summani yig'). G'oya — split-apply-combine (bo'l — guruhlar; hisobla — funksiya; birlashtir — jadval). Agregatsiya — sum/mean/count/max (2.8, lekin guruh bo'yicha), size (barcha — NaN ham), count (NaN emas). Guruh darajasidagi statistika.

  2. Ko'p ustun va agg. Ko'p ustun — df.groupby(["shahar", "jins"]) (kombinatsiya — T-M, T-F, ...; MultiIndex — ko'p darajali; reset_index oddiy). agg — bir nechta funksiya: agg(["sum", "mean", "count"]) (ro'yxat — bir ustun), agg({"summa": "sum", "narx": "mean"}) (dict — har ustun boshqa); bir amalda to'liq xulosa.

  3. Guruh darajasidagi tahlil. Natija bilan ishlash — groupby natijasi Series (indeks guruh); sort_values (reyting — eng ko'p), [natija > 100] (filtr), reset_index (DataFrame — CSV/grafik). groupby — guruh darajasidagi tahlil (bo'l-hisobla-birlashtir — eng kuchli vosita; Excel pivot, SQL GROUP BY); guruhlarni solishtirish (Toshkent vs Samarqand), naqsh topish. Split-apply-combine universal (SQL/Excel/Pandas — bir naqsh; deklarativ — sikl emas). Tuzoqlar: size/count (NaN), MultiIndex (reset_index), NaN guruh (dropna=False), natija Series, saralanmagan (sort_values).

Keyingi darsda birlashtirish (merge, concat)ni o'rganamiz: ikki DataFrame'ni birlashtirish (SQL JOIN kabi) — turli manbalardagi ma'lumotni bir jadvalga yig'ish.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
3.8-dars: Guruhlash (groupby) — IlmHamroh