Pandas & NumPy Academy · Pelajaran

pd.merge: Cantuman Dalaman dan Luaran

Gabungkan dua DataFrames berdasarkan lajur kunci yang sama menggunakan cantuman dalaman dan luaran, serta fahami baris yang dikekalkan atau digugurkan.

Pelajaran 2 daripada 413 langkah

pd.merge: Cantuman Dalaman dan Luaran ialah pelajaran Pandas & NumPy Academy percuma di CoddyKit. Ini ialah pelajaran 2 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Pandas & NumPy Academy, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Pandas & NumPy Academy merangkumi sejumlah 4 pelajaran.

Apakah Join?

Join menggabungkan dua DataFrames dengan memadankan baris berdasarkan lajur kunci yang dikongsi — konsep yang sama seperti klausa JOIN dalam SQL. Pandas melaksanakan join melalui pd.merge(). Tidak seperti pd.concat() yang hanya menindan data, pd.merge() menyelaraskan baris daripada dua jadual berbeza secara bijak berdasarkan nilai yang sepadan dalam satu atau lebih lajur.

Lajur Kunci yang Dikongsi

Untuk melaksanakan cantuman, kedua-dua DataFrames mesti mempunyai sekurang-kurangnya satu lajur dengan nilai yang dikongsi — iaitu lajur kunci. Sebagai contoh, jadual orders mempunyai lajur customer_id, dan jadual customers juga mempunyai lajur customer_id. Cantuman berdasarkan customer_id melampirkan butiran pelanggan pada setiap baris pesanan. Tentukan kunci dengan parameter on apabila kedua-dua DataFrames berkongsi nama lajur yang sama.

import pandas as pd

orders = pd.DataFrame({
    'order_id': [1, 2, 3, 4],
    'customer_id': [101, 102, 101, 103],
    'amount': [250, 80, 320, 150]
})

customers = pd.DataFrame({
    'customer_id': [101, 102, 104],
    'name': ['Alice', 'Bob', 'Diana']
})

Cantuman Dalaman: Persilangan Kedua-dua Jadual

Cantuman dalaman (lalai) hanya mengekalkan baris yang nilai kekuncinya wujud dalam kedua-dua DataFrames. Baris dalam mana-mana jadual yang tiada kunci sepadan dalam jadual yang satu lagi akan digugurkan secara senyap. Dalam contoh pesanan, pelanggan 103 dan 104 tiada padanan dalam jadual yang satu lagi, maka baris mereka dikecualikan daripada hasil cantuman dalaman.

# Inner join (default): only matching rows from both
result = pd.merge(orders, customers, on='customer_id', how='inner')
print(result)
#    order_id  customer_id  amount   name
# 0         1          101     250  Alice
# 1         3          101     320  Alice
# 2         2          102      80    Bob
# Order 4 (customer 103) dropped - no match in customers
# Diana (customer 104) dropped - no match in orders

Cantuman Luaran: Kesatuan Kedua-dua Jadual

Cantuman luaran (how='outer') mengekalkan semua baris daripada kedua-dua DataFrames. Jika sesuatu baris tiada kunci sepadan dalam jadual yang satu lagi, lajur yang hilang akan diisi dengan NaN. Ini berguna apabila anda mahukan gambaran lengkap tentang kedua-dua set data sambil mengekalkan rekod yang tidak menemukan padanan.

result = pd.merge(orders, customers, on='customer_id', how='outer')
print(result)
#    order_id  customer_id  amount   name
# 0       1.0          101   250.0  Alice
# 1       3.0          101   320.0  Alice
# 2       2.0          102    80.0    Bob
# 3       4.0          103   150.0    NaN  <- order with unknown customer
# 4       NaN          104     NaN  Diana  <- customer with no orders

Mencantumkan Lajur dengan Nama Berbeza

Apabila lajur kunci mempunyai nama berbeza dalam setiap DataFrame, gunakan left_on dan right_on dan bukannya on. Pandas memadankan baris apabila left_on dalam DataFrame kiri sama dengan right_on dalam DataFrame kanan. Kedua-dua lajur kunci muncul dalam hasil; anda boleh menggugurkan lajur yang berlebihan selepas itu.

products = pd.DataFrame({
    'prod_id': [10, 20, 30],
    'name': ['Widget', 'Gadget', 'Doohickey']
})

order_lines = pd.DataFrame({
    'item_id': [10, 10, 20],
    'qty': [3, 1, 5]
})

result = pd.merge(order_lines, products,
                  left_on='item_id', right_on='prod_id')
print(result.drop(columns='prod_id'))
#    item_id  qty    name
# 0       10    3  Widget
# 1       10    1  Widget
# 2       20    5  Gadget

Mencantumkan Berdasarkan Berbilang Lajur

Untuk memadankan baris berdasarkan gabungan lajur (kunci majmuk), hantarkan senarai kepada on. Ini lazim apabila satu lajur tidak mencukupi untuk padanan unik, seperti mencantumkan berdasarkan kedua-dua year dan region. Semua lajur yang disenaraikan mesti sepadan serentak supaya sesuatu baris dimasukkan dalam hasil.

targets = pd.DataFrame({
    'year': [2023, 2023, 2024],
    'region': ['East', 'West', 'East'],
    'target': [100, 150, 120]
})
actuals = pd.DataFrame({
    'year': [2023, 2024, 2024],
    'region': ['East', 'East', 'West'],
    'actual': [95, 115, 80]
})

result = pd.merge(targets, actuals, on=['year', 'region'], how='inner')
print(result)
#    year region  target  actual
# 0  2023   East     100      95
# 1  2024   East     120     115

Mengendalikan Nama Lajur yang Bertindih

Apabila kedua-dua DataFrames mempunyai lajur dengan nama yang sama (selain kunci), Pandas menambahkan akhiran untuk membezakannya. Nilai lalai ialah _x (kiri) dan _y (kanan). Anda boleh menyesuaikannya dengan parameter suffixes untuk menghasilkan nama yang lebih bermakna dan mengelakkan kekeliruan dalam hasil.

df_a = pd.DataFrame({'id': [1, 2], 'value': [10, 20]})
df_b = pd.DataFrame({'id': [1, 2], 'value': [100, 200]})

# Default suffixes
print(pd.merge(df_a, df_b, on='id'))
#    id  value_x  value_y

# Custom suffixes
print(pd.merge(df_a, df_b, on='id', suffixes=('_budget', '_actual')))
#    id  value_budget  value_actual

Menyemak Pendua yang Tidak Dijangka

Perangkap lazim dalam cantuman ialah penggandaan baris yang tidak dijangka. Jika lajur kunci mempunyai nilai pendua dalam kedua-dua DataFrames, cantuman menghasilkan hasil darab Cartesian bagi semua baris yang sepadan. Sentiasa semak bilangan baris selepas cantuman: jika bilangannya lebih besar daripada jangkaan, siasat pendua dalam lajur kunci dengan df.duplicated(subset=['key']).sum().

# Both tables have duplicate keys -> cartesian product
left = pd.DataFrame({'id': [1, 1], 'val_l': ['a', 'b']})
right = pd.DataFrame({'id': [1, 1], 'val_r': ['x', 'y']})

result = pd.merge(left, right, on='id')
print(len(result))  # 4 rows! (2x2 cartesian product)
print(result)
#    id val_l val_r
# 0   1     a     x
# 1   1     a     y
# 2   1     b     x
# 3   1     b     y

Parameter validate untuk Keselamatan

Hantarkan parameter validate untuk menguatkuasakan kekangan hubungan pada cantuman dan menghasilkan ralat jika kekangan tersebut dilanggar. 'one_to_one' memerlukan kunci unik dalam kedua-dua jadual, 'one_to_many' memerlukan kunci unik hanya dalam jadual kiri, manakala 'many_to_one' hanya dalam jadual kanan. Ini ialah amalan pengaturcaraan defensif yang sangat baik kerana dapat mengesan isu kualiti data lebih awal.

# Safe merge: validate that customer_id is unique in customers
try:
    result = pd.merge(orders, customers,
                      on='customer_id',
                      how='inner',
                      validate='many_to_one')
    print('Merge OK, shape:', result.shape)
except Exception as e:
    print('Merge error:', e)

Menyemak Liputan dengan indicator

Hantarkan indicator=True untuk menambahkan lajur _merge pada hasil yang menunjukkan asal setiap baris: 'left_only', 'right_only', atau 'both'. Ini berguna selepas cantuman luaran untuk mengenal pasti rekod yang menemukan padanan dan yang tidak, sekali gus membantu anda mengaudit kualiti data sebelum menggugurkan lajur penunjuk tersebut.

result = pd.merge(orders, customers, on='customer_id',
                  how='outer', indicator=True)
print(result['_merge'].value_counts())
# both           3
# left_only      1  <- orders with no customer record
# right_only     1  <- customers with no orders

# Find unmatched orders
print(result[result['_merge'] == 'left_only'])

Ringkasan Dalaman berbanding Luaran

Ringkasnya, bagi kedua-dua jenis cantuman: cantuman dalaman memberikan persilangan — hanya baris dengan kunci sepadan dalam kedua-dua DataFrames. Cantuman luaran memberikan kesatuan — semua baris daripada kedua-dua DataFrames, dengan NaN apabila tiada padanan. Untuk melengkapkan gambaran: cantuman kiri mengekalkan semua baris daripada DataFrame kiri, manakala cantuman kanan mengekalkan semua baris daripada DataFrame kanan. Perkara ini akan dibincangkan dalam pelajaran seterusnya.

# Quick reference
# how='inner'  -> intersection: only matched rows
# how='outer'  -> union: all rows from both, NaN for no match
# how='left'   -> all left rows + matched right rows
# how='right'  -> all right rows + matched left rows

# Most common: inner (default) for enrichment, left for preserving records

Semakan Pantas

Uji pemahaman anda tentang cantuman dalaman dan luaran pd.merge daripada pelajaran ini.

Jawab dalam pelajaran interaktif

Ulang Kaji Pelajaran

Dalam pelajaran ini, anda telah mempelajari: pd.merge() dengan how='inner' hanya mengekalkan baris yang sepadan daripada kedua-dua DataFrames, manakala how='outer' mengekalkan semua baris dengan NaN untuk baris yang tiada padanan; on menentukan kunci yang dikongsi, manakala left_on/right_on mengendalikan nama lajur yang berbeza; dan parameter indicator membantu mengaudit baris yang sepadan. Seterusnya, kita akan meneroka cantuman kiri dan kanan untuk mengekalkan semua baris dari satu sisi.

Percuma untuk bermula

Pelajari Python dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 30
Pelajaran: 120

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “pd.merge: Cantuman Dalaman dan Luaran” percuma?

Ya — teks penuh “pd.merge: Cantuman Dalaman dan Luaran” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Pandas & NumPy Academy, tingkat taraf kepada CoddyKit PRO. Kursus Pandas & NumPy Academy merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “pd.merge: Cantuman Dalaman dan Luaran”?

Gabungkan dua DataFrames berdasarkan lajur kunci yang sama menggunakan cantuman dalaman dan luaran, serta fahami baris yang dikekalkan atau digugurkan. Anda berlatih Pandas & NumPy Academy menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Pandas & NumPy Academy?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Pandas & NumPy Academy di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 2 daripada 4.

Berapa lamakah pelajaran “pd.merge: Cantuman Dalaman dan Luaran” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Pandas & NumPy Academy ini?

Ya. Setiap pelajaran Pandas & NumPy Academy menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Pandas & NumPy Academy