Python kursi24.10-dars: pandas — birlashtirish
Python kursi · Malumot tahlili

24.10-dars: pandas — birlashtirish

16 daqiqa10/18-dars

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


1. Kirish va motivatsiya

24.9 da bir jadvalni guruhladik. Lekin real ma'lumot ko'pincha bir necha jadvalda taqsimlangan (23.12 normalizatsiya): kurslar bir jadval, mualliflar boshqa (muallif_id bilan bog'langan), sotuvlar uchinchi. Tahlil uchun ularni birlashtirish kerak — kurs nomi + muallif nomi bir joyga. Yoki har oy sotuvi alohida faylda — ularni bir jadvalga ulash.

pandas ikki xil birlashtirish beradi: merge (ustun/kalit bo'yicha — SQL JOIN kabi, 23.2) va concat (jadvallarni ustma-ust yoki yonma-yon ulash). merge — bog'langan jadvallarni (kurs + muallif) id bo'yicha; concat — bir xil ustunli jadvallarni (yanvar + fevral sotuvi) birlashtirish. Birlashtirish turlari (inner, left, outer) — qaysi qatorlar qoladi. Bu 23.2 (SQL JOIN) ning pandas versiyasi — turli manbalardagi ma'lumotni bir joyga.

Real vaziyat. Bir hisobot kurs sotuvi + muallif ma'lumoti + kategoriyani birlashtirishni talab qildi — uch alohida jadval. Qo'lda: har kurs uchun muallifni qidirish, sekin. pandas bilan: sotuv.merge(muallif, on="muallif_id").merge(kategoriya, on="kat_id") — uch jadval bir joyda. Har oy faylini pd.concat([...]) bilan bir jadvalga. Birlashtirish — taqsimlangan ma'lumotni jamlashning vositasi.

Bu darsda pandas birlashtirishni o'rganamiz.

Bu darsda:

  • merge (kalit bo'yicha)
  • Birlashtirish turlari (inner, left, outer)
  • concat (ustma-ust, yonma-yon)
  • on, left_on/right_on
  • Ustunlar to'qnashuvi (suffixes)
  • join (indeks bo'yicha)
  • merge vs concat — qachan
  • Amaliy: jadvallarni birlashtirish

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


2. Nazariya — chuqur tushuntirish

2.1. merge (kalit bo'yicha)

merge — jadvallarni umumiy ustun bo'yicha:

python
kurs.merge(muallif, on="muallif_id")
# kurs jadvali + muallif jadvali (muallif_id bo'yicha)
# har kursga o'z muallifi qo'shiladi

merge — ikki jadvalni umumiy ustun (kalit) bo'yicha birlashtiradi (SQL JOIN, 23.2 kabi): kurs.merge(muallif, on="muallif_id") — kurs jadvaliga muallif ma'lumoti qo'shiladi (kalit mos qatorlar). Bu bog'langan ma'lumotni (23.12 FK) bir joyga keltiradi. on — umumiy ustun. Tahlil uchun taqsimlangan ma'lumotni jamlashning asosi.

2.2. Birlashtirish turlari (how)

Qaysi qatorlar qoladi:

how Natija
inner (default) Faqat ikkalasida mos
left Chap barcha + mos o'ng
right O'ng barcha + mos chap
outer Ikkalasi barcha
python
a.merge(b, on="k", how="inner")   # faqat mos
a.merge(b, on="k", how="left")    # chap barcha (o'ng NaN)
a.merge(b, on="k", how="outer")   # hammasi

Birlashtirish turlari (how — 23.2 JOIN kabi): inner (default — faqat ikki jadvalda mos kalit), left (chap barcha qator + o'ngdan mos, mos yo'q — NaN), right (aksincha), outer (ikkalasi barcha). Tanlov muhim: inner — faqat to'liq mos (ma'lumot yo'qolishi mumkin), left — chap saqlanadi (odatda asosiy jadval). Noto'g'ri how — noto'g'ri natija.

2.3. concat (ustma-ust, yonma-yon)

concat — jadvallarni ulash:

python
pd.concat([df1, df2])                    # ustma-ust (qatorlar)
pd.concat([df1, df2], ignore_index=True)  # indeks qayta
pd.concat([df1, df2], axis=1)            # yonma-yon (ustunlar)

concat — jadvallarni ulash (merge'dan farq — kalit yo'q): pd.concat([df1, df2]) (ustma-ust — qatorlarni qo'shadi, bir xil ustunli jadvallar — yanvar + fevral), axis=1 (yonma-yon — ustunlarni qo'shadi). ignore_index=True (indeksni qayta raqamla). Bir xil tuzilmali jadvallarni (turli fayl, davr) bir jadvalga. Oddiy ulash (bog'lanish emas).

2.4. on, left_on/right_on

Kalit ustunlar har xil nomli bo'lsa:

python
a.merge(b, on="id")                       # ikkalasida "id"
a.merge(b, left_on="muallif_id", right_on="id")  # har xil nom
a.merge(b, on=["kat", "til"])             # bir necha kalit

Kalit ko'rsatish: on="id" (ikkalasida bir xil nom), left_on/right_on (har xil nom — kurs.muallif_id va muallif.id), on=["a", "b"] (bir necha kalit). Real ma'lumotda kalit nomlari har xil (muallif_id vs id) — left_on/right_on bilan. Kalit — birlashtirish asosi (to'g'ri kalit — to'g'ri natija).

2.5. Ustunlar to'qnashuvi (suffixes)

Ikki jadvalda bir xil ustun nomi:

python
a.merge(b, on="k")   # ikkalasida "nom" bor
# → nom_x, nom_y (avtomatik)
a.merge(b, on="k", suffixes=("_kurs", "_muallif"))
# → nom_kurs, nom_muallif

Ustunlar to'qnashuvi — ikki jadvalda bir xil nomli ustun (kalitdan tashqari): pandas avtomatik _x, _y qo'shadi. suffixes=("_kurs", "_muallif") — aniq nom (o'qiluvchan). Masalan, kurs va muallif ikkalasida "nom" bor — nom_kurs, nom_muallif. Bu chalkashlikni oldini oladi. Aniq suffix — o'qiluvchan natija.

2.6. join (indeks bo'yicha)

join — indeks bo'yicha birlashtirish:

python
chap.join(ong)                    # indeks bo'yicha
chap.join(ong, how="left")        # turi
# merge'ning indeks versiyasi (qulayroq sintaksis)

join — indeks bo'yicha birlashtirish (mergening indeks uchun qulay shakli): chap.join(ong) (ikkalasi indeksi bo'yicha). how (inner, left, ...) — merge kabi. Ustun bo'yicha — merge; indeks bo'yicha — join (yoki merge(left_index=True)). Nomlangan indeks (sana, id) bilan ishlaganda qulay. merge'ning maxsus holi.

2.7. merge vs concat — qachan

Holat Usul
Bog'langan jadvallar (FK) merge
Bir xil ustun, ko'p davr concat (ustma-ust)
Ustun qo'shish (bir xil qator) concat(axis=1)
Indeks bo'yicha join

merge — bog'langan jadvallar (kurs + muallif — kalit bo'yicha, SQL JOIN); concat — bir xil tuzilmali jadvallar (yanvar + fevral — ustma-ust, yoki ustun qo'shish — yonma-yon). Qoida: bog'lanish (kalit) → merge; ulash (bir xil shakl) → concat. join — indeks bo'yicha merge. Noto'g'ri tanlov — noto'g'ri natija (yoki xato).

2.8. Birlashtirish — SQL JOIN

pandas merge — SQL JOIN 23.2-bob ga to'g'ridan-to'g'ri mos: SELECT * FROM kurs JOIN muallif ON kurs.muallif_id = muallif.id = kurs.merge(muallif, left_on="muallif_id", right_on="id"). how — JOIN turi (inner/left/outer). Har ikkisi bog'langan ma'lumotni birlashtiradi. Farq: pandas xotirada (tahlil), SQL bazada (katta). 23.12 (baza dizayni — normalizatsiya) va bu (birlashtirish) — ikki tomon: bo'l (normalizatsiya), birlashtir (merge/JOIN).


3. Tez ma'lumotnoma

python
import pandas as pd

# merge (kalit bo'yicha — SQL JOIN):
a.merge(b, on="id")                        # umumiy ustun
a.merge(b, left_on="muallif_id", right_on="id")  # har xil nom
a.merge(b, on="k", how="left")             # chap barcha
a.merge(b, on="k", suffixes=("_a", "_b"))  # ustun to'qnashuvi

# how turlari:
how="inner"   # faqat mos (default)
how="left"    # chap barcha
how="outer"   # ikkalasi barcha

# concat (ulash):
pd.concat([df1, df2], ignore_index=True)   # ustma-ust (qator)
pd.concat([df1, df2], axis=1)              # yonma-yon (ustun)

# join (indeks bo'yicha):
chap.join(ong, how="left")

Birlashtirish xulosasi

merge: kalit bo'yicha (JOIN) · how: inner/left/right/outer
concat: ulash (ustma-ust qator, axis=1 ustun) · join: indeks bo'yicha
merge=bog'lanish, concat=ulash · = SQL JOIN

4. Batafsil misollar

Misollarda pandas (import pandas as pd) bilan sinaladi.

Misol 1 — merge (bog'langan jadvallar)

python
"""merge: kurs + muallif (muallif_id bo'yicha); left_on/right_on (har xil nom); suffixes."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    kurs = pd.DataFrame({
        "nom": ["Python", "Go", "Rust"],
        "muallif_id": [1, 1, 2],
    })
    muallif = pd.DataFrame({
        "id": [1, 2],
        "muallif": ["Ali", "Vali"],
    })

    print("=== 1. merge (left_on/right_on) ===")
    m = kurs.merge(muallif, left_on="muallif_id", right_on="id")
    print(m[["nom", "muallif"]].to_string(index=False))

    print("\n=== 2. Har muallif necha kurs ===")
    print(f"  {m.groupby('muallif').size().to_dict()}")

    print("\n=== 3. on (bir xil nom) ===")
    a = pd.DataFrame({"id": [1, 2, 3], "x": ["a", "b", "c"]})
    b = pd.DataFrame({"id": [1, 2, 3], "y": ["p", "q", "r"]})
    print(f"  {a.merge(b, on='id').to_dict(orient='records')}")

    print("\n=== 4. suffixes (ustun to'qnashuvi) ===")
    c = pd.DataFrame({"k": [1], "nom": ["kurs_nomi"]})
    d = pd.DataFrame({"k": [1], "nom": ["mua_nomi"]})
    r = c.merge(d, on="k", suffixes=("_kurs", "_mua"))
    print(f"  ustunlar: {list(r.columns)}")
    print("  ⭐ merge — bog'langan jadvallar (kalit bo'yicha)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. merge (left_on/right_on) ===
   nom muallif
Python     Ali
    Go     Ali
  Rust    Vali

=== 2. Har muallif necha kurs ===
  {'Ali': 2, 'Vali': 1}

=== 3. on (bir xil nom) ===
  [{'id': 1, 'x': 'a', 'y': 'p'}, {'id': 2, 'x': 'b', 'y': 'q'}, {'id': 3, 'x': 'c', 'y': 'r'}]

=== 4. suffixes (ustun to'qnashuvi) ===
  ustunlar: ['k', 'nom_kurs', 'nom_mua']
  ⭐ merge — bog'langan jadvallar (kalit bo'yicha)

Nima ko'rsatdi: 2.1, 2.4, 2.5-bo'limlar.

Misol 2 — Birlashtirish turlari (how)

python
"""how: inner (mos), left (chap barcha), outer (hammasi) — qaysi qatorlar qoladi."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    a = pd.DataFrame({"k": [1, 2, 3], "x": ["a", "b", "c"]})
    b = pd.DataFrame({"k": [2, 3, 4], "y": ["p", "q", "r"]})

    print("=== 1. inner (faqat mos: 2, 3) ===")
    r = a.merge(b, on="k", how="inner")
    print(f"  kalitlar: {r['k'].tolist()}")

    print("\n=== 2. left (chap barcha: 1, 2, 3) ===")
    r = a.merge(b, on="k", how="left")
    print(f"  kalitlar: {r['k'].tolist()}")
    print(f"  y (mos yo'q → NaN): {r['y'].fillna('YOQ').tolist()}")

    print("\n=== 3. right (o'ng barcha: 2, 3, 4) ===")
    r = a.merge(b, on="k", how="right")
    print(f"  kalitlar: {r['k'].tolist()}")

    print("\n=== 4. outer (hammasi: 1, 2, 3, 4) ===")
    r = a.merge(b, on="k", how="outer")
    print(f"  kalitlar soni: {len(r)}")
    print("  ⭐ how — inner(mos)/left(chap)/right/outer(hammasi)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. inner (faqat mos: 2, 3) ===
  kalitlar: [2, 3]

=== 2. left (chap barcha: 1, 2, 3) ===
  kalitlar: [1, 2, 3]
  y (mos yo'q → NaN): ['YOQ', 'p', 'q']

=== 3. right (o'ng barcha: 2, 3, 4) ===
  kalitlar: [2, 3, 4]

=== 4. outer (hammasi: 1, 2, 3, 4) ===
  kalitlar soni: 4
  ⭐ how — inner(mos)/left(chap)/right/outer(hammasi)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — concat (ulash)

python
"""concat: ustma-ust (qatorlar — turli davr); yonma-yon (axis=1 — ustun qo'shish)."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    yanvar = pd.DataFrame({"mahsulot": ["Python", "Go"], "sotildi": [50, 30]})
    fevral = pd.DataFrame({"mahsulot": ["Python", "Rust"], "sotildi": [60, 20]})

    print("=== 1. concat (ustma-ust — qatorlar) ===")
    df = pd.concat([yanvar, fevral], ignore_index=True)
    print(f"  jami qatorlar: {len(df)}")
    print(f"  {df.to_dict(orient='records')}")

    print("\n=== 2. Oy ustuni qo'shib concat ===")
    yanvar2 = yanvar.copy(); yanvar2["oy"] = "yanvar"
    fevral2 = fevral.copy(); fevral2["oy"] = "fevral"
    df2 = pd.concat([yanvar2, fevral2], ignore_index=True)
    print(f"  har oy: {df2.groupby('oy')['sotildi'].sum().to_dict()}")

    print("\n=== 3. concat axis=1 (yonma-yon — ustun) ===")
    a = pd.DataFrame({"nom": ["Python", "Go"]})
    b = pd.DataFrame({"narx": [100, 120]})
    df3 = pd.concat([a, b], axis=1)
    print(f"  ustunlar: {list(df3.columns)}")

    print("\n=== 4. Umumiy sotuv (birlashtirilgan) ===")
    print(f"  mahsulot bo'yicha: {df.groupby('mahsulot')['sotildi'].sum().to_dict()}")
    print("  ⭐ concat — bir xil tuzilmali jadvallarni ulash")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. concat (ustma-ust — qatorlar) ===
  jami qatorlar: 4
  [{'mahsulot': 'Python', 'sotildi': 50}, {'mahsulot': 'Go', 'sotildi': 30}, {'mahsulot': 'Python', 'sotildi': 60}, {'mahsulot': 'Rust', 'sotildi': 20}]

=== 2. Oy ustuni qo'shib concat ===
  har oy: {'fevral': 80, 'yanvar': 80}

=== 3. concat axis=1 (yonma-yon — ustun) ===
  ustunlar: ['nom', 'narx']

=== 4. Umumiy sotuv (birlashtirilgan) ===
  mahsulot bo'yicha: {'Go': 30, 'Python': 110, 'Rust': 20}
  ⭐ concat — bir xil tuzilmali jadvallarni ulash

Nima ko'rsatdi: 2.3-bo'lim.

Misol 4 — Amaliy: uch jadvalni birlashtirish

Real misol: sotuv + kurs + muallif — uch jadval, merge bilan bir joyga, keyin guruhlash. Bu — taqsimlangan ma'lumotni jamlashning namunasi.

python
"""to'liq birlashtirish: sotuv+kurs+muallif merge, keyin guruhlab hisobot (muallif bo'yicha)."""

import warnings
warnings.filterwarnings("ignore")

import pandas as pd


def main() -> None:
    kurs = pd.DataFrame({
        "kurs_id": [1, 2, 3],
        "nom": ["Python", "Go", "Rust"],
        "muallif_id": [1, 1, 2],
    })
    muallif = pd.DataFrame({"muallif_id": [1, 2], "muallif": ["Ali", "Vali"]})
    sotuv = pd.DataFrame({
        "kurs_id": [1, 2, 3, 1, 2],
        "summa": [100, 120, 150, 100, 120],
    })

    print("=== 1. sotuv + kurs (kurs_id bo'yicha) ===")
    df = sotuv.merge(kurs, on="kurs_id")
    print(f"  qatorlar: {len(df)}, ustunlar: {list(df.columns)}")

    print("\n=== 2. + muallif (muallif_id bo'yicha) ===")
    df = df.merge(muallif, on="muallif_id")
    print(f"  {df[['nom', 'muallif', 'summa']].head(3).to_dict(orient='records')}")

    print("\n=== 3. Muallif bo'yicha daromad ===")
    daromad = df.groupby("muallif")["summa"].sum().sort_values(ascending=False)
    print(f"  {daromad.to_dict()}")

    print("\n=== 4. Kurs bo'yicha sotuv soni ===")
    print(f"  {df.groupby('nom').size().to_dict()}")
    print(f"  jami daromad: {df['summa'].sum()}")
    print("  ⭐ merge (uch jadval) + groupby — to'liq hisobot")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

text
=== 1. sotuv + kurs (kurs_id bo'yicha) ===
  qatorlar: 5, ustunlar: ['kurs_id', 'summa', 'nom', 'muallif_id']

=== 2. + muallif (muallif_id bo'yicha) ===
  [{'nom': 'Python', 'muallif': 'Ali', 'summa': 100}, {'nom': 'Go', 'muallif': 'Ali', 'summa': 120}, {'nom': 'Rust', 'muallif': 'Vali', 'summa': 150}]

=== 3. Muallif bo'yicha daromad ===
  {'Ali': 440, 'Vali': 150}

=== 4. Kurs bo'yicha sotuv soni ===
  {'Go': 2, 'Python': 2, 'Rust': 1}
  jami daromad: 590
  ⭐ merge (uch jadval) + groupby — to'liq hisobot

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
"merge = concat" merge — kalit, concat — ulash
"merge default outer" Default inner (faqat mos)
"inner ma'lumot yo'qotmaydi" Mos bo'lmagan qatorlar tushadi
"Kalit nom bir xil bo'lsin" left_on/right_on (har xil)
"concat kalit bo'yicha" Ustma-ust/yonma-yon (kalit yo'q)
"Ustun to'qnashuvi xato" _x, _y (suffixes)
"join = merge" join — indeks bo'yicha
"SQL JOIN boshqacha" merge — bir xil g'oya

6. Keng tarqalgan xatolar va yechimlari

1. innerda ma'lumot yo'qolishi

python
a.merge(b, on="k")   # mos bo'lmagan tushadi  # ba'zan kutilmagan
a.merge(b, on="k", how="left")  # chap saqlanadi  # ✅ kerak bo'lsa

2. Kalit nom har xil

python
kurs.merge(muallif, on="id")   # kurs'da id yo'q  # ⚠️
kurs.merge(muallif, left_on="muallif_id", right_on="id")  # ✅

3. concatda indeks takror

python
pd.concat([a, b])   # indeks 0,1,0,1              # ⚠️
pd.concat([a, b], ignore_index=True)             # ✅

4. mergeni concat o'rniga (bir xil ustun)

python
yanvar.merge(fevral)   # kalit yo'q               # ⚠️
pd.concat([yanvar, fevral])                       # ✅ ulash

5. Ko'p-ko'p merge (qator ko'payadi)

python
# kalit takrorlansa, qatorlar ko'payadi (kartezian)  # ehtiyot
# kalit noyob bo'lsin (yoki kutilgan)

6. Ustun to'qnashuvi (noaniq nom)

python
a.merge(b, on="k")   # nom_x, nom_y (noaniq)      # ⚠️
a.merge(b, on="k", suffixes=("_a", "_b"))         # ✅

7. outerda ko'p NaN

python
a.merge(b, on="k", how="outer")   # ko'p bo'sh (NaN)  # ehtiyot
# fillna yoki kerakli how tanla

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 24.9-dars (o'tilgan): Guruhlash — birlashtirilgan ma'lumot
  • 24.6-dars (o'tilgan): O'qish — ko'p fayl (concat)
  • 23.2-dars (o'tilgan): SQL JOIN — merge o'xshashi
  • 23.12-dars (o'tilgan): Normalizatsiya — birlashtirish sababi
  • 25-qism: ML — ma'lumot tayyorlash (birlashtirish)

8. Eng yaxshi amaliyotlar

  1. Bog'langan jadvallar — merge (kalit).

  2. Bir xil tuzilma — concat.

  3. howni ongli tanla (inner/left).

  4. Har xil kalit nom — left_on/right_on.

  5. Ustun to'qnashuvi — suffixes.

  6. concatda ignore_index=True.

  7. Kalit noyobligini tekshir (qator ko'payishi).

  8. SQL JOIN bilimini ishlat.


9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

python
1.  # merge nima?
2.  # concat nima?
3.  # merge vs concat?
4.  # how nima?
5.  # inner nima?
6.  # left nima?
7.  # outer nima?
8.  # on nima?
9.  # left_on/right_on?
10. # suffixes nima?
11. # join nima?
12. # SQL bilan bog'liq?
Javoblar
  1. Kalit bo'yicha birlashtirish (JOIN)
  2. Jadvallarni ulash (ustma-ust/yonma-yon)
  3. merge — bog'lanish, concat — ulash
  4. Birlashtirish turi (inner/left/...)
  5. Faqat ikkalasida mos (default)
  6. Chap barcha + mos o'ng
  7. Ikkalasi barcha
  8. Umumiy kalit ustun
  9. Har xil nomli kalit
  10. Ustun to'qnashuvida qo'shimcha
  11. Indeks bo'yicha birlashtirish
  12. SQL JOIN ga mos

Vazifa 2: Xatolarni tuzating

python
1.  kurs.merge(muallif, on="id")  # kurs'da yo'q  # left_on/right_on

2.  pd.concat([a, b])  # indeks takror            # ignore_index

3.  yanvar.merge(fevral)  # kalit yo'q            # concat

4.  a.merge(b, on="k")  # nom_x, nom_y            # suffixes

5.  a.merge(b)  # inner, ma'lumot yo'qoldi        # how=left
Javoblar
python
1.  kurs.merge(muallif, left_on="muallif_id", right_on="id")

2.  pd.concat([a, b], ignore_index=True)

3.  pd.concat([yanvar, fevral])

4.  a.merge(b, on="k", suffixes=("_a", "_b"))

5.  a.merge(b, on="k", how="left")

Vazifa 3: merge

Bog'lanish:

  1. on (bir xil nom)
  2. left_on/right_on
  3. suffixes
  4. Guruhlash

Vazifa 4: how

Turlar:

  1. inner
  2. left
  3. right
  4. outer

Vazifa 5: concat

Ulash:

  1. Ustma-ust
  2. ignore_index
  3. axis=1
  4. Guruhlash

Vazifa 6: Uch jadval

To'liq:

  1. Ikki jadval merge
  2. Uchinchi merge
  3. Guruhlash
  4. Hisobot

Vazifa 7: O'ylash

23.12 da ma'lumotni normalizatsiya qildik (takror yo'qotish — kurs va muallif alohida jadval). Endi tahlil uchun ularni merge bilan birlashtiramiz. Bu ikki teskari amal: bo'l (normalizatsiya — saqlash uchun) va birlashtir (merge/JOIN — tahlil uchun). Nima uchun ma'lumot saqlashda bo'lingan (normallashtirilgan), lekin tahlilda birlashtirilgan shakl kerak, va bu "saqlash vs o'qish optimallashtirishi" tamoyili bilan qanday bog'liq?

Javob

Qisqa javob: Ma'lumot saqlashda bo'lingan (normallashtirilgan, 23.12 — takror yo'q, bir fakt bir joyda — yangilash oson, nomuvofiqlik yo'q), lekin tahlilda birlashtirilgan shakl kerak (bir joyda — kurs + muallif + sotuv — o'qish/hisoblash oson). Bu "saqlash vs o'qish optimallashtirishi" — ikki har xil maqsad: saqlash yozish/yangilashga optimallashtiriladi (normalizatsiya — takror yo'q, xato yo'q), o'qish/tahlil o'qishga (denormalizatsiya yoki merge — bir joyda, JOIN'siz). merge (JOIN) — saqlash shaklidan tahlil shakliga o'tish. Shuning uchun tahlilda birlashtirish kerak: saqlash shakli (bo'lingan) tahlilga noqulay. "Ma'lumot shakli maqsadga qarab" — saqlash uchun bo'l, o'qish uchun birlashtir.

1. Bo'l vs birlashtir (teskari amallar)

Bo'l (normalizatsiya) Birlashtir (merge)
Saqlash uchun Tahlil uchun
Takror yo'q Bir joyda
Yangilash oson O'qish oson
23.12 24.10

2. Nega saqlashda bo'lingan

Normalizatsiya 23.12-bob: takror yo'q (bir fakt bir joyda), yangilash oson (bir marta), nomuvofiqlik yo'q. Saqlash — yozish/yangilash optimallashtiriladi.

3. Nega tahlilda birlashtirilgan

Tahlil — o'qish (kurs + muallif + sotuv bir joyda — hisoblash oson, JOIN takror emas). Bo'lingan shakl — har savolda merge (noqulay). Birlashtirilgan — o'qishga qulay.

4. Saqlash vs o'qish optimallashtirishi

  • Saqlash (OLTP): normalizatsiya (yozish, yangilash)
  • Tahlil (OLAP): denormalizatsiya/merge (o'qish, hisobot)

Ikki har xil maqsad — har xil shakl. merge — o'tish ko'prigi.

5. Muhandislik saboqlari

  1. Saqlash — bo'l (normalizatsiya, yozish)
  2. Tahlil — birlashtir (merge, o'qish)
  3. Ma'lumot shakli maqsadga qarab
  4. merge — saqlash → tahlil ko'prigi

6. Xulosa

  1. Bo'l (saqlash) va birlashtir (tahlil) — teskari
  2. Saqlash: yozish optimali (normalizatsiya)
  3. Tahlil: o'qish optimali (merge)
  4. Ma'lumot shakli maqsadga qarab

Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.


Xulosa

Bu darsda pandas birlashtirishni o'rgandik.

Eng muhim uch fikr:

  1. merge (kalit bo'yicha — SQL JOIN). merge — ikki jadvalni umumiy ustun (kalit) bo'yicha birlashtiradi (SQL JOIN, 23.2 kabi): kurs.merge(muallif, on="muallif_id"). Kalit ko'rsatish: on="id" (bir xil nom), left_on/right_on (har xil nom — muallif_id vs id), on=["a", "b"] (ko'p kalit). Ustun to'qnashuvi (ikki jadvalda bir xil nom): pandas _x/_y qo'shadi — suffixes=("_kurs", "_mua") (aniq nom). Bog'langan ma'lumot (23.12 FK) ni bir joyga.

  2. Birlashtirish turlari va concat. how (23.2 JOIN turlari): inner (default — faqat ikkalasida mos kalit; mos bo'lmagan qatorlar tushadi), left (chap barcha + o'ng mos, mos yo'q → NaN), right (aksincha), outer (ikkalasi barcha). Tanlov muhim (inner ma'lumot yo'qotishi mumkin). concat — jadvallarni ulash (kalit yo'q): pd.concat([df1, df2], ignore_index=True) (ustma-ust — qatorlar, turli davr), axis=1 (yonma-yon — ustun). join — indeks bo'yicha (mergening indeks shakli).

  3. merge vs concat va saqlash/o'qish. merge — bog'langan jadvallar (kalit bo'yicha — kurs + muallif); concat — bir xil tuzilmali jadvallar (yanvar + fevral — ustma-ust). Qoida: bog'lanish (kalit) → merge; ulash (bir xil shakl) → concat. merge — SQL JOIN 23.2-bob ga mos. 23.12 (normalizatsiya — bo'l, saqlash uchun) va 24.10 (merge — birlashtir, tahlil uchun) — teskari amallar: ma'lumot saqlashda bo'lingan (yozish/yangilash optimali — takror yo'q), tahlilda birlashtirilgan (o'qish optimali — bir joyda). merge — saqlash shaklidan tahlil shakliga ko'prik.

Keyingi darsda pandas: vaqt qatorlari ni o'rganamiz: sana/vaqt ma'lumoti bilan ishlash — resampling, sana bo'yicha guruhlash, siljivchi oyna (moving average) — vaqt bo'yicha tahlil.

Malumot tahlili · 10-dars yakunlandi

24.10-dars: pandas — birlashtirish

16 daqvaqt
0belgi
Keyingi dars: 24.11-dars: pandas — vaqt qatorlari
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0