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

3.13-dars: Pivot va reshape

3-QISM — PANDAS · 13-dars

1. Kirish va motivatsiya

Ma'lumot ikki asosiy shaklda bo'ladi: uzun (long — har qator bir kuzatish: shahar, oy, savdo) va keng (wide — shaharlar qator, oylar ustun, kataklar savdo). Ba'zan bir shakldan boshqasiga o'tish kerak: tahlil uchun uzun qulay (groupby), taqdimot/jadval uchun keng chiroyli (Excel pivot). Bu — pivot (uzun → keng) va melt (keng → uzun). pivot_table — Excel'dagi pivot jadval (guruhlab, jadval shaklida), melt — ustunlarni qatorga aylantirish. Nega muhim? (1) Taqdimot — keng jadval o'qilishli (matritsa ko'rinishi); (2) Tahlil — uzun shakl qulay (groupby, filtr); (3) Moslik — turli vositalar turli shakl talab qiladi. Bu dars pivot va reshape'ni o'rgatadi — jadval shaklini o'zgartirish.

Pivot va reshape — jadval shaklini o'zgartirish: uzun vs keng (long — qator kuzatish; wide — matritsa), pivot_table (uzun → keng — guruhlab jadval; Excel pivot), pivot (oddiy — agregatsiyasiz), melt (keng → uzun — ustun → qator), stack/unstack (indeks ↔ ustun), agregatsiya (aggfunc — pivot_table ichida). Foydalanish: taqdimot (keng), tahlil (uzun), moslik. Bu 3.8 (groupby), 2.7 (reshape) bilan bog'liq. pivot — uzun→keng. melt — keng→uzun. Shakl.

Real vaziyat. Data Scientist savdo ma'lumoti bilan ishlar edi (uzun shakl: shahar, oy, savdo — har qator bir kuzatish). Taqdimot uchun keng jadval kerak edi (shaharlar qator, oylar ustun — matritsa, o'qilishli): df.pivot_table(index="shahar", columns="oy", values="savdo", aggfunc="sum") (Excel pivot kabi — shahar × oy, katak savdo). Aksincha: tashqi keng ma'lumot keldi (oylar ustun), tahlil uchun uzun kerak edi (groupby) — df.melt(id_vars="shahar", var_name="oy", value_name="savdo") (keng → uzun). Pivot/melt jadval shaklini o'zgartirdi (taqdimot ↔ tahlil). pivot_table — Data Science taqdimot va tahlil vositasi.

Bu darsda pivot va reshape'ni o'rganamiz.

Bu darsda:

  • Uzun vs keng shakl
  • pivot_table (uzun → keng)
  • melt (keng → uzun)
  • stack va unstack
  • aggfunc (agregatsiya)
  • Pivot amaliyoti
  • Pivot tuzoqlari
  • Amaliy: pivot modeli

ℹ Misollar real pandas bilan (deterministik) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. Uzun vs keng shakl

Ikki asosiy shakl:

python
# UZUN (long) — har qator bir kuzatish
#   shahar   oy    savdo
#   T        Yan   100
#   T        Fev   150
#   S        Yan   200

# KENG (wide) — matritsa
#   shahar   Yan   Fev
#   T        100   150
#   S        200   250

# UZUN: tahlil qulay (groupby, filtr)
# KENG: taqdimot chiroyli (o'qilishli matritsa)

Uzun vs keng shakl — ikki asosiy: uzun (long — har qator bir kuzatish: shahar, oy, savdo; ustun kam, qator ko'p), keng (wide — matritsa: shaharlar qator, oylar ustun, katak savdo; ustun ko'p). Sabab: turli maqsad — uzun (tahlil qulay — groupby, filtr, har kuzatish alohida; ma'lumot bazasi shakli), keng (taqdimot — o'qilishli matritsa, Excel; solishtirish oson). Bir ma'lumot ikki shaklda (uzun ↔ keng — o'zgartirish mumkin). Uzun (tahlil), keng (taqdimot). Uzun vs keng — kuzatish vs matritsa. Tahlil vs taqdimot. Shakl.

2.2. pivot_table (uzun → keng)

Uzun → keng (Excel pivot):

python
import pandas as pd

df = pd.DataFrame({
    "shahar": ["T", "T", "S", "S"],
    "oy": ["Yan", "Fev", "Yan", "Fev"],
    "savdo": [100, 150, 200, 250],
})

# pivot_table — uzun → keng (guruhlab jadval)
df.pivot_table(index="shahar", columns="oy", values="savdo", aggfunc="sum")
#         Fev   Yan
# shahar
# S       250   200
# T       150   100

pivot_table (uzun → keng) — guruhlab jadval (Excel pivot): df.pivot_table(index="shahar", columns="oy", values="savdo", aggfunc="sum") (index — qator, columns — ustun, values — katak, aggfunc — funksiya). Sabab: uzun ma'lumotni matritsa qilish (shahar × oy — savdo; taqdimot, solishtirish); pivot_table guruhlab (index/columns bo'yicha — takror bo'lsa aggfunc yig'adi). index (qator yorliq), columns (ustun yorliq), values (katak qiymat), aggfunc (sum/mean — takror uchun). Excel pivot kabi (guruhlab jadval). pivot_table — uzun→keng (index/columns/values/aggfunc). Excel pivot. Matritsa.

2.3. melt (keng → uzun)

Keng → uzun (ustun → qator):

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

# melt — keng → uzun (ustunlarni qatorga)
keng.melt(id_vars="shahar", var_name="oy", value_name="savdo")
#   shahar   oy    savdo
#   T        Yan   100
#   S        Yan   200
#   T        Fev   150
#   S        Fev   250

melt (keng → uzun) — ustun → qator: keng.melt(id_vars="shahar", var_name="oy", value_name="savdo") (id_vars — saqlanadigan ustun; var_name — ustun nomlari ketadigan yangi ustun; value_name — qiymatlar). Sabab: keng ma'lumotni uzun qilish (tahlil uchun — groupby, filtr; ustunlar (oylar) → qator); melt ustunlarni qatorga aylantiradi. id_vars (o'zgarmas — shahar), qolgan ustunlar → var_name (oy) + value_name (savdo). pivot'ning teskarisi (keng → uzun). melt — keng→uzun (id_vars/var_name/value_name). Ustun→qator. Teskari.

2.4. stack va unstack

Indeks ↔ ustun:

python
df = pd.DataFrame({"a": [1, 2], "b": [3, 4]}, index=["x", "y"])

# stack — ustunlarni indeksga (keng → uzun, indeksli)
df.stack()
# x  a    1
#    b    3
# y  a    2
#    b    4

# unstack — indeksni ustunga (uzun → keng)
df.stack().unstack()   # asl (keng)

stack va unstack — indeks ↔ ustun: stack (ustunlarni indeksga — keng → uzun, MultiIndex; ustun → indeks daraja), unstack (indeksni ustunga — uzun → keng; indeks daraja → ustun). Sabab: MultiIndex bilan ishlash (groupby ko'p ustun — 3.8; stack/unstack — indeks/ustun almashtirish); stack (ustun → indeks — ixchamroq), unstack (indeks → ustun — matritsa). groupby([...]).unstack() (ko'p darajali guruh → matritsa — keng ko'rinish). stack/unstack — indeks↔ustun (MultiIndex). Almashtirish. Guruh bilan.

2.5. aggfunc (agregatsiya)

aggfunc (agregatsiya) — pivot_table ichida funksiya: aggfunc="sum" (jami — standart mean), aggfunc="mean" (o'rtacha), aggfunc="count" (soni), aggfunc=["sum", "mean"] (ko'p). Sabab: pivot'da takror bo'lsa (bir shahar-oy juftligida ko'p qator — 3.8 groupby kabi) — aggfunc yig'adi (sum, mean); pivot_table (agregatsiya — takror yig'adi) vs pivot (agregatsiyasiz — takror bo'lsa xato). aggfunc (funksiya — takror uchun), standart mean. pivot_table = groupby + unstack (guruhlab → matritsa). aggfunc — pivot agregatsiya (sum/mean). Takror. groupby kabi.

2.6. Pivot amaliyoti

Pivot amaliyoti: uzun vs keng (tahlil uzun, taqdimot keng); pivot_table (uzun→keng — index/columns/values/aggfunc); melt (keng→uzun — id_vars/var_name/value_name); stack/unstack (indeks↔ustun — MultiIndex); aggfunc (takror — sum/mean); fill_value (pivot NaN — 0); reset_index (pivot natija — MultiIndex/ustun). Tuzoqlar: pivot vs pivot_table (agregatsiya — takror), NaN (mos kelmagan katak — fill_value), MultiIndex (pivot natija — reset_index), melt id_vars (saqlanadigan). Amaliyot — pivot_table, melt, stack, aggfunc. Uzun↔keng. Shakl.

2.7. Pivot tuzoqlari

Pivot asosiy tuzoqlari: pivot vs pivot_table (pivot — agregatsiyasiz (takror bo'lsa xato — "duplicate entries"); pivot_table — aggfunc (takror yig'adi); takror bo'lsa pivot_table); NaN katak (pivot — mos kelmagan juftlik (shahar-oy yo'q) → NaN; fill_value=0); MultiIndex natija (pivot_table — index/columns MultiIndex bo'lishi mumkin; kirish qiyin; reset_index()); melt id_vars (saqlanadigan ustun — id_vars; unutsa barcha melt bo'ladi); aggfunc standart (pivot_table — standart mean (sum emas!); jami kerak bo'lsa aggfunc="sum"); stack/unstack chalkash (stack ustun→indeks, unstack indeks→ustun — teskari); ustun nom yo'qolish (pivot — values ustun nomi ketadi; columns qiymatlar ustun bo'ladi); katta pivot (ko'p columns — keng jadval, ko'p NaN; ehtiyot). Sabab: pivot shakl/agregatsiya/NaN nozik (pivot vs pivot_table, aggfunc, NaN — jim xato). Yechim: pivot_table (takror), fill_value, aggfunc="sum", reset_index. Tuzoqlar — pivot/pivot_table, NaN, aggfunc, MultiIndex.

2.8. Pivot — jadval shaklini o'zgartirish

Pivot asosiy g'oyasi — jadval shaklini o'zgartirish: ma'lumot ikki shaklda (uzun — kuzatish, tahlil qulay; keng — matritsa, taqdimot chiroyli); pivot/melt shakl orasida o'tish (bir ma'lumot — ikki ko'rinish). pivot_table (uzun → keng — guruhlab matritsa; Excel pivot; index/columns/values/aggfunc), melt (keng → uzun — ustun → qator; tahlil uchun), stack/unstack (indeks ↔ ustun — MultiIndex). Sabab: turli maqsad turli shakl talab qiladi (tahlil — uzun groupby; taqdimot — keng jadval; vosita — o'z shakli); shakl o'zgartirish moslik (ma'lumot bir, shakl turli). pivot_table = groupby + unstack (guruhlab → matritsa). Data Science'da (taqdimot — hisobot jadval; tahlil — uzun; moslik — vosita). Bu 3.8 (groupby) va 2.7 (reshape — NumPy shakl) davomi. Pivot — jadval shaklini o'zgartirish (pivot uzun→keng, melt keng→uzun). Shakl. Taqdimot/tahlil.

3. Tez ma'lumotnoma

python
import pandas as pd

# UZUN vs KENG:
#   uzun (long) — har qator kuzatish (tahlil: groupby)
#   keng (wide) — matritsa (taqdimot: o'qilishli)

# pivot_table (uzun → keng, Excel pivot):
df.pivot_table(index="shahar", columns="oy", values="savdo", aggfunc="sum")
#   index — qator · columns — ustun · values — katak · aggfunc — funksiya
#   (standart aggfunc — MEAN, sum emas!)

# melt (keng → uzun, ustun → qator):
keng.melt(id_vars="shahar", var_name="oy", value_name="savdo")

# stack / unstack (indeks ↔ ustun, MultiIndex):
df.stack()      # ustun → indeks (keng → uzun)
df.unstack()    # indeks → ustun (uzun → keng)

# NaN to'ldirish:
df.pivot_table(..., fill_value=0)

QOIDA: pivot_table takror (aggfunc) · standart mean · fill_value NaN · reset_index

Pivot xulosasi

Pivot — jadval shaklini o'zgartirish (uzun ↔ keng)
Uzun (kuzatish, tahlil) vs keng (matritsa, taqdimot)
pivot_table — uzun → keng (index/columns/values/aggfunc, Excel pivot)
melt — keng → uzun (id_vars/var_name/value_name, ustun → qator)
stack/unstack — indeks ↔ ustun · aggfunc standart mean (sum emas)

4. Batafsil misollar

Misollar real pandas bilan (deterministik) ishlaydi.

Misol 1 — pivot_table

python
"""pivot_table: uzun → keng (real pandas)."""

import pandas as pd


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

    print("=== 1. pivot_table ===")
    keng = df.pivot_table(index="shahar", columns="oy", values="savdo", aggfunc="sum")
    print(f"  shakl: {keng.shape} (2 shahar × 2 oy)")

    print("\n=== 2. Katak (T, Yan) ===")
    print(f"  T yanvar: {keng.loc['T', 'Yan']}")

    print("\n=== 3. Ustunlar (oylar) ===")
    print(f"  ustunlar: {list(keng.columns)}")

    print("\n=== 4. Shahar jami (qator yig'indi) ===")
    print(f"  T jami: {keng.loc['T'].sum()}")
    print("  ⭐ pivot_table — uzun → keng (Excel pivot)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. pivot_table ===
  shakl: (2, 2) (2 shahar × 2 oy)

=== 2. Katak (T, Yan) ===
  T yanvar: 100

=== 3. Ustunlar (oylar) ===
  ustunlar: ['Fev', 'Yan']

=== 4. Shahar jami (qator yig'indi) ===
  T jami: 250
  ⭐ pivot_table — uzun → keng (Excel pivot)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 2 — melt

python
"""melt: keng → uzun (real pandas)."""

import pandas as pd


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

    print("=== 1. melt (keng → uzun) ===")
    uzun = keng.melt(id_vars="shahar", var_name="oy", value_name="savdo")
    print(f"  qatorlar: {len(uzun)} (2 shahar × 2 oy)")

    print("\n=== 2. Ustunlar ===")
    print(f"  ustunlar: {list(uzun.columns)}")

    print("\n=== 3. Endi groupby mumkin ===")
    print(f"  shahar jami: {uzun.groupby('shahar')['savdo'].sum().to_dict()}")

    print("\n=== 4. Teskari (pivot) ===")
    qayta = uzun.pivot_table(index="shahar", columns="oy", values="savdo")
    print(f"  qayta keng: {qayta.shape}")
    print("  ⭐ melt — keng → uzun (tahlil uchun)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. melt (keng → uzun) ===
  qatorlar: 4 (2 shahar × 2 oy)

=== 2. Ustunlar ===
  ustunlar: ['shahar', 'oy', 'savdo']

=== 3. Endi groupby mumkin ===
  shahar jami: {'S': 450, 'T': 250}

=== 4. Teskari (pivot) ===
  qayta keng: (2, 2)
  ⭐ melt — keng → uzun (tahlil uchun)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 3 — aggfunc

python
"""aggfunc: agregatsiya (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({
        "shahar": ["T", "T", "T", "S"],
        "oy": ["Yan", "Yan", "Fev", "Yan"],
        "savdo": [100, 50, 150, 200],
    })

    print("=== 1. sum (takror yig'iladi) ===")
    p_sum = df.pivot_table(index="shahar", columns="oy", values="savdo", aggfunc="sum")
    print(f"  T yanvar (100+50): {p_sum.loc['T', 'Yan']}")

    print("\n=== 2. mean ===")
    p_mean = df.pivot_table(index="shahar", columns="oy", values="savdo", aggfunc="mean")
    print(f"  T yanvar o'rtacha: {p_mean.loc['T', 'Yan']}")

    print("\n=== 3. count ===")
    p_count = df.pivot_table(index="shahar", columns="oy", values="savdo", aggfunc="count")
    print(f"  T yanvar soni: {p_count.loc['T', 'Yan']}")

    print("\n=== 4. fill_value (NaN → 0) ===")
    p_fill = df.pivot_table(index="shahar", columns="oy", values="savdo",
                            aggfunc="sum", fill_value=0)
    print(f"  S fevral (yo'q → 0): {p_fill.loc['S', 'Fev']}")
    print("  ⭐ aggfunc — takror yig'ish (sum/mean/count)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. sum (takror yig'iladi) ===
  T yanvar (100+50): 150.0

=== 2. mean ===
  T yanvar o'rtacha: 75.0

=== 3. count ===
  T yanvar soni: 2.0

=== 4. fill_value (NaN → 0) ===
  S fevral (yo'q → 0): 0
  ⭐ aggfunc — takror yig'ish (sum/mean/count)

Nima ko'rsatdi: 2.5-bo'lim.

Misol 4 — stack/unstack

python
"""stack va unstack (real pandas)."""

import pandas as pd


def main() -> None:
    df = pd.DataFrame({"a": [1, 2], "b": [3, 4]}, index=["x", "y"])

    print("=== 1. stack (ustun → indeks) ===")
    stacked = df.stack()
    print(f"  stacked uzunlik: {len(stacked)} (2×2)")

    print("\n=== 2. unstack (qayta keng) ===")
    unstacked = stacked.unstack()
    print(f"  unstacked shakl: {unstacked.shape}")

    print("\n=== 3. Asl bilan bir xil ===")
    print(f"  bir xil: {df.equals(unstacked)}")

    print("\n=== 4. groupby + unstack ===")
    d2 = pd.DataFrame({"g": ["A", "A", "B"], "k": ["x", "y", "x"], "v": [1, 2, 3]})
    natija = d2.groupby(["g", "k"])["v"].sum().unstack(fill_value=0)
    print(f"  guruh matritsa shakl: {natija.shape}")
    print("  ⭐ stack/unstack — indeks ↔ ustun")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. stack (ustun → indeks) ===
  stacked uzunlik: 4 (2×2)

=== 2. unstack (qayta keng) ===
  unstacked shakl: (2, 2)

=== 3. Asl bilan bir xil ===
  bir xil: True

=== 4. groupby + unstack ===
  guruh matritsa shakl: (2, 2)
  ⭐ stack/unstack — indeks ↔ ustun

Nima ko'rsatdi: 2.4-bo'lim.

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

Noto'g'ri fikr To'g'risi
"bir shakl yetarli" Uzun (tahlil), keng (taqdimot)
"pivot = pivot_table" pivot agregatsiyasiz (takror xato)
"aggfunc standart sum" mean (sum emas!)
"pivot NaN yo'q" Mos kelmagan → NaN (fill_value)
"melt id_vars keraksiz" Saqlanadigan ustun
"keng har doim yaxshi" Tahlil — uzun qulay
"stack = unstack" Teskari (ustun↔indeks)
"pivot natija oddiy" MultiIndex (reset_index)

6. Keng tarqalgan xatolar va yechimlari

1. pivot vs pivot_table

python
df.pivot(index="a", columns="b", values="c")   # takror → xato # ⚠️
df.pivot_table(index="a", columns="b", values="c", aggfunc="sum")  # ✅

2. aggfunc standart

python
df.pivot_table(index="a", columns="b", values="c")   # mean!   # ⚠️
df.pivot_table(..., aggfunc="sum")   # jami                     # ✅

3. NaN katak

python
df.pivot_table(...)   # mos kelmagan → NaN                     # ⚠️
df.pivot_table(..., fill_value=0)   # NaN → 0                   # ✅

4. MultiIndex

python
p = df.pivot_table(...)   # MultiIndex (kirish qiyin)          # ⚠️
p.reset_index()   # oddiy ustun                                 # ✅

5. melt id_vars

python
df.melt()   # hamma ustun melt (shahar ham)                    # ⚠️
df.melt(id_vars="shahar")   # shahar saqlanadi                  # ✅

6. stack/unstack chalkash

python
df.stack()   # ustun → indeks (keng → uzun)                    # ⚠️
df.unstack()   # indeks → ustun (uzun → keng)                   # ✅

7. Katta pivot

python
df.pivot_table(columns="id")   # ko'p ustun (id million)       # ⚠️
# columns kam noyob qiymatli ustun bo'lsin                      # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 3.8-dars (o'tilgan): groupby (pivot_table = groupby + unstack)
  • 2.7-dars (o'tilgan): reshape (NumPy shakl)
  • 5-qism: Vizualizatsiya (keng — heatmap)
  • 6-qism: Tozalash (shakl to'g'rilash)
  • 4-qism: Statistika (pivot — solishtirish)

8. Eng yaxshi amaliyotlar

  1. Uzun — tahlil, keng — taqdimot.

  2. pivot_table — takror (aggfunc).

  3. aggfunc="sum" — jami (standart mean).

  4. fill_value=0 — NaN to'ldirish.

  5. melt — keng → uzun (id_vars).

  6. reset_index — pivot natija (MultiIndex).

  7. stack/unstack — indeks ↔ ustun.

  8. Pivot — jadval shaklini o'zgartirish.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # uzun shakl nima?
2.  # keng shakl nima?
3.  # qaysi tahlil uchun?
4.  # pivot_table nima?
5.  # index/columns/values?
6.  # aggfunc standart?
7.  # pivot vs pivot_table?
8.  # melt nima?
9.  # id_vars nima?
10. # stack/unstack?
11. # pivot NaN?
12. # nega shakl muhim?
Javoblar
  1. Har qator kuzatish
  2. Matritsa
  3. Uzun (tahlil), keng (taqdimot)
  4. Uzun → keng (guruhlab jadval)
  5. qator/ustun/katak
  6. mean (sum emas)
  7. pivot agregatsiyasiz (takror xato)
  8. Keng → uzun (ustun → qator)
  9. Saqlanadigan ustun
  10. indeks ↔ ustun (teskari)
  11. Mos kelmagan → NaN (fill_value)
  12. Turli maqsad turli shakl (moslik)

Vazifa 2: Xatolarni tuzating

python
1.  df.pivot(index="a", columns="b", values="c")   # takror

2.  df.pivot_table(...)   # jami kerak

3.  df.pivot_table(...)   # NaN bor

4.  p = df.pivot_table(...)   # MultiIndex

5.  df.melt()   # shahar saqlansin
Javoblar
python
1.  pivot_table(..., aggfunc="sum")

2.  aggfunc="sum"

3.  fill_value=0

4.  p.reset_index()

5.  df.melt(id_vars="shahar")

Vazifa 3: Uzun vs keng

Modellang:

  1. Uzun
  2. Keng
  3. Tahlil
  4. Taqdimot

Vazifa 4: pivot_table

Modellang:

  1. index
  2. columns
  3. values
  4. aggfunc

Vazifa 5: melt

Modellang:

  1. id_vars
  2. var_name
  3. value_name
  4. Teskari

Vazifa 6: stack

Modellang:

  1. stack
  2. unstack
  3. Indeks↔ustun
  4. MultiIndex

Vazifa 7: O'ylash

Bir xil ma'lumot "uzun" (tahlil uchun) va "keng" (taqdimot uchun) shaklda bo'lishi mumkin, va biz ular orasida o'tamiz. Nima uchun tahlil uchun uzun shakl qulay (groupby, filtr), taqdimot uchun keng shakl chiroyli, va bu qanday qilib "ma'lumot bir xil, lekin ko'rinish maqsadga bog'liq" degan muhim tushunchani ko'rsatadi?

Javob

Qisqa javob: Bir ma'lumot uzun (tahlil) va keng (taqdimot) shaklda; uzun tahlil uchun qulay, keng taqdimot uchun chiroyli, chunki: (1) uzun — har kuzatish mustaqil — uzun shaklda har qator bir kuzatish (shahar, oy, savdo — to'liq); groupby oson (ustun bo'yicha guruh — shahar; har kuzatish — bir qator), filtr oson (shart — qatorlar), amal ustun bo'yicha (3.2 — ustun-markaziy); uzun mashina uchun (dastur — qator-qator ishlaydi); (2) keng — matritsa, ko'z uchun — keng shaklda matritsa (shahar × oy — katak savdo); solishtirish oson (bir qatorda shaharning barcha oylari — trend ko'rinadi; ustunda oyning barcha shaharlari); inson matritsa o'qiydi (Excel — keng; taqdimot); keng inson uchun (ko'z — solishtirish, naqsh); (3) maqsad farqi — tahlil (mashina — groupby, filtr; uzun), taqdimot (inson — o'qish, solishtirish; keng). "Nega 'ma'lumot bir, ko'rinish maqsadga bog'liq'": (a) ma'lumot o'zgarmaydi — uzun/keng bir xil ma'lumot (savdo qiymatlar o'sha — faqat tashkil boshqa; pivot/melt — o'zgartirish, yo'qotish yo'q); (b) maqsad ko'rinishni tanlaydi — tahlil (uzun — dastur qulay), taqdimot (keng — inson qulay); bir ma'lumot turli maqsad (turli shakl); (c) moslashuvchanlik — pivot/melt o'tish (maqsadga — shakl o'zgartirish; bir ma'lumot, ikki ko'rinish); (d) vosita talab — ba'zi vosita uzun (groupby, ML — uzun/tidy), ba'zi keng (heatmap, Excel — keng); shakl vositaga mos. "Tidy data" (uzun — tahlil standarti): har o'zgaruvchan ustun, har kuzatish qator (uzun — dastur uchun toza); keng (taqdimot — inson). Saboqlar: uzun kuzatish (mashina — groupby/filtr); keng matritsa (inson — solishtirish); ma'lumot bir (shakl o'zgaradi — yo'qotish yo'q); maqsad ko'rinish (tahlil uzun, taqdimot keng). To'g'ri: tahlil — uzun (groupby); taqdimot — keng (pivot_table); o'tish (pivot/melt). Muvozanat: mashina (uzun — tahlil) + inson (keng — taqdimot) — ikki auditoriya. Bu Data Science tushunchasi (ma'lumot bir — ko'rinish maqsadga; shakl o'zgartirish — moslik); "tidy data" (uzun — tahlil asosi). Pivot/melt — shakl vositasi (bir ma'lumot, maqsadga mos ko'rinish).

1. Nega uzun tahlil uchun

  • Har qator kuzatish (mustaqil — to'liq)
  • groupby/filtr oson (ustun/shart)
  • Mashina uchun (qator-qator)

2. Nega keng taqdimot uchun

  • Matritsa (shahar × oy — katak)
  • Solishtirish oson (qator/ustun — trend)
  • Inson uchun (ko'z — o'qish)

3. "Ma'lumot bir, ko'rinish maqsadga"

  • Ma'lumot o'zgarmaydi (uzun/keng — bir xil)
  • Maqsad ko'rinish tanlaydi (tahlil/taqdimot)
  • Moslashuvchanlik (pivot/melt — o'tish)
  • Vosita talab (uzun/keng — mos)

4. Uzun vs keng

Uzun Keng
Kuzatish (qator) Matritsa
Mashina (groupby) Inson (ko'z)
Tahlil Taqdimot

5. Saboqlar

  1. Uzun kuzatish (mashina — groupby)
  2. Keng matritsa (inson — solishtirish)
  3. Ma'lumot bir (shakl o'zgaradi)
  4. Maqsad ko'rinish (tahlil/taqdimot)

6. Xulosa

  1. Uzun tahlil (groupby/filtr — mashina)
  2. Keng taqdimot (matritsa — inson)
  3. Ma'lumot bir (ko'rinish maqsadga)
  4. Pivot/melt — shakl vositasi (moslik)

Nimani mustahkamlaydi: 2.1, 2.8-bo'limlar.

Xulosa

Bu darsda pivot va reshape'ni o'rgandik.

Eng muhim uch fikr:

  1. Uzun/keng va pivot_table. Uzun vs keng — uzun (long — har qator bir kuzatish; tahlil qulay — groupby, filtr), keng (wide — matritsa; taqdimot chiroyli — o'qilishli). pivot_table — uzun → keng (Excel pivot): index (qator), columns (ustun), values (katak), aggfunc (funksiya — takror yig'adi; standart mean, sum emas!); guruhlab matritsa.

  2. melt va stack. melt — keng → uzun (ustun → qator): id_vars (saqlanadigan), var_name (ustun nomlari), value_name (qiymatlar); pivot teskarisi (tahlil uchun). stack/unstack — indeks ↔ ustun (stack ustun→indeks; unstack indeks→ustun; MultiIndex — groupby ko'p ustun bilan).

  3. Shakl o'zgartirish. aggfunc (pivot takror — sum/mean/count), fill_value (NaN → 0). Pivot — jadval shaklini o'zgartirish (uzun ↔ keng; bir ma'lumot — ikki ko'rinish); ma'lumot bir, ko'rinish maqsadga bog'liq (tahlil — uzun/mashina; taqdimot — keng/inson). pivot_table = groupby + unstack. Data Science'da (taqdimot — hisobot; tahlil — uzun; "tidy data"). Tuzoqlar: pivot vs pivot_table (takror — aggfunc), aggfunc standart mean, NaN (fill_value), MultiIndex (reset_index), melt id_vars.

Keyingi darsda Pandas amaliy loyihani bajaramiz: butun Pandas bilimini (o'qish, tozalash, filtr, guruhlash, birlashtirish) real ma'lumot tahlilida qo'llab — 3-qismni yakunlaymiz.

Ulashish:Telegram'da

Izohlar (0)

Izoh yozish uchun kiring.

  • Hozircha izoh yo'q. Birinchi bo'ling!
3.13-dars: Pivot va reshape — IlmHamroh