Pandas per Python: unione di dataframe con merge()

La funzione DataFrame.merge() di Pandas serve a unire due DataFrame utilizzando chiavi condivise (keys). In questo modo è possibile combinare in modo efficiente i dati provenienti da diverse fonti per eseguire analisi più complete.

La sintassi della funzione merge() di Pandas

Il metodo merge() per i DataFrame in Pandas per Python può accettare tutta una serie di parametri che influenzano il modo in cui vengono uniti i DataFrame da combinare. La sintassi generale della funzione merge() è la seguente:

DataFrame.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)

Parametri applicabili

Utilizzando i vari parametri accettati da merge() in Pandas è possibile specificare non soltanto i DataFrame Pandas da unire, ma anche il tipo di operazione join e ulteriori dettagli.

Utilizzo di merge() in Pandas

È possibile ricorrere a diversi esempi per comprendere meglio il funzionamento di merge() in Pandas.

INNER JOIN

Una INNER JOIN unisce due DataFrame in Pandas e restituisce solo le righe in cui le chiavi dei due DataFrame coincidono. Innanzitutto, creiamo due DataFrame con dati di esempio:

import pandas as pd
# DataFrame di esempio
df1 = pd.DataFrame({
    'Chiave': ['A', 'B', 'C'],
    'Valore1': [1, 2, 3]
})
df2 = pd.DataFrame({
    'Chiave': ['B', 'C', 'D'],
    'Valore2': [4, 5, 6]
})
print(df1)
print(df2)

I due DataFrame risultanti si presentano così:

Chiave  Valore1
0         A      1
1         B      2
2         C      3
Chiave  Valore2
0         B      4
1         C      5
2         D      6

Ora è possibile eseguire una INNER JOIN utilizzando la funzione merge():

# INNER JOIN
result = pd.merge(df1, df2, how='inner', on='Chiave')
print(result)

Il risultato mostra che in questo esempio solo le righe con le chiavi B e C sono incluse nel DataFrame risultante, perché sono presenti in entrambi i DataFrame originali.

Chiave  Valore1  Valore2
0         B      2      4
1         C      3      5

OUTER JOIN

Anche una OUTER JOIN permette di unire due DataFrame. A differenza della INNER JOIN, vengono restituite tutte le righe, ma i valori mancanti vengono compilati con NaN.

# OUTER JOIN
result = pd.merge(df1, df2, how='outer', on='Chiave')
print(result)

Come previsto, il DataFrame risultante contiene tutte le righe di entrambi i DataFrame. Per la chiave A, presente solo in df1, e per la chiave D, presente solo in df2, i valori mancanti vengono inseriti come NaN.

Chiave  Valore1  Valore2
0         A    1.0    NaN
1         B    2.0    4.0
2         C    3.0    5.0
3         D    NaN    6.0

Utilizzo di left_on e right_on

A volte i due DataFrame hanno nomi di colonne chiave differenti. In questo caso è possibile utilizzare i parametri left_on e right_on per specificare quali colonne utilizzare. A tal fine, creiamo innanzitutto due nuovi DataFrame:

df3 = pd.DataFrame({
    'Chiave': ['A', 'B', 'C'],
    'Valore1': [1, 2, 3]
})
df4 = pd.DataFrame({
    'Chiave2': ['B', 'C', 'D'],
    'Valore2': [4, 5, 6]
})
print(df3)
print(df4)

I due DataFrame si presentano come segue:

Chiave  Valore1
0         A      1
1         B      2
2         C      3
Chiave2  Valore2
0          B      4
1          C      5
2          D      6

Per eseguire l’operazione JOIN con chiavi differenti, specifichiamo ora i parametri left_on e right_on:

# Join con nomi di colonne chiave differenti
result = pd.merge(df3, df4, how='inner', left_on='Chiave', right_on='Chiave2')
print(result)

L’uso esplicito di left_on='Chiave' e right_on='Chiave2' permette di utilizzare le colonne chiave corrispondenti per l’unione.

Chiave    Valore1   Chiave2  Valore2
0         B      2          B      4
1         C      3          C      5

Utilizzo di indici come chiave

In alternativa, è possibile utilizzare gli indici dei DataFrame come chiavi per l’unione impostando i parametri left_index e right_index su True. Per prima cosa, creiamo due nuovi DataFrame dotati di indici:

df5 = pd.DataFrame({
    'Valore1': [1, 2, 3]
}, index=['A', 'B', 'C'])
df6 = pd.DataFrame({
    'Valore2': [4, 5, 6]
}, index=['B', 'C', 'D'])
print(df5)
print(df6)

I DataFrame creati con il codice precedente sono i seguenti:

Valore1
A        1
B        2
C        3
    Valore2
B        4
C        5
D        6

Ora è possibile eseguire un’operazione JOIN basata sugli indici:

# JOIN con indici
result = pd.merge(df5, df6, how='inner', left_index=True, right_index=True)
print(result)

Come prevedibile, il risultato è una JOIN basata sugli indici dei DataFrame:

Valore1  Valore2
B        2        4
C        3        5