24.10-dars: pandas — birlashtirish
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:
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 |
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:
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:
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:
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:
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
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 JOIN4. Batafsil misollar
Misollarda pandas (
import pandas as pd) bilan sinaladi.
Misol 1 — merge (bog'langan jadvallar)
"""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:
=== 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)
"""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:
=== 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)
"""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:
=== 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 ulashNima 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.
"""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:
=== 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 hisobotNima 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
a.merge(b, on="k") # mos bo'lmagan tushadi # ba'zan kutilmagan
a.merge(b, on="k", how="left") # chap saqlanadi # ✅ kerak bo'lsa2. Kalit nom har xil
kurs.merge(muallif, on="id") # kurs'da id yo'q # ⚠️
kurs.merge(muallif, left_on="muallif_id", right_on="id") # ✅3. concatda indeks takror
pd.concat([a, b]) # indeks 0,1,0,1 # ⚠️
pd.concat([a, b], ignore_index=True) # ✅4. mergeni concat o'rniga (bir xil ustun)
yanvar.merge(fevral) # kalit yo'q # ⚠️
pd.concat([yanvar, fevral]) # ✅ ulash5. Ko'p-ko'p merge (qator ko'payadi)
# kalit takrorlansa, qatorlar ko'payadi (kartezian) # ehtiyot
# kalit noyob bo'lsin (yoki kutilgan)6. Ustun to'qnashuvi (noaniq nom)
a.merge(b, on="k") # nom_x, nom_y (noaniq) # ⚠️
a.merge(b, on="k", suffixes=("_a", "_b")) # ✅7. outerda ko'p NaN
a.merge(b, on="k", how="outer") # ko'p bo'sh (NaN) # ehtiyot
# fillna yoki kerakli how tanla7. 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
Bog'langan jadvallar —
merge(kalit).Bir xil tuzilma —
concat.howni ongli tanla (inner/left).Har xil kalit nom —
left_on/right_on.Ustun to'qnashuvi —
suffixes.concatdaignore_index=True.Kalit noyobligini tekshir (qator ko'payishi).
SQL JOIN bilimini ishlat.
9. Amaliy topshiriq
Vazifa 1: Bashorat qiling
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
- Kalit bo'yicha birlashtirish (JOIN)
- Jadvallarni ulash (ustma-ust/yonma-yon)
- merge — bog'lanish, concat — ulash
- Birlashtirish turi (inner/left/...)
- Faqat ikkalasida mos (default)
- Chap barcha + mos o'ng
- Ikkalasi barcha
- Umumiy kalit ustun
- Har xil nomli kalit
- Ustun to'qnashuvida qo'shimcha
- Indeks bo'yicha birlashtirish
- SQL JOIN ga mos
Vazifa 2: Xatolarni tuzating
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=leftJavoblar
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:
on(bir xil nom)left_on/right_onsuffixes- Guruhlash
Vazifa 4: how
Turlar:
innerleftrightouter
Vazifa 5: concat
Ulash:
- Ustma-ust
ignore_indexaxis=1- Guruhlash
Vazifa 6: Uch jadval
To'liq:
- Ikki jadval merge
- Uchinchi merge
- Guruhlash
- 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
- Saqlash — bo'l (normalizatsiya, yozish)
- Tahlil — birlashtir (merge, o'qish)
- Ma'lumot shakli maqsadga qarab
- merge — saqlash → tahlil ko'prigi
6. Xulosa
- Bo'l (saqlash) va birlashtir (tahlil) — teskari
- Saqlash: yozish optimali (normalizatsiya)
- Tahlil: o'qish optimali (merge)
- Ma'lumot shakli maqsadga qarab
Nimani mustahkamlaydi: 2.1–2.8-bo'limlar.
Xulosa
Bu darsda pandas birlashtirishni o'rgandik.
Eng muhim uch fikr:
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_idvsid),on=["a", "b"](ko'p kalit). Ustun to'qnashuvi (ikki jadvalda bir xil nom): pandas_x/_yqo'shadi —suffixes=("_kurs", "_mua")(aniq nom). Bog'langan ma'lumot (23.12 FK) ni bir joyga.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 (innerma'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).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— SQLJOIN23.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.
Izohlar · 0
Izoh yozish uchun kiring.