# 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](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/pandas-di-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: ```python 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) ``` N.B. La funzione `merge()` di Pandas equivale all’operazione [SQL JOIN](https://www.ionos.it/digitalguide/server/configurazione/comandi-sql-join/) nei [database relazionali](https://www.ionos.it/digitalguide/hosting/tecniche-hosting/database-relazionale/). Pertanto avere dimestichezza con i linguaggi per database come [SQL](https://www.ionos.it/digitalguide/server/know-how/che-cose-sql/) ti sarà utile per capire il funzionamento del metodo `merge()` per i DataFrame in Pandas. Tuttavia, ricorda che in questo caso il comportamento è leggermente diverso: se entrambe le colonne chiave contengono valori in cui la chiave è *null*, anche questi valori vengono uniti. ### Parametri applicabili Utilizzando i vari parametri accettati da `merge()` in Pandas è possibile specificare non soltanto i [DataFrame Pandas](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/dataframe-in-pandas-per-python/) da unire, ma anche il tipo di operazione join e ulteriori dettagli.
Parametro Descrizione Valore standard
`left` Primo DataFrame da unire
`right` Secondo DataFrame da unire
`how` Tipo di operazione join da eseguire (`inner`, `outer`, `left` o `right`) `inner`
`on` Colonna o livello/i di indice utilizzati come chiavi; deve essere presente in entrambi i DataFrame
`left_on` Colonna o livello/i di indice del DataFrame sinistro utilizzato come chiave
`right_on` Colonna o livello/i di indice del DataFrame destro utilizzato come chiave
`left_index` Se `True`, l’indice del DataFrame sinistro viene utilizzato come chiave `False`
`right_index` Se `True`, l’indice del DataFrame destro viene utilizzato come chiave `False`
`sort` Se `True`, le chiavi del DataFrame risultanti vengono messe in ordine lessicografico. `False`
`suffixes` Suffissi utilizzati per rendere univoche le colonne con lo stesso nome `("_x", "_y")`
`copy` Se `False`, evita che venga eseguita una copia `True`
## Utilizzo di `merge()` in Pandas È possibile ricorrere a diversi esempi per comprendere meglio il funzionamento di `merge()` in Pandas. ### `INNER JOIN` Una [INNER JOIN](https://www.ionos.it/digitalguide/hosting/tecniche-hosting/inner-join-sql/) 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: ```python 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ì: ```none 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()`: ```python # 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**. ```none 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`. ```python # 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`. ```none 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 ``` N.B. Tutte le altre varianti note di `JOIN` funzionano in modo simile. ### 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: ```python 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: ```none 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`: ```python # 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. ```none 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: ```python 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: ```none Valore1 A 1 B 2 C 3 Valore2 B 4 C 5 D 6 ``` Ora è possibile eseguire un’operazione `JOIN` basata sugli indici: ```python # 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: ```none Valore1 Valore2 B 2 4 C 3 5 ``` This is a markdown version of: [https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/dataframe-merge-in-pandas-per-python/](https://www.ionos.it/digitalguide/siti-web/programmazione-del-sito-web/dataframe-merge-in-pandas-per-python/) for AI/LLM consumption.