pd.merge: join interno ed esterno
Unisca due DataFrame usando una colonna chiave condivisa e join interni o esterni, comprendendo quali righe vengono mantenute o eliminate.
pd.merge: join interno ed esterno è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 2 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.
Che cos'è un join?
Un join combina due DataFrame facendo corrispondere le righe in base a una colonna chiave condivisa: lo stesso concetto della clausola JOIN di SQL. Pandas implementa i join tramite pd.merge(). A differenza di pd.concat(), che si limita a impilare i dati, pd.merge() allinea in modo intelligente le righe di due tabelle diverse in base ai valori corrispondenti di una o più colonne.
La colonna chiave condivisa
Per eseguire un merge, entrambi i DataFrame devono avere almeno una colonna con valori condivisi: la colonna chiave. Ad esempio, una tabella orders ha una colonna customer_id e anche una tabella customers ha una colonna customer_id. Eseguendo il merge su customer_id, i dettagli del cliente vengono associati a ogni riga dell'ordine. Specifichi la chiave con il parametro on quando entrambi i DataFrame condividono lo stesso nome di colonna.
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']
})Join interno: intersezione delle due tabelle
Un join interno (quello predefinito) conserva solo le righe in cui il valore della chiave esiste in entrambi i DataFrame. Le righe di una delle due tabelle che non hanno una chiave corrispondente nell'altra vengono eliminate senza alcun avviso. Nell'esempio degli ordini, i clienti 103 e 104 non hanno una corrispondenza nell'altra tabella, quindi le loro righe vengono escluse dal risultato del join interno.
# 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 ordersJoin esterno: unione delle due tabelle
Un join esterno (how='outer') conserva tutte le righe di entrambi i DataFrame. Quando una riga non ha una chiave corrispondente nell'altra tabella, le colonne mancanti vengono valorizzate con NaN. È utile quando si desidera una visione completa di entrambi i dataset, mantenendo anche i record che non hanno trovato corrispondenza.
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 ordersEseguire il merge su colonne con nomi diversi
Quando la colonna chiave ha un nome diverso in ciascun DataFrame, usi left_on e right_on invece di on. Pandas fa corrispondere le righe in cui left_on nel DataFrame a sinistra è uguale a right_on nel DataFrame a destra. Nel risultato compaiono entrambe le colonne chiave; in seguito è possibile eliminare quella ridondante.
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 GadgetEseguire il merge su più colonne
Per far corrispondere le righe in base a una combinazione di colonne (una chiave composta), passi un elenco a on. È una situazione comune quando una singola colonna non è sufficiente per ottenere una corrispondenza univoca, ad esempio eseguendo il merge sia su year sia su region. Tutte le colonne elencate devono corrispondere contemporaneamente affinché una riga venga inclusa nel risultato.
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 115Gestire i nomi di colonna sovrapposti
Quando entrambi i DataFrame hanno una colonna con lo stesso nome, diversa dalla chiave, Pandas aggiunge dei suffissi per distinguerle. I valori predefiniti sono _x (a sinistra) e _y (a destra). È possibile personalizzarli con il parametro suffixes per ottenere nomi più significativi ed evitare confusione nel risultato.
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_actualControllare i duplicati imprevisti
Un problema comune nei merge è la moltiplicazione imprevista delle righe. Se la colonna chiave contiene valori duplicati in entrambi i DataFrame, il merge produce il prodotto cartesiano di tutte le righe corrispondenti. Controlli sempre il numero di righe dopo un merge: se è maggiore del previsto, analizzi i duplicati nella colonna chiave con 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 yIl parametro validate per maggiore sicurezza
Passi il parametro validate per imporre vincoli sulla relazione del merge e generare un errore se vengono violati. 'one_to_one' richiede chiavi univoche in entrambe le tabelle, 'one_to_many' richiede chiavi univoche solo nella tabella a sinistra e 'many_to_one' solo in quella a destra. È un'ottima pratica di programmazione difensiva, perché consente di individuare tempestivamente i problemi di qualità dei dati.
# 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)Controllare la copertura con indicator
Passi indicator=True per aggiungere al risultato una colonna _merge che indica l'origine di ogni riga: 'left_only', 'right_only' oppure 'both'. È utile dopo un join esterno per identificare i record che hanno trovato una corrispondenza e quelli che non l'hanno trovata, così da verificare la qualità dei dati prima di eliminare la colonna indicatrice.
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'])Riepilogo: join interno e join esterno
Per riassumere i due tipi di join: il join interno restituisce l'intersezione, cioè solo le righe con chiavi corrispondenti in entrambi i DataFrame. Il join esterno restituisce l'unione, cioè tutte le righe di entrambi i DataFrame, con NaN dove non esiste una corrispondenza. Per completezza: il join sinistro conserva tutte le righe del DataFrame a sinistra, mentre il join destro conserva tutte le righe del DataFrame a destra. Questi argomenti vengono trattati nella lezione successiva.
# 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 recordsVerifica rapida
Verifichi la sua comprensione dei join interni ed esterni di pd.merge presentati in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che pd.merge() con how='inner' conserva solo le righe corrispondenti di entrambi i DataFrame, mentre how='outer' conserva tutte le righe, usando NaN per quelle senza corrispondenza; on specifica la chiave condivisa, mentre left_on/right_on gestiscono nomi di colonna diversi; inoltre, il parametro indicator aiuta a verificare quali righe hanno trovato una corrispondenza. Ora esploreremo i join sinistri e destri per conservare tutte le righe di uno dei due lati.
Domande Frequenti
La lezione «pd.merge: join interno ed esterno» è gratuita?
Sì — il testo completo di «pd.merge: join interno ed esterno» è 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 «pd.merge: join interno ed esterno»?
Unisca due DataFrame usando una colonna chiave condivisa e join interni o esterni, comprendendo quali righe vengono mantenute o eliminate. 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 2 di 4.
Quanto tempo richiede la lezione «pd.merge: join interno ed esterno»?
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