3.9-dars: Birlashtirish (merge, concat)

3-QISM — PANDAS · 9-dars

1. Kirish va motivatsiya

Real dunyoda ma'lumot bir joyda emas: mijozlar bir jadvalda (ID, ism, shahar), buyurtmalar boshqasida (buyurtma ID, mijoz ID, summa), mahsulotlar uchinchisida. Tahlil qilish uchun ularni birlashtirish kerak — "har buyurtmaga mijoz ismini qo'shish", "ikki oylik ma'lumotni bir jadvalga yig'ish". Bu — merge (ustun bo'yicha birlashtirish, SQL JOIN kabi) va concat (jadvallarni ustma-ust yoki yonma-yon qo'shish). SQL bilgan bo'lsangiz — merge = JOIN. Nega muhim? (1) Ma'lumot bir joyda emas — turli jadvallar (normallashtirilgan bazalar); (2) Boyitish — bir jadvalga boshqasidan ustun qo'shish; (3) Yig'ish — bo'laklarni birlashtirish (oylik fayllar). Bu dars birlashtirishni o'rgatadi — turli manbalardagi ma'lumotni bir jadvalga.

Birlashtirish — jadvallarni qo'shish: merge (ustun bo'yicha — kalit ustun, SQL JOIN; on=), JOIN turlari (inner — umumiy, left — chap to'liq, right, outer — hammasi), concat (ustma-ust axis=0 yoki yonma-yon axis=1), kalit (on= — umumiy ustun), how (JOIN turi), indeks (concat — indeks saqlanadi). Foydalanish: turli jadval, boyitish, yig'ish. Bu 3.8 (groupby), SQL JOIN bilan bog'liq. merge — ustun (JOIN). concat — ustma-ust/yonma-yon. Yig'ish.

Real vaziyat. Data Scientist ikki jadval bilan ishlar edi: mijozlar (mijoz_id, ism, shahar) va buyurtmalar (buyurtma_id, mijoz_id, summa). Tahlil uchun birlashtirish kerak edi (har buyurtmaga mijoz ismi/shahri): buyurtma.merge(mijoz, on="mijoz_id") (kalit — mijoz_id; SQL JOIN kabi). JOIN turi: how="left" (barcha buyurtma — mijozi yo'q bo'lsa ham); how="inner" (faqat mos — mijozi bor buyurtma). Keyin oylik fayllarni yig'di — pd.concat([yanvar, fevral, mart]) (ustma-ust — bir yillik). Birlashtirish turli jadvallarni bir jadvalga yig'di (tahlil — mijoz + buyurtma birga). merge/concat — turli manba ma'lumotini birlashtirish (real dunyo — ma'lumot tarqoq).

Bu darsda birlashtirishni o'rganamiz.

Bu darsda:

• merge (ustun bo'yicha, JOIN)
• JOIN turlari (inner, left, right, outer)
• concat (ustma-ust, yonma-yon)
• Kalit ustun (on)
• Birlashtirish amaliyoti
• Birlashtirish tuzoqlari
• Amaliy: birlashtirish modeli
• Xulosa

ℹ Misollar real pandas bilan (deterministik) ishlaydi.

2. Nazariya — chuqur tushuntirish

2.1. merge (ustun bo'yicha, JOIN)

Kalit ustun bo'yicha birlashtirish:

import pandas as pd

mijoz = pd.DataFrame({"id": [1, 2, 3], "ism": ["Ali", "Vali", "Guli"]})
buyurtma = pd.DataFrame({"mijoz_id": [1, 2, 1], "summa": [100, 200, 150]})

# merge — kalit ustun bo'yicha (SQL JOIN)
buyurtma.merge(mijoz, left_on="mijoz_id", right_on="id")
#   mijoz_id  summa  id   ism
# 0        1    100   1   Ali
# 1        2    200   2  Vali
# 2        1    150   1   Ali

# bir xil nom bo'lsa
buyurtma.merge(mijoz, on="id")   # umumiy ustun "id"

merge (ustun bo'yicha, JOIN) — kalit ustun bo'yicha birlashtirish: buyurtma.merge(mijoz, on="id") (umumiy ustun "id" bo'yicha), left_on/right_on (turli nom). Sabab: ma'lumot turli jadvallarda (mijoz alohida, buyurtma alohida — normallashtirish); birlashtirish uchun umumiy kalit (mijoz_id — bog'laydi); merge SQL JOIN kabi (kalit bo'yicha qatorlarni moslashtiradi). on= (bir xil nom), left_on/right_on (turli nom). Natija — kengaytirilgan jadval (ikki jadval ustunlari). merge — ustun bo'yicha (JOIN, on=). Kalit. Boyitish.

2.2. JOIN turlari (inner, left, right, outer)

Qaysi qatorlar qoladi:

# how — JOIN turi
buyurtma.merge(mijoz, on="id", how="inner")   # UMUMIY (ikkalasida bor)
buyurtma.merge(mijoz, on="id", how="left")    # CHAP to'liq (buyurtma hammasi)
buyurtma.merge(mijoz, on="id", how="right")   # O'NG to'liq (mijoz hammasi)
buyurtma.merge(mijoz, on="id", how="outer")   # HAMMASI (birlashma)

# mos kelmagan → NaN

JOIN turlari (how) — qaysi qatorlar qoladi: inner (UMUMIY — ikki jadvalda ham bor kalit; standart), left (CHAP to'liq — birinchi jadval hammasi, ikkinchi mos bo'lsa qo'shiladi, yo'q → NaN), right (O'NG to'liq), outer (HAMMASI — birlashma, ikki jadval barcha kalit). Sabab: ma'lumot to'liq mos kelmaydi (ba'zi mijozning buyurtmasi yo'q, aksincha); JOIN turi qaysini saqlash (inner — faqat mos; left — chap hammasi). inner (kesishma — xavfsiz, faqat to'liq), left (chap saqlanadi — buyurtma yo'qolmasin). Mos kelmagan → NaN (left/outer). JOIN turlari — inner (umumiy), left (chap), outer (hammasi). how. Qatorlar.

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

Jadvallarni qo'shish:

yanvar = pd.DataFrame({"kun": [1, 2], "savdo": [100, 200]})
fevral = pd.DataFrame({"kun": [1, 2], "savdo": [150, 250]})

# USTMA-UST (axis=0) — qatorlarni qo'shish (standart)
pd.concat([yanvar, fevral])              # 4 qator (yanvar + fevral)
pd.concat([yanvar, fevral], ignore_index=True)   # indeks 0,1,2,3

# YONMA-YON (axis=1) — ustunlarni qo'shish
pd.concat([yanvar, fevral], axis=1)      # 4 ustun

concat (ustma-ust, yonma-yon) — jadvallarni qo'shish: axis=0 (USTMA-UST — qatorlarni qo'shish, standart; oylik fayllar → bir yillik), axis=1 (YONMA-YON — ustunlarni qo'shish). Sabab: ba'zan jadvallar bir xil tuzilma (oylik fayllar — bir xil ustun; ustma-ust yig'ish) yoki to'ldirish (yonma-yon — ustun qo'shish); concat qo'shadi (kalit kerak emas — merge dan farq). ignore_index=True (indeks 0 dan — takror indeks oldini). concat (bo'laklar yig'ish — bir xil tuzilma), merge (kalit — turli jadval). concat — ustma-ust (axis=0), yonma-yon (axis=1). Yig'ish. Kalit yo'q.

2.4. merge vs concat

merge vs concat — qachon qaysi: merge (kalit ustun bo'yicha — turli jadvallar bir kalit bilan bog'liq; mijoz + buyurtma — mijoz_id; SQL JOIN; ustunlar qo'shiladi — boyitish), concat (tuzilma bo'yicha — bir xil ustunli bo'laklar; oylik fayllar — ustma-ust; kalit kerak emas — yig'ish). Sabab: turli ehtiyoj — boyitish (bir jadvalga boshqasidan ustun — merge, kalit) yoki yig'ish (bo'laklarni — concat, tuzilma). merge — bog'lash (kalit — mos qatorlar), concat — to'plash (bir xil — ustma-ust). Chalkash: merge (kalit bor — JOIN), concat (kalit yo'q — qo'shish). merge vs concat — merge kalit (boyitish), concat tuzilma (yig'ish). Turli ehtiyoj. Kalit.

2.5. Birlashtirish amaliyoti

Birlashtirish amaliyoti: merge (kalit — on=/left_on/right_on); how (inner/left/right/outer — qatorlar); concat (ustma-ust axis=0, yonma-yon axis=1); ignore_index (concat — indeks tiklash); kalit tekshir (turlar mos — 3.6; takror kalit — ko'payish); NaN (mos kelmagan — left/outer → NaN, 3.7); tekshirish (merge/concat keyin shape — kutilganchami). Tuzoqlar: how (inner standart — qatorlar yo'qoladi; left saqlash), kalit turi (son vs matn — mos emas), takror kalit (ko'payish — kartezian), concat indeks (takror — ignore_index), NaN (mos kelmagan). Amaliyot — merge, how, concat, kalit. Boyitish. Yig'ish.

2.6. Birlashtirish tuzoqlari

Birlashtirish asosiy tuzoqlari: how standart inner (merge — standart inner (faqat umumiy); mos kelmagan qatorlar yo'qoladi (jim — buyurtma mijozi yo'q → yo'qoladi); how="left" — chap saqlanadi); kalit tur mos emas (merge kalit — bir xil tur bo'lishi kerak; son vs matn ("1" vs 1) — mos kelmaydi, bo'sh natija; astype — 3.6); takror kalit (ko'payish) (kalit noyob emas bo'lsa — har mos juftlik (kartezian); 2 buyurtma × 2 mijoz = 4 qator; kutilmagan ko'payish); concat indeks takrori (concat — indeks saqlanadi (0,1,0,1 — takror); ignore_index=True — 0 dan); ustun nom to'qnashuvi (ikki jadval bir xil ustun (merge) — _x/_y qo'shiladi; suffixes=); NaN (mos kelmagan) (left/outer — mos yo'q → NaN; tekshir 3.7); concat ustun mos emas (axis=0 — turli ustun → NaN to'ldiriladi). Sabab: birlashtirish kalit/how/indeks nozik (inner yo'qotadi, tur mos emas, takror ko'paytiradi — jim xato). Yechim: how to'g'ri, kalit tur, ignore_index, shape tekshir. Tuzoqlar — how, kalit tur, takror, indeks.

2.7. Birlashtirish — ma'lumotni bir joyga

Birlashtirish asosiy g'oyasi — ma'lumotni bir joyga: real dunyoda ma'lumot tarqoq (mijoz, buyurtma, mahsulot — turli jadvallar; normallashtirilgan baza — takror oldini); tahlil uchun birlashtirish kerak (bir jadval — mijoz + buyurtma birga). merge (kalit ustun bo'yicha — SQL JOIN; turli jadvallarni bog'lash; ustun qo'shish — boyitish; how — inner/left/outer, qaysi qatorlar), concat (tuzilma bo'yicha — bir xil ustunli bo'laklar; ustma-ust axis=0 yoki yonma-yon axis=1; yig'ish — kalit kerak emas). Data Science'da doim (turli manba — DB jadvallar, oylik fayllar, tashqi ma'lumot; birlashtirish — tahlil uchun). SQL JOIN bilgan bo'lsa — merge = JOIN (bir g'oya). Bu 3.8 (groupby) davomi va real ma'lumot (tarqoq — birlashtirish) uchun. Birlashtirish — ma'lumotni bir joyga (merge kalit, concat tuzilma). Tarqoq → bir jadval. Boyitish/yig'ish.

2.8. Birlashtirish — kuchli, lekin ehtiyot

Birlashtirish kuchli, lekin ehtiyot: birlashtirish turli manba ma'lumotini bir joyga yig'adi (kuchli — tahlil to'liq); lekin jim xato manbai (how — inner yo'qotadi; kalit tur — mos emas; takror — ko'paytiradi). Eng muhim ehtiyot: (1) how to'g'ri — inner (faqat umumiy — qator yo'qoladi) yoki left (chap saqlanadi); maqsadga qarab; (2) kalit tur — bir xil (son vs matn — mos emas); (3) takror kalit — ko'payish (kartezian — kutilmagan); (4) shape tekshir — birlashtirishdan oldin/keyin (qator soni kutilganchami — yo'qoldimi/ko'paydimi). Sabab: birlashtirish qator sonini o'zgartiradi (yo'qotish — inner; ko'payish — takror); tekshirmasa — jim xato (ma'lumot yo'qoldi/ko'paydi). Yaxshi amaliyot: how aniq, kalit tur, shape tekshir (oldin/keyin). Birlashtirish — kuchli (bir joyga) lekin ehtiyot (how/kalit/shape). Jim xato. Tekshir.

3. Tez ma'lumotnoma

import pandas as pd

# merge (ustun bo'yicha — SQL JOIN):
buyurtma.merge(mijoz, on="id")                    # umumiy ustun
buyurtma.merge(mijoz, left_on="mijoz_id", right_on="id")  # turli nom

# how (JOIN turi):
.merge(mijoz, on="id", how="inner")   # UMUMIY (standart)
.merge(mijoz, on="id", how="left")    # CHAP to'liq (yo'q → NaN)
.merge(mijoz, on="id", how="outer")   # HAMMASI (birlashma)

# concat (yig'ish — kalit yo'q):
pd.concat([yanvar, fevral])                  # ustma-ust (axis=0)
pd.concat([yanvar, fevral], ignore_index=True)   # indeks tiklash
pd.concat([a, b], axis=1)                    # yonma-yon (ustun)

# merge vs concat:
#   merge — kalit ustun (turli jadval, boyitish, JOIN)
#   concat — tuzilma (bir xil ustun, bo'lak, yig'ish)

QOIDA: merge kalit (how tekshir) · concat tuzilma (ignore_index) · shape tekshir

Birlashtirish xulosasi

Birlashtirish — ma'lumotni bir joyga (tarqoq → bir jadval)
merge — ustun bo'yicha (kalit, SQL JOIN, boyitish)
how — inner (umumiy) · left (chap) · outer (hammasi)
concat — ustma-ust (axis=0) / yonma-yon (axis=1) (yig'ish)
Ehtiyot — how (yo'qotish), kalit tur, takror (ko'payish), shape

4. Batafsil misollar

Misollar real pandas bilan (deterministik) ishlaydi.

Misol 1 — merge asoslari

"""merge: ustun bo'yicha (real pandas)."""

import pandas as pd


def main() -> None:
    mijoz = pd.DataFrame({"id": [1, 2, 3], "ism": ["Ali", "Vali", "Guli"]})
    buyurtma = pd.DataFrame({"mijoz_id": [1, 2, 1], "summa": [100, 200, 150]})

    print("=== 1. merge (kalit) ===")
    birlashgan = buyurtma.merge(mijoz, left_on="mijoz_id", right_on="id")
    print(f"  qatorlar: {len(birlashgan)}, ustunlar: {len(birlashgan.columns)}")

    print("\n=== 2. Ismlar qo'shildi ===")
    print(f"  ismlar: {list(birlashgan['ism'])}")

    print("\n=== 3. Summa bilan ===")
    print(f"  Ali buyurtmalari: {list(birlashgan[birlashgan['ism']=='Ali']['summa'])}")

    print("\n=== 4. Tushuntirish ===")
    print("  merge — kalit ustun bo'yicha (SQL JOIN)")
    print("  ⭐ merge — turli jadvalni bog'lash (boyitish)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. merge (kalit) ===
  qatorlar: 3, ustunlar: 4

=== 2. Ismlar qo'shildi ===
  ismlar: ['Ali', 'Vali', 'Ali']

=== 3. Summa bilan ===
  Ali buyurtmalari: [100, 150]

=== 4. Tushuntirish ===
  merge — kalit ustun bo'yicha (SQL JOIN)
  ⭐ merge — turli jadvalni bog'lash (boyitish)

Nima ko'rsatdi: 2.1-bo'lim.

Misol 2 — JOIN turlari

"""JOIN turlari: how (real pandas)."""

import pandas as pd


def main() -> None:
    mijoz = pd.DataFrame({"id": [1, 2, 3], "ism": ["Ali", "Vali", "Guli"]})
    buyurtma = pd.DataFrame({"id": [1, 2, 4], "summa": [100, 200, 300]})

    print("=== 1. inner (umumiy) ===")
    inner = buyurtma.merge(mijoz, on="id", how="inner")
    print(f"  qatorlar: {len(inner)} (id 1,2 — umumiy)")

    print("\n=== 2. left (chap to'liq) ===")
    left = buyurtma.merge(mijoz, on="id", how="left")
    print(f"  qatorlar: {len(left)} (buyurtma hammasi, id 4 ism NaN)")

    print("\n=== 3. outer (hammasi) ===")
    outer = buyurtma.merge(mijoz, on="id", how="outer")
    print(f"  qatorlar: {len(outer)} (id 1,2,3,4)")

    print("\n=== 4. NaN (mos kelmagan) ===")
    print(f"  left NaN ism: {left['ism'].isna().sum()}")
    print("  ⭐ how — inner/left/outer (qaysi qatorlar)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. inner (umumiy) ===
  qatorlar: 2 (id 1,2 — umumiy)

=== 2. left (chap to'liq) ===
  qatorlar: 3 (buyurtma hammasi, id 4 ism NaN)

=== 3. outer (hammasi) ===
  qatorlar: 4 (id 1,2,3,4)

=== 4. NaN (mos kelmagan) ===
  left NaN ism: 1
  ⭐ how — inner/left/outer (qaysi qatorlar)

Nima ko'rsatdi: 2.2-bo'lim.

Misol 3 — concat

"""concat: yig'ish (real pandas)."""

import pandas as pd


def main() -> None:
    yanvar = pd.DataFrame({"kun": [1, 2], "savdo": [100, 200]})
    fevral = pd.DataFrame({"kun": [1, 2], "savdo": [150, 250]})

    print("=== 1. Ustma-ust (axis=0) ===")
    yillik = pd.concat([yanvar, fevral], ignore_index=True)
    print(f"  qatorlar: {len(yillik)} (yanvar + fevral)")

    print("\n=== 2. Jami savdo ===")
    print(f"  jami: {yillik['savdo'].sum()}")

    print("\n=== 3. Yonma-yon (axis=1) ===")
    yon = pd.concat([yanvar, fevral], axis=1)
    print(f"  ustunlar: {len(yon.columns)} (4 ustun)")

    print("\n=== 4. ignore_index ===")
    print(f"  indeks: {list(yillik.index)} (0 dan)")
    print("  ⭐ concat — yig'ish (kalit yo'q)")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Ustma-ust (axis=0) ===
  qatorlar: 4 (yanvar + fevral)

=== 2. Jami savdo ===
  jami: 700

=== 3. Yonma-yon (axis=1) ===
  ustunlar: 4 (4 ustun)

=== 4. ignore_index ===
  indeks: [0, 1, 2, 3] (0 dan)
  ⭐ concat — yig'ish (kalit yo'q)

Nima ko'rsatdi: 2.3-bo'lim.

Misol 4 — Amaliy (merge + groupby)

"""Amaliy: merge + groupby (real pandas)."""

import pandas as pd


def main() -> None:
    mijoz = pd.DataFrame({
        "id": [1, 2, 3],
        "shahar": ["Toshkent", "Samarqand", "Toshkent"],
    })
    buyurtma = pd.DataFrame({
        "mijoz_id": [1, 2, 3, 1, 2],
        "summa": [100, 200, 150, 120, 250],
    })

    print("=== 1. Birlashtirish ===")
    b = buyurtma.merge(mijoz, left_on="mijoz_id", right_on="id")
    print(f"  qatorlar: {len(b)}")

    print("\n=== 2. Shahar bo'yicha jami (groupby) ===")
    shahar_savdo = b.groupby("shahar")["summa"].sum()
    print(f"  {shahar_savdo.to_dict()}")

    print("\n=== 3. Eng ko'p savdo shahri ===")
    print(f"  eng ko'p: {shahar_savdo.idxmax()}")

    print("\n=== 4. Xulosa ===")
    print("  merge (birlashtir) + groupby (guruh tahlil)")
    print("  ⭐ Birlashtirish — to'liq tahlil uchun")


if __name__ == "__main__":
    main()

Natijaning muhim qismi:

=== 1. Birlashtirish ===
  qatorlar: 5

=== 2. Shahar bo'yicha jami (groupby) ===
  {'Samarqand': 450, 'Toshkent': 370}

=== 3. Eng ko'p savdo shahri ===
  eng ko'p: Samarqand

=== 4. Xulosa ===
  merge (birlashtir) + groupby (guruh tahlil)
  ⭐ Birlashtirish — to'liq tahlil uchun

Nima ko'rsatdi: 2.7-bo'lim.

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

6. Keng tarqalgan xatolar va yechimlari

1. how standart

a.merge(b, on="id")   # inner (qatorlar yo'qolishi mumkin)   # ⚠️
a.merge(b, on="id", how="left")   # chap saqlanadi            # ✅

2. Kalit tur

a.merge(b, on="id")   # "1" vs 1 (mos emas)                  # ⚠️
a["id"] = a["id"].astype(int)   # tur mos                     # ✅

3. Takror kalit

a.merge(b, on="id")   # noyob emas → ko'payish               # ⚠️
b = b.drop_duplicates("id")   # noyob kalit                   # ✅

4. concat indeks

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

5. Ustun to'qnashuvi

a.merge(b, on="id")   # bir xil ustun → _x, _y              # ⚠️
a.merge(b, on="id", suffixes=("_a", "_b"))   # aniq nom       # ✅

6. shape tekshirmaslik

c = a.merge(b, on="id")   # qator soni noma'lum              # ⚠️
print(a.shape, c.shape)   # tekshir (yo'qoldimi/ko'paydimi)   # ✅

7. concat ustun mos emas

pd.concat([a, b])   # turli ustun → NaN to'ladi              # ⚠️
# ustunlar mos ekanini tekshir                                # ✅

7. Integratsiya — bu bilim qayerda kerak bo'ladi

• 3.8-dars (o'tilgan): groupby (merge + guruh)
• 3.3-dars (o'tilgan): O'qish (turli fayllar → concat)
• 6-qism: Tozalash (birlashtirilgan ma'lumot)
• SQL: JOIN (merge — bir g'oya)
• 20-qism: ML (turli manba xususiyatlar)

8. Eng yaxshi amaliyotlar

1. merge — kalit ustun (SQL JOIN).

2. how aniq (inner yo'qotadi, left saqlaydi).

3. Kalit turi bir xil (son vs matn).

4. Takror kalit — drop_duplicates (ko'payish).

5. concat — tuzilma (ustma-ust/yonma-yon).

6. ignore_index — concat indeks tiklash.

7. shape tekshir (oldin/keyin).

8. Birlashtirish — kuchli, lekin ehtiyot.

9. Amaliy topshiriq

Vazifa 1: Bashorat qiling

1.  # merge nima?
2.  # merge = SQL nima?
3.  # on nima?
4.  # how nima?
5.  # inner nima?
6.  # left nima?
7.  # outer nima?
8.  # concat nima?
9.  # axis=0 vs axis=1?
10. # merge vs concat?
11. # takror kalit?
12. # nega ehtiyot?

Vazifa 2: Xatolarni tuzating

1.  a.merge(b, on="id")   # chap saqlansin

2.  a.merge(b, on="id")   # "1" vs 1

3.  a.merge(b, on="id")   # takror kalit

4.  pd.concat([a, b])   # indeks tiklash

5.  c = a.merge(b, on="id")   # tekshirmasdan

1.  how="left"

2.  a["id"] = a["id"].astype(int)

3.  b.drop_duplicates("id")

4.  ignore_index=True

5.  print(a.shape, c.shape)

Vazifa 3: merge

Modellang:

1. Kalit
2. on
3. JOIN
4. Boyitish

Vazifa 4: how

Modellang:

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

Vazifa 5: concat

Modellang:

1. Ustma-ust
2. Yonma-yon
3. ignore_index
4. Yig'ish

Vazifa 6: merge vs concat

Modellang:

1. Kalit
2. Tuzilma
3. Boyitish
4. Yig'ish

Vazifa 7: O'ylash

Real ma'lumotlar bazalari ko'pincha "normallashtirilgan" — ma'lumot bir jadvalda emas, ko'p jadvalga bo'lingan (mijozlar alohida, buyurtmalar alohida), va ular kalit orqali bog'langan. Nima uchun ma'lumotni shunday bo'lish (bir katta jadval o'rniga) foydali, va nega merge (JOIN) shu sababdan Data Science'da shunchalik muhim ko'nikma?

Nimani mustahkamlaydi: 2.1, 2.7-bo'limlar.

Xulosa

Bu darsda birlashtirishni o'rgandik.

Eng muhim uch fikr:

1. merge va JOIN turlari. merge — kalit ustun bo'yicha birlashtirish (SQL JOIN kabi): buyurtma.merge(mijoz, on="id") (umumiy ustun), left_on/right_on (turli nom); turli jadvallarni bog'lash (boyitish — ustun qo'shish). JOIN turlari (how): inner (umumiy — ikkisida bor, standart), left (chap to'liq — birinchi hammasi, mos yo'q → NaN), outer (hammasi — birlashma).

2. concat va farq. concat — jadvallarni qo'shish: axis=0 (ustma-ust — qatorlar, standart; oylik fayllar → yillik), axis=1 (yonma-yon — ustunlar); ignore_index=True (indeks tiklash); kalit kerak emas. merge vs concat — merge kalit (turli jadval — boyitish, JOIN), concat tuzilma (bir xil ustun — bo'lak, yig'ish).

3. Ehtiyot bilan. Birlashtirish — ma'lumotni bir joyga (real dunyoda tarqoq — mijoz/buyurtma turli jadval, normallashtirilgan; tahlil uchun birlashtirish). Kuchli lekin ehtiyot (jim xato): how (inner yo'qotadi — left saqlash), kalit tur (son vs matn — mos emas), takror kalit (ko'payish — kartezian), shape tekshir (oldin/keyin). Data Science'da doim (DB jadvallar, oylik fayllar; SQL JOIN bir g'oya). Normallashtirish (yozish — takror yo'q) + merge (o'qish — birlashtirish). Tuzoqlar: how, kalit tur, takror, concat indeks (ignore_index).

Keyingi darsda saralash va tartiblashni o'rganamiz: ma'lumotni tartiblash (sort_values), reyting, eng katta/kichik (nlargest) — ma'lumotni tartibga solish.