Panduan komprehensif untuk menggabungkan DataFrame di Python Pandas, membahas strategi inner, outer, left, dan right join dengan contoh praktis.
Penggabungan Python Pandas: Menguasai Strategi Penyatuan DataFrame untuk Analisis Data
Manipulasi data adalah aspek krusial dari analisis data, dan pustaka Pandas di Python menyediakan alat yang kuat untuk tujuan ini. Di antara alat-alat ini, penggabungan dan penyatuan DataFrame adalah operasi penting untuk menggabungkan set data berdasarkan kolom atau indeks umum. Panduan komprehensif ini menjelajahi berbagai strategi penyatuan DataFrame di Pandas, membekali Anda dengan pengetahuan untuk menggabungkan dan menganalisis data dari berbagai sumber secara efektif.
Memahami Penggabungan dan Penyatuan DataFrame
Menggabungkan dan menyatukan DataFrame melibatkan penggabungan dua atau lebih DataFrame menjadi satu DataFrame tunggal berdasarkan kolom atau indeks yang sama. Perbedaan utama antara `merge` dan `join` adalah bahwa `merge` adalah fungsi dari pustaka Pandas dan biasanya menggabungkan DataFrame berdasarkan kolom, sementara `join` adalah metode DataFrame yang menggabungkan DataFrame terutama berdasarkan indeks, meskipun juga dapat digunakan dengan kolom.
Konsep Kunci
- DataFrames: Struktur data berlabel dua dimensi dengan kolom-kolom yang berpotensi memiliki tipe yang berbeda.
- Kolom/Indeks Umum: Kolom atau indeks yang memiliki nama dan tipe data yang sama di seluruh DataFrame, yang berfungsi sebagai dasar untuk penggabungan/penyatuan.
- Tipe Join: Strategi yang berbeda untuk menangani baris yang tidak cocok selama proses penggabungan/penyatuan, termasuk inner, outer, left, dan right join.
Penggabungan DataFrame dengan `pd.merge()`
Fungsi `pd.merge()` adalah alat utama untuk menggabungkan DataFrame berdasarkan kolom. Fungsi ini menawarkan cara yang fleksibel untuk menggabungkan data berdasarkan satu atau lebih kolom umum.
Sintaks
pd.merge(left, right, how='inner', on=None, left_on=None, right_on=None, left_index=False, right_index=False, sort=False, suffixes=('_x', '_y'), copy=True, indicator=False, validate=None)
Parameter
- left: DataFrame kiri yang akan digabungkan.
- right: DataFrame kanan yang akan digabungkan.
- how: Jenis penggabungan yang akan dilakukan ('inner', 'outer', 'left', 'right'). Defaultnya adalah 'inner'.
- on: Nama kolom yang akan dijadikan dasar join. Kolom ini harus ada di kedua DataFrame.
- left_on: Nama kolom di DataFrame kiri yang akan digunakan sebagai kunci join.
- right_on: Nama kolom di DataFrame kanan yang akan digunakan sebagai kunci join.
- left_index: Jika True, gunakan indeks dari DataFrame kiri sebagai kunci join.
- right_index: Jika True, gunakan indeks dari DataFrame kanan sebagai kunci join.
- sort: Urutkan DataFrame hasil secara leksikografis berdasarkan kunci join. Defaultnya adalah False.
- suffixes: Sebuah tuple berisi sufiks string untuk diterapkan pada nama kolom yang tumpang tindih. Defaultnya adalah ('_x', '_y').
- copy: Jika False, hindari menyalin data ke DataFrame baru jika memungkinkan. Defaultnya adalah True.
- indicator: Jika True, tambahkan kolom bernama '_merge' yang menunjukkan sumber setiap baris.
- validate: Memeriksa apakah penggabungan sesuai dengan tipe yang ditentukan. "one_to_one", "one_to_many", "many_to_one", "many_to_many".
Penjelasan Jenis-Jenis Join
Parameter `how` di `pd.merge()` menentukan jenis join yang dilakukan. Jenis-jenis join yang berbeda menangani baris yang tidak cocok dengan cara yang berbeda.
Inner Join
Inner join hanya mengembalikan baris yang memiliki nilai yang cocok di kedua DataFrame berdasarkan kunci join. Baris dengan nilai yang tidak cocok akan dikecualikan dari hasil.
Contoh:
Perhatikan dua DataFrame berikut:
import pandas as pd
# DataFrame 1: Customer Orders
df_orders = pd.DataFrame({
'order_id': [1, 2, 3, 4, 5],
'customer_id': [101, 102, 103, 104, 105],
'product_id': [1, 2, 1, 3, 2],
'quantity': [2, 1, 3, 1, 2]
})
# DataFrame 2: Customer Information
df_customers = pd.DataFrame({
'customer_id': [101, 102, 103, 106],
'customer_name': ['Alice', 'Bob', 'Charlie', 'David'],
'country': ['USA', 'Canada', 'UK', 'Australia']
})
# Inner Join
df_inner = pd.merge(df_orders, df_customers, on='customer_id', how='inner')
print(df_inner)
Output:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
Dalam contoh ini, inner join menggabungkan DataFrame `df_orders` dan `df_customers` berdasarkan kolom `customer_id`. Hanya pelanggan yang telah melakukan pesanan yang disertakan dalam hasil. Pelanggan 'David' (customer_id 106) dikecualikan karena ia tidak memiliki pesanan apa pun.
Outer Join (Full Outer Join)
Outer join mengembalikan semua baris dari kedua DataFrame, termasuk baris yang tidak cocok. Jika sebuah baris tidak memiliki pasangan di DataFrame lain, kolom yang bersangkutan akan berisi nilai `NaN` (Not a Number).
Contoh:
# Outer Join
df_outer = pd.merge(df_orders, df_customers, on='customer_id', how='outer')
print(df_outer)
Output:
order_id customer_id product_id quantity customer_name country
0 1.0 101 1.0 2.0 Alice USA
1 2.0 102 2.0 1.0 Bob Canada
2 3.0 103 1.0 3.0 Charlie UK
3 4.0 104 3.0 1.0 NaN NaN
4 5.0 105 2.0 2.0 NaN NaN
5 NaN 106 NaN NaN David Australia
Outer join menyertakan semua pelanggan dan semua pesanan. Pelanggan 104 dan 105 memiliki pesanan tetapi tidak ada informasi pelanggan, dan pelanggan 106 memiliki informasi pelanggan tetapi tidak ada pesanan. Nilai yang hilang direpresentasikan sebagai `NaN`.
Left Join
Left join mengembalikan semua baris dari DataFrame kiri dan baris yang cocok dari DataFrame kanan. Jika sebuah baris di DataFrame kiri tidak memiliki pasangan di DataFrame kanan, kolom yang bersangkutan dari DataFrame kanan akan berisi nilai `NaN`.
Contoh:
# Left Join
df_left = pd.merge(df_orders, df_customers, on='customer_id', how='left')
print(df_left)
Output:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
3 4 104 3 1 NaN NaN
4 5 105 2 2 NaN NaN
Left join menyertakan semua pesanan dari `df_orders`. Pelanggan 104 dan 105 memiliki pesanan tetapi tidak ada informasi pelanggan, sehingga kolom `customer_name` dan `country` bernilai `NaN` untuk pesanan tersebut.
Right Join
Right join mengembalikan semua baris dari DataFrame kanan dan baris yang cocok dari DataFrame kiri. Jika sebuah baris di DataFrame kanan tidak memiliki pasangan di DataFrame kiri, kolom yang bersangkutan dari DataFrame kiri akan berisi nilai `NaN`.
Contoh:
# Right Join
df_right = pd.merge(df_orders, df_customers, on='customer_id', how='right')
print(df_right)
Output:
order_id customer_id product_id quantity customer_name country
0 1.0 101 1.0 2.0 Alice USA
1 2.0 102 2.0 1.0 Bob Canada
2 3.0 103 1.0 3.0 Charlie UK
3 NaN 106 NaN NaN David Australia
Right join menyertakan semua pelanggan dari `df_customers`. Pelanggan 106 memiliki informasi pelanggan tetapi tidak ada pesanan, sehingga kolom `order_id`, `product_id`, dan `quantity` bernilai `NaN` untuk pelanggan tersebut.
Penyatuan DataFrame dengan `df.join()`
Metode `df.join()` terutama digunakan untuk menyatukan DataFrame berdasarkan indeksnya. Metode ini juga dapat digunakan untuk join berdasarkan kolom, tetapi biasanya lebih mudah menggunakan `pd.merge()` untuk join berbasis kolom.
Sintaks
DataFrame.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)
Parameter
- other: DataFrame lain yang akan di-join.
- on: Nama kolom untuk join. Harus diisi jika indeks tidak digunakan sebagai kunci join.
- how: Cara menangani operasi dari set kiri dan kanan. Defaultnya adalah 'left'.
- lsuffix: Sufiks untuk digunakan dari DataFrame kiri untuk menimpa nama kolom yang tumpang tindih.
- rsuffix: Sufiks untuk digunakan dari DataFrame kanan untuk menimpa nama kolom yang tumpang tindih.
- sort: Urutkan DataFrame hasil secara leksikografis berdasarkan kunci join. Defaultnya adalah False.
Join Berdasarkan Indeks
Saat melakukan join pada indeks, parameter `on` tidak digunakan.
Contoh:
# DataFrame 1: Customer Orders with Customer ID as Index
df_orders_index = df_orders.set_index('customer_id')
# DataFrame 2: Customer Information with Customer ID as Index
df_customers_index = df_customers.set_index('customer_id')
# Join on Index (Left Join)
df_join_index = df_orders_index.join(df_customers_index, how='left')
print(df_join_index)
Output:
order_id product_id quantity customer_name country
customer_id
101 1 1 2 Alice USA
102 2 2 1 Bob Canada
103 3 1 3 Charlie UK
104 4 3 1 NaN NaN
105 5 2 2 NaN NaN
Dalam contoh ini, metode `join()` digunakan untuk melakukan left join pada indeks (`customer_id`). Hasilnya mirip dengan left join menggunakan `pd.merge()`, tetapi join dilakukan berdasarkan indeks, bukan kolom.
Join Berdasarkan Kolom
Untuk melakukan join pada kolom menggunakan `df.join()`, Anda perlu menentukan parameter `on`.
Contoh:
# Joining on a column
df_join_column = df_orders.join(df_customers.set_index('customer_id'), on='customer_id', how='left')
print(df_join_column)
Output:
order_id customer_id product_id quantity customer_name country
0 1 101 1 2 Alice USA
1 2 102 2 1 Bob Canada
2 3 103 1 3 Charlie UK
3 4 104 3 1 NaN NaN
4 5 105 2 2 NaN NaN
Contoh ini mendemonstrasikan penyatuan `df_orders` dengan `df_customers` menggunakan kolom `customer_id`. Perhatikan bahwa `customer_id` diatur sebagai indeks di `df_customers` sebelum melakukan join.
Menangani Kolom yang Tumpang Tindih
Saat menggabungkan atau menyatukan DataFrame, seringkali ditemukan nama kolom yang tumpang tindih (kolom dengan nama yang sama di kedua DataFrame). Pandas menyediakan parameter `suffixes` di `pd.merge()` dan parameter `lsuffix` serta `rsuffix` di `df.join()` untuk menangani situasi ini.
Menggunakan `suffixes` di `pd.merge()`
Parameter `suffixes` memungkinkan Anda untuk menentukan sufiks yang akan ditambahkan ke nama kolom yang tumpang tindih untuk membedakannya.
Contoh:
# DataFrame 1: Product Information
df_products1 = pd.DataFrame({
'product_id': [1, 2, 3],
'product_name': ['Product A', 'Product B', 'Product C'],
'price': [10, 20, 15]
})
# DataFrame 2: Product Information (with potentially updated prices)
df_products2 = pd.DataFrame({
'product_id': [1, 2, 4],
'product_name': ['Product A', 'Product B', 'Product D'],
'price': [12, 18, 25]
})
# Merge with suffixes
df_merged_suffixes = pd.merge(df_products1, df_products2, on='product_id', suffixes=('_old', '_new'))
print(df_merged_suffixes)
Output:
product_id product_name_old price_old product_name_new price_new
0 1 Product A 10 Product A 12
1 2 Product B 20 Product B 18
Dalam contoh ini, kolom `product_name` dan `price` ada di kedua DataFrame. Parameter `suffixes` menambahkan sufiks `_old` dan `_new` untuk membedakan kolom dari DataFrame kiri dan kanan.
Menggunakan `lsuffix` dan `rsuffix` di `df.join()`
Parameter `lsuffix` dan `rsuffix` menyediakan fungsionalitas serupa untuk `df.join()`. `lsuffix` ditambahkan ke kolom yang tumpang tindih di DataFrame kiri, dan `rsuffix` ke DataFrame kanan.
Contoh:
# Join with lsuffix and rsuffix
df_products1_index = df_products1.set_index('product_id')
df_products2_index = df_products2.set_index('product_id')
df_joined_suffixes = df_products1_index.join(df_products2_index, lsuffix='_old', rsuffix='_new', how='outer')
print(df_joined_suffixes)
Output:
product_name_old price_old product_name_new price_new
product_id
1 Product A 10.0 Product A 12.0
2 Product B 20.0 Product B 18.0
3 Product C 15.0 NaN NaN
4 NaN NaN Product D 25.0
Contoh Praktis dan Kasus Penggunaan
Menggabungkan dan menyatukan DataFrame banyak digunakan dalam berbagai skenario analisis data. Berikut adalah beberapa contoh praktis:
Menggabungkan Data Penjualan dengan Informasi Produk
Kasus penggunaan yang umum adalah menggabungkan data penjualan dengan informasi produk. Misalkan Anda memiliki DataFrame yang berisi transaksi penjualan dan DataFrame lain yang berisi detail produk. Anda dapat menggabungkan DataFrame ini untuk memperkaya data penjualan dengan informasi produk.
Contoh:
# Sales Transactions Data
df_sales = pd.DataFrame({
'transaction_id': [1, 2, 3, 4, 5],
'product_id': [101, 102, 103, 101, 104],
'quantity': [2, 1, 3, 1, 2],
'sales_date': ['2023-01-15', '2023-02-20', '2023-03-10', '2023-04-05', '2023-05-01']
})
# Product Information Data
df_products = pd.DataFrame({
'product_id': [101, 102, 103, 104],
'product_name': ['Laptop', 'Mouse', 'Keyboard', 'Monitor'],
'category': ['Electronics', 'Electronics', 'Electronics', 'Electronics'],
'price': [1200, 25, 75, 300]
})
# Merge Sales Data with Product Information
df_sales_enriched = pd.merge(df_sales, df_products, on='product_id', how='left')
print(df_sales_enriched)
Output:
transaction_id product_id quantity sales_date product_name category price
0 1 101 2 2023-01-15 Laptop Electronics 1200
1 2 102 1 2023-02-20 Mouse Electronics 25
2 3 103 3 2023-03-10 Keyboard Electronics 75
3 4 101 1 2023-04-05 Laptop Electronics 1200
4 5 104 2 2023-05-01 Monitor Electronics 300
DataFrame hasil `df_sales_enriched` berisi transaksi penjualan beserta informasi produk yang sesuai, memungkinkan analisis yang lebih rinci tentang tren penjualan dan kinerja produk.
Menggabungkan Data Pelanggan dengan Informasi Demografis
Kasus penggunaan umum lainnya adalah menggabungkan data pelanggan dengan informasi demografis. Hal ini memungkinkan analisis perilaku pelanggan berdasarkan faktor demografis.
Contoh:
# Customer Data
df_customers = pd.DataFrame({
'customer_id': [1, 2, 3, 4, 5],
'customer_name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin']
})
# Demographic Information Data
df_demographics = pd.DataFrame({
'city': ['New York', 'London', 'Tokyo', 'Sydney', 'Berlin'],
'population': [8419000, 8982000, 13960000, 5312000, 3769000],
'average_income': [75000, 65000, 85000, 90000, 55000]
})
# Merge Customer Data with Demographic Information
df_customer_demographics = pd.merge(df_customers, df_demographics, on='city', how='left')
print(df_customer_demographics)
Output:
customer_id customer_name city population average_income
0 1 Alice New York 8419000 75000
1 2 Bob London 8982000 65000
2 3 Charlie Tokyo 13960000 85000
3 4 David Sydney 5312000 90000
4 5 Eve Berlin 3769000 55000
DataFrame hasil `df_customer_demographics` berisi data pelanggan beserta informasi demografis untuk kota masing-masing, memungkinkan analisis perilaku pelanggan berdasarkan demografi kota.
Menganalisis Data Rantai Pasokan Global
Penggabungan Pandas sangat berharga untuk menganalisis data rantai pasokan global, di mana informasi sering tersebar di beberapa tabel. Misalnya, menghubungkan data pemasok, informasi pengiriman, dan angka penjualan dapat mengungkap hambatan dan mengoptimalkan logistik.
Contoh:
# Supplier Data
df_suppliers = pd.DataFrame({
'supplier_id': [1, 2, 3],
'supplier_name': ['GlobalTech', 'EuroParts', 'AsiaSource'],
'location': ['Taiwan', 'Germany', 'China']
})
# Shipping Data
df_shipments = pd.DataFrame({
'shipment_id': [101, 102, 103, 104],
'supplier_id': [1, 2, 3, 1],
'destination': ['USA', 'Canada', 'Australia', 'Japan'],
'shipment_date': ['2023-01-10', '2023-02-15', '2023-03-20', '2023-04-25']
})
# Merge Supplier and Shipment Data
df_supply_chain = pd.merge(df_shipments, df_suppliers, on='supplier_id', how='left')
print(df_supply_chain)
Output:
shipment_id supplier_id destination shipment_date supplier_name location
0 101 1 USA 2023-01-10 GlobalTech Taiwan
1 102 2 Canada 2023-02-15 EuroParts Germany
2 103 3 Australia 2023-03-20 AsiaSource China
3 104 1 Japan 2023-04-25 GlobalTech Taiwan
Teknik Penggabungan Tingkat Lanjut
Menggabungkan Berdasarkan Beberapa Kolom
Anda dapat menggabungkan DataFrame berdasarkan beberapa kolom dengan memberikan daftar nama kolom ke parameter `on`.
Contoh:
# DataFrame 1
df1 = pd.DataFrame({
'product_id': [1, 1, 2, 2],
'color': ['red', 'blue', 'red', 'blue'],
'quantity': [10, 15, 20, 25]
})
# DataFrame 2
df2 = pd.DataFrame({
'product_id': [1, 1, 2, 2],
'color': ['red', 'blue', 'red', 'blue'],
'price': [5, 7, 8, 10]
})
# Merge on multiple columns
df_merged_multiple = pd.merge(df1, df2, on=['product_id', 'color'], how='inner')
print(df_merged_multiple)
Output:
product_id color quantity price
0 1 red 10 5
1 1 blue 15 7
2 2 red 20 8
3 2 blue 25 10
Menggabungkan dengan Nama Kolom yang Berbeda
Jika kolom join memiliki nama yang berbeda di kedua DataFrame, Anda dapat menggunakan parameter `left_on` dan `right_on` untuk menentukan nama kolom yang akan digunakan untuk penggabungan.
Contoh:
# DataFrame 1
df1 = pd.DataFrame({
'product_id': [1, 2, 3],
'product_name': ['Product A', 'Product B', 'Product C']
})
# DataFrame 2
df2 = pd.DataFrame({
'id': [1, 2, 4],
'price': [10, 20, 25]
})
# Merge with different column names
df_merged_different = pd.merge(df1, df2, left_on='product_id', right_on='id', how='left')
print(df_merged_different)
Output:
product_id product_name id price
0 1 Product A 1.0 10.0
1 2 Product B 2.0 20.0
2 3 Product C NaN NaN
Menggunakan `indicator` untuk Analisis Penggabungan
Parameter `indicator` di `pd.merge()` menambahkan kolom bernama `_merge` ke DataFrame hasil, yang menunjukkan sumber setiap baris. Ini berguna untuk memahami baris mana yang cocok dan mana yang tidak.
Contoh:
# Merge with indicator
df_merged_indicator = pd.merge(df_orders, df_customers, on='customer_id', how='outer', indicator=True)
print(df_merged_indicator)
Output:
order_id customer_id product_id quantity customer_name country _merge
0 1.0 101 1.0 2.0 Alice USA both
1 2.0 102 2.0 1.0 Bob Canada both
2 3.0 103 1.0 3.0 Charlie UK both
3 4.0 104 3.0 1.0 NaN NaN left_only
4 5.0 105 2.0 2.0 NaN NaN left_only
5 NaN 106 NaN NaN David Australia right_only
Kolom `_merge` menunjukkan apakah baris tersebut berasal dari kedua DataFrame (`both`), hanya dari DataFrame kiri (`left_only`), atau hanya dari DataFrame kanan (`right_only`).
Memvalidasi Tipe Penggabungan
Parameter `validate` memastikan bahwa operasi penggabungan sejalan dengan tipe hubungan yang diharapkan antara DataFrame (misalnya, 'one_to_one', 'one_to_many'). Ini membantu mencegah inkonsistensi data dan kesalahan.
Contoh:
# Example with one-to-one validation
df_users = pd.DataFrame({
'user_id': [1, 2, 3],
'username': ['john_doe', 'jane_smith', 'peter_jones']
})
df_profiles = pd.DataFrame({
'user_id': [1, 2, 3],
'profile_description': ['Software Engineer', 'Data Scientist', 'Project Manager']
})
# Performing a one-to-one merge with validation
merged_df = pd.merge(df_users, df_profiles, on='user_id', validate='one_to_one')
print(merged_df)
Jika penggabungan melanggar validasi yang ditentukan (misalnya, hubungan banyak-ke-satu saat 'satu-ke-satu' ditentukan), sebuah `MergeError` akan muncul, memberitahu Anda tentang potensi masalah integritas data.
Pertimbangan Kinerja
Menggabungkan dan menyatukan DataFrame bisa memakan banyak sumber daya komputasi, terutama untuk set data besar. Berikut adalah beberapa tips untuk meningkatkan kinerja:
- Gunakan tipe join yang sesuai: Memilih tipe join yang benar dapat secara signifikan memengaruhi kinerja. Misalnya, jika Anda hanya memerlukan baris yang cocok, gunakan inner join.
- Indeks kolom join: Mengindeks kolom join dapat mempercepat proses penggabungan.
- Gunakan tipe data yang sesuai: Pastikan kolom join memiliki tipe data yang kompatibel.
- Hindari salinan yang tidak perlu: Atur `copy=False` di `pd.merge()` dan `df.join()` untuk menghindari pembuatan salinan data yang tidak perlu.
Kesimpulan
Menggabungkan dan menyatukan DataFrame adalah operasi fundamental dalam analisis data. Dengan memahami berbagai jenis join dan tekniknya, Anda dapat secara efektif menggabungkan dan menganalisis data dari berbagai sumber, membuka wawasan berharga, dan mendorong pengambilan keputusan yang terinformasi. Dari menggabungkan data penjualan dengan informasi produk hingga menganalisis rantai pasokan global, menguasai teknik-teknik ini akan memberdayakan Anda untuk menangani tugas manipulasi data yang kompleks dengan percaya diri. Ingatlah untuk mempertimbangkan implikasi kinerja saat bekerja dengan set data besar dan manfaatkan fitur-fitur canggih seperti parameter `indicator` dan `validate` untuk analisis yang lebih kuat dan mendalam.