0Pricing
Pandas & NumPy Academy · Pelajaran

Menggabungkan Berdasarkan Indeks

Gunakan DataFrame.join() dan tetapkan left_index/right_index=True dalam merge() untuk menggabungkan DataFrames yang diselaraskan berdasarkan indeksnya.

Menggabungkan Berdasarkan Indeks adalah pelajaran Pandas & NumPy Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Pandas & NumPy Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Pandas & NumPy Academy mencakup 4 pelajaran total.

Join Berbasis Indeks

Sejauh ini, Anda telah menggabungkan DataFrames dengan mencocokkan nilai dalam kolom biasa. Namun, terkadang informasi yang ingin Anda cocokkan tersimpan dalam indeks DataFrame, bukan dalam kolom. Pandas mendukung join berbasis indeks melalui DataFrame.join() dan melalui pd.merge() dengan parameter left_index=True atau right_index=True.

Metode DataFrame.join()

DataFrame.join(other) adalah metode praktis yang secara bawaan melakukan join berdasarkan indeks kedua DataFrames. Metode ini setara dengan pemanggilan pd.merge() menggunakan left_index=True, right_index=True. Jenis join bawaannya adalah 'left', berbeda dari pd.merge() yang secara bawaan menggunakan 'inner'. Kedua DataFrames harus memiliki label indeks yang bermakna agar join menghasilkan data yang benar.

import pandas as pd

profiles = pd.DataFrame(
    {'age': [25, 30, 22]},
    index=['alice', 'bob', 'carol']
)

scores = pd.DataFrame(
    {'score': [88, 95, 70]},
    index=['alice', 'carol', 'dave']
)

# join: left join on index (default)
result = profiles.join(scores)
print(result)
#        age  score
# alice   25   88.0
# bob     30    NaN   <- bob has no score
# carol   22   95.0

Mengontrol Jenis Join dalam join()

Teruskan parameter how ke join() untuk mengontrol baris mana yang dipertahankan, sama seperti pada pd.merge(). Pilihannya adalah 'left' (bawaan), 'right', 'inner', dan 'outer'. Misalnya, how='inner' hanya mempertahankan indeks yang muncul di kedua DataFrames, sehingga baris milik alice dihapus jika tidak memiliki indeks yang cocok pada tabel kanan.

# Inner join on index: only rows present in BOTH indices
print(profiles.join(scores, how='inner'))
#        age  score
# alice   25     88
# carol   22     70

# Outer join: all indices from both
print(profiles.join(scores, how='outer'))
#        age  score
# alice  25.0   88.0
# bob    30.0    NaN
# carol  22.0   70.0
# dave    NaN   95.0

Menggabungkan Beberapa DataFrames Sekaligus

Keunggulan utama join() dibandingkan pd.merge() adalah kemampuannya menerima daftar DataFrames dan menggabungkan semuanya dengan DataFrame pemanggil dalam satu pemanggilan. Semua DataFrames harus memiliki indeks yang selaras. Ini sangat praktis jika Anda memiliki banyak tabel fitur yang semuanya diindeks berdasarkan kunci yang sama, seperti ID pengguna atau tanggal, dan ingin menyusunnya menjadi satu DataFrame lebar.

emails = pd.DataFrame({'email': ['a@x.com', 'b@x.com', 'c@x.com']},
                      index=['alice', 'bob', 'carol'])
city  = pd.DataFrame({'city': ['NY', 'LA', 'SF']},
                     index=['alice', 'bob', 'carol'])

# Join multiple DataFrames at once
result = profiles.join([emails, city])
print(result)
#        age    email city
# alice   25  a@x.com   NY
# bob     30  b@x.com   LA
# carol   22  c@x.com   SF

Menggabungkan Berdasarkan Kolom di Satu Tabel dan Indeks di Tabel Lain

pd.merge() memungkinkan Anda mencampur pencocokan berbasis kolom dan berbasis indeks dengan left_on/right_index atau left_index/right_on. Ini berguna jika satu DataFrame menyimpan kunci dalam kolom, sedangkan DataFrame lainnya menggunakannya sebagai indeks. Anda tidak dapat mencapai hal ini hanya dengan join().

# orders has customer_id as a column; customers is indexed by customer_id
customers_indexed = pd.DataFrame(
    {'name': ['Alice', 'Bob', 'Carol']},
    index=[101, 102, 103]
)
orders = pd.DataFrame({
    'order_id': [1, 2, 3],
    'customer_id': [101, 102, 101]
})

result = pd.merge(orders, customers_indexed,
                  left_on='customer_id', right_index=True)
print(result)
#    order_id  customer_id   name
# 0         1          101  Alice
# 2         3          101  Alice
# 1         2          102    Bob

Menggunakan left_index dan right_index dalam merge()

Jika kedua DataFrames memiliki kunci sebagai indeksnya, gunakan pd.merge(left, right, left_index=True, right_index=True). Ini setara dengan join(), tetapi menggunakan jenis penggabungan bawaan 'inner' dan parameter yang lebih eksplisit. Anda juga mendapatkan akses ke semua parameter pd.merge() lainnya, seperti suffixes dan indicator.

# Both DataFrames indexed by user_id
demog = pd.DataFrame({'age': [25, 30]}, index=[1, 2])
behav = pd.DataFrame({'clicks': [10, 5]}, index=[1, 2])

# Equivalent joins
result1 = demog.join(behav)  # left join
result2 = pd.merge(demog, behav, left_index=True, right_index=True)  # inner join

print(result1)
print(result2)

Mengapa Menggunakan Penggabungan Berbasis Indeks?

Penggabungan berbasis indeks lebih disukai jika DataFrames Anda secara alami menggunakan pengenal bermakna sebagai kunci, seperti ID pengguna, SKU produk, atau tanggal. Menggunakan indeks untuk penggabungan menghindarkan DataFrame Anda dari kolom kunci yang berlebihan dan dapat lebih cepat karena Pandas mempertahankan struktur indeks terurut untuk pencarian O(log n). Penggabungan ini sangat umum dalam data deret waktu, ketika DatetimeIndex menjadi kunci penggabungan alami.

# Time series example: join temperature and humidity by date index
import numpy as np
dates = pd.date_range('2024-01-01', periods=5)
temp = pd.DataFrame({'temp_c': [10, 12, 9, 11, 13]}, index=dates)
humid = pd.DataFrame({'humidity': [65, 70, 60, 75, 68]}, index=dates)

weather = temp.join(humid)
print(weather.head())

Menangani Nama Kolom yang Tumpang Tindih

Jika kedua DataFrames memiliki kolom dengan nama yang sama (selain kunci), join() secara bawaan memunculkan ValueError, kecuali Anda memberikan parameter lsuffix dan rsuffix. Parameter ini bekerja seperti suffixes dalam pd.merge(), dengan menambahkan string ke nama kolom yang tumpang tindih dari DataFrame kiri dan kanan.

df_a = pd.DataFrame({'value': [1, 2]}, index=['x', 'y'])
df_b = pd.DataFrame({'value': [10, 20]}, index=['x', 'y'])

# Without suffixes: raises ValueError
# result = df_a.join(df_b)

# With suffixes: disambiguate column names
result = df_a.join(df_b, lsuffix='_left', rsuffix='_right')
print(result)
#    value_left  value_right
# x           1           10
# y           2           20

set_index Sebelum Penggabungan

Alur kerja yang umum adalah menetapkan sebuah kolom sebagai indeks sebelum melakukan penggabungan, sehingga Anda dapat menggunakan sintaks join(). Setelah penggabungan, reset_index() mengembalikan kunci sebagai kolom biasa. Pola ini mudah dipahami: promosikan kunci menjadi indeks, lakukan penggabungan, lalu kembalikan kunci menjadi kolom, sehingga maksud kode jelas bagi pembaca berikutnya.

orders_col = pd.DataFrame({'order_id': [1,2,3], 'customer_id': [10,20,10], 'amount': [100,200,150]})
cust_col = pd.DataFrame({'customer_id': [10,20], 'name': ['Alice','Bob']})

result = (
    orders_col.set_index('customer_id')
    .join(cust_col.set_index('customer_id'), how='left')
    .reset_index()
)
print(result)

Menyelaraskan Series dengan Indeks DataFrame

Series juga memiliki indeks, dan Anda dapat menambahkannya sebagai kolom baru ke DataFrame menggunakan penetapan — Pandas secara otomatis menyelaraskan nilai Series dengan label indeks yang cocok. Ini adalah bentuk ringan dari penggabungan berbasis indeks yang berguna jika Anda ingin menambahkan satu kolom dari Series tanpa memanggil merge() atau join().

df = pd.DataFrame({'sales': [100, 200, 150]}, index=['A', 'B', 'C'])
tax_rate = pd.Series({'A': 0.1, 'B': 0.2, 'C': 0.15})

# Index alignment: Series aligns to DataFrame index automatically
df['tax'] = df['sales'] * tax_rate
print(df)
#    sales   tax
# A    100  10.0
# B    200  40.0
# C    150  22.5

Kinerja Penggabungan Indeks

Penggabungan berdasarkan indeks terurut lebih cepat daripada penggabungan berdasarkan kolom biasa karena Pandas menggunakan pencarian biner pada indeks terurut. Jika Anda berulang kali melakukan penggabungan berdasarkan kunci yang sama, tetapkan kunci tersebut sebagai indeks sekali di awal alur kerja Anda. Hal ini sangat penting dalam alur kerja deret waktu ketika Anda melakukan penggabungan berdasarkan DatetimeIndex ribuan kali pada banyak file.

# Sort index before repeated joins for speed
left = left.sort_index()
right = right.sort_index()

# Both sorted -> Pandas uses merge path with binary search
result = left.join(right, how='inner')

# Check if index is sorted
print('Left sorted:', left.index.is_monotonic_increasing)
print('Right sorted:', right.index.is_monotonic_increasing)

Pemeriksaan Cepat

Uji pemahaman Anda tentang penggabungan berbasis indeks dari pelajaran ini.

Ringkasan Pelajaran

Dalam pelajaran ini Anda mempelajari bahwa DataFrame.join() secara bawaan melakukan penggabungan berdasarkan indeks dengan penggabungan kiri; pd.merge() dengan left_index=True/right_index=True menawarkan lebih banyak kendali; Anda dapat menggabungkan beberapa DataFrames sekaligus dengan meneruskan daftar ke join(); dan penggunaan indeks terurut meningkatkan kinerja penggabungan. Selanjutnya kita akan mempelajari cara mengubah bentuk DataFrames dengan pivot_table.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Menggabungkan Berdasarkan Indeks” gratis?

Ya — teks lengkap “Menggabungkan Berdasarkan Indeks” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Pandas & NumPy Academy, upgrade ke CoddyKit PRO. Kursus Pandas & NumPy Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Menggabungkan Berdasarkan Indeks”?

Gunakan DataFrame.join() dan tetapkan left_index/right_index=True dalam merge() untuk menggabungkan DataFrames yang diselaraskan berdasarkan indeksnya. Kamu berlatih Pandas & NumPy Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Pandas & NumPy Academy?

Tidak diperlukan pengalaman sebelumnya. Pandas & NumPy Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Menggabungkan Berdasarkan Indeks” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Pandas & NumPy Academy ini?

Ya. Setiap pelajaran Pandas & NumPy Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. pd.concat untuk Menumpuk DataFrames
  2. pd.merge: Gabungan Dalam dan Luar
  3. Gabungan Kiri dan Kanan
  4. Menggabungkan Berdasarkan Indeks
← Kembali ke Pandas & NumPy Academy