Eseguire join sull'indice
Usi DataFrame.join() e imposti left_index/right_index=True in merge() per combinare DataFrame allineati in base al loro indice.
Eseguire join sull'indice è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Pandas & NumPy Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Pandas & NumPy Academy include 4 lezioni in totale.
Join basati sull'indice
Finora ha unito i DataFrame facendo corrispondere i valori presenti nelle normali colonne. A volte, però, l'informazione da usare per la corrispondenza è memorizzata nell'indice del DataFrame anziché in una colonna. Pandas supporta i join basati sull'indice tramite DataFrame.join() e tramite pd.merge() con i parametri left_index=True o right_index=True.
Il metodo DataFrame.join()
DataFrame.join(other) è un metodo di utilità che, per impostazione predefinita, esegue il join sull'indice di entrambi i DataFrame. È equivalente a una chiamata a pd.merge() con left_index=True, right_index=True. Il tipo di join predefinito è 'left', a differenza di pd.merge(), il cui valore predefinito è 'inner'. Entrambi i DataFrame devono condividere etichette di indice significative affinché il join produca risultati corretti.
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.0Controllare il tipo di join in join()
Passi il parametro how a join() per controllare quali righe mantenere, proprio come con pd.merge(). Le opzioni sono 'left' (predefinita), 'right', 'inner' e 'outer'. Ad esempio, how='inner' mantiene solo gli indici presenti in entrambi i DataFrame, eliminando la riga di alice se non avesse un indice corrispondente nella tabella di destra.
# 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.0Unire più DataFrame contemporaneamente
Un vantaggio importante di join() rispetto a pd.merge() è che accetta un elenco di DataFrame e li unisce tutti al DataFrame chiamante con una sola chiamata. Tutti i DataFrame devono essere allineati in base all'indice. È molto utile quando si hanno molte tabelle di caratteristiche indicizzate tramite la stessa chiave, ad esempio l'ID utente o la data, e si desidera assemblarle in un unico DataFrame ampio.
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 SFUnire una colonna di una tabella all'indice di un'altra
pd.merge() consente di combinare corrispondenze basate su colonne e su indici usando left_on/right_index oppure left_index/right_on. È utile quando un DataFrame contiene la chiave in una colonna, mentre l'altro la usa come indice. Non è possibile ottenere questo risultato usando solo 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 BobUsare left_index e right_index in merge()
Quando entrambi i DataFrame hanno la chiave come indice, usi pd.merge(left, right, left_index=True, right_index=True). È equivalente a join(), ma con il tipo di join predefinito 'inner' e parametri più espliciti. Avrà inoltre accesso a tutti gli altri parametri di pd.merge(), come suffixes e 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)Perché usare join basati sull'indice
I join basati sull'indice sono preferibili quando i DataFrame sono naturalmente associati a un identificatore significativo, come un ID utente, uno SKU di prodotto o una data. Usare l'indice per i join evita di aggiungere colonne di chiavi ridondanti al DataFrame e può essere più veloce, perché Pandas mantiene strutture di indice ordinate per le ricerche in O(log n). Sono particolarmente comuni nei dati di serie temporali, dove il DatetimeIndex è la chiave naturale del join.
# 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())Gestire i nomi di colonna sovrapposti
Quando entrambi i DataFrame hanno colonne con lo stesso nome (diverso da quello della chiave), join() solleva un ValueError per impostazione predefinita, a meno che non vengano forniti i parametri lsuffix e rsuffix. Questi parametri funzionano come suffixes in pd.merge() e aggiungono una stringa ai nomi delle colonne sovrapposte dei DataFrame di sinistra e di destra, rispettivamente.
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 20set_index prima del join
Un flusso di lavoro comune consiste nell'impostare una colonna come indice prima del join, così da poter usare la sintassi di join(). Dopo il join, reset_index() riporta la chiave a essere una colonna normale. Questo schema è intuitivo: si promuove la chiave a indice, si esegue il join e si riporta la chiave a colonna, rendendo chiara l'intenzione a chi leggerà il codice in futuro.
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)Allineare una Series all'indice di un DataFrame
Anche una Series ha un indice e può essere aggiunta come nuova colonna a un DataFrame tramite un'assegnazione: Pandas allinea automaticamente i valori della Series alle etichette di indice corrispondenti. È una forma leggera di join basato sull'indice, utile quando si desidera aggiungere una singola colonna da una Series senza chiamare merge() o 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.5Prestazioni dei join sull'indice
Un join su un indice ordinato è più veloce di un join su una colonna normale, perché Pandas usa la ricerca binaria sull'indice ordinato. Se esegue ripetutamente il join sulla stessa chiave, imposti quella chiave come indice una sola volta, all'inizio della pipeline. Questo è particolarmente importante nei flussi di lavoro con serie temporali, in cui si esegue il join su un DatetimeIndex migliaia di volte e su molti 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)Verifica rapida
Verifichi la Sua comprensione dei join basati sull'indice presentati in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che DataFrame.join() esegue il join sull'indice per impostazione predefinita, con un left join; pd.merge() con left_index=True/right_index=True offre un maggiore controllo; è possibile unire più DataFrame contemporaneamente passando un elenco a join(); e usare un indice ordinato migliora le prestazioni dei join. Ora esamineremo il rimodellamento dei DataFrame con pivot_table.
Domande Frequenti
La lezione «Eseguire join sull'indice» è gratuita?
Sì — il testo completo di «Eseguire join sull'indice» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Pandas & NumPy Academy, passa a CoddyKit PRO. Il corso Pandas & NumPy Academy include 4 lezioni in totale.
Cosa imparerò in «Eseguire join sull'indice»?
Usi DataFrame.join() e imposti left_index/right_index=True in merge() per combinare DataFrame allineati in base al loro indice. Eserciti Pandas & NumPy Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Pandas & NumPy Academy?
Non è richiesta alcuna esperienza precedente. Pandas & NumPy Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Eseguire join sull'indice»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Pandas & NumPy Academy?
Sì. Ogni lezione Pandas & NumPy Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- pd.concat per impilare DataFrame
- pd.merge: join interno ed esterno
- Join sinistri e destri
- Eseguire join sull'indice