Pandas per Python: unione di dataframe con merge()

La funzione DataFrame.merge() di Pandas serve a unire due DataFrame uti­liz­zan­do chiavi condivise (keys). In questo modo è possibile combinare in modo ef­fi­cien­te i dati pro­ve­nien­ti 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 in­fluen­za­no 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 ap­pli­ca­bi­li

Uti­liz­zan­do i vari parametri accettati da merge() in Pandas è possibile spe­ci­fi­ca­re non soltanto i DataFrame Pandas da unire, ma anche il tipo di ope­ra­zio­ne join e ulteriori dettagli.

Utilizzo di merge() in Pandas

È possibile ricorrere a diversi esempi per com­pren­de­re meglio il fun­zio­na­men­to di merge() in Pandas.

INNER JOIN

Una INNER JOIN unisce due DataFrame in Pandas e re­sti­tui­sce solo le righe in cui le chiavi dei due DataFrame coin­ci­do­no. In­nan­zi­tut­to, 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 ri­sul­tan­ti si pre­sen­ta­no 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 uti­liz­zan­do 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 ri­sul­tan­te, 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 dif­fe­ren­za della INNER JOIN, vengono re­sti­tui­te 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 ri­sul­tan­te 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 dif­fe­ren­ti. In questo caso è possibile uti­liz­za­re i parametri left_on e right_on per spe­ci­fi­ca­re quali colonne uti­liz­za­re. A tal fine, creiamo in­nan­zi­tut­to 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 pre­sen­ta­no 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’ope­ra­zio­ne JOIN con chiavi dif­fe­ren­ti, spe­ci­fi­chia­mo 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 uti­liz­za­re le colonne chiave cor­ri­spon­den­ti per l’unione.

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

Utilizzo di indici come chiave

In al­ter­na­ti­va, è possibile uti­liz­za­re gli indici dei DataFrame come chiavi per l’unione im­po­stan­do 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 pre­ce­den­te sono i seguenti:

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

Ora è possibile eseguire un’ope­ra­zio­ne JOIN basata sugli indici:

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

Come pre­ve­di­bi­le, il risultato è una JOIN basata sugli indici dei DataFrame:

Valore1  Valore2
B        2        4
C        3        5