Pandas è una delle librerie più popolari e potenti in Python per la manipolazione e l’analisi dei dati. Se sei un data scientist, un analista o semplicemente un appassionato di dati, saper utilizzare Pandas è essenziale per gestire, pulire e analizzare grandi quantità di informazioni in modo efficiente. In questa lezione avanzata, esploreremo le operazioni più importanti che Pandas offre, dall’importazione dei dati alla manipolazione, pulizia, analisi statistica e molto altro.
Pandas è particolarmente utile per lavorare con dati strutturati, come tabelle e serie temporali, e offre strumenti flessibili per gestire dati complessi. Che tu stia lavorando su un progetto di machine learning, analisi finanziaria o semplicemente cercando di organizzare i tuoi dati, Pandas è uno strumento indispensabile.
Di seguito ti mostro quali sono le operazioni avanzate da utilizzare con Pandas quando si lavora con grandi quantità di dati:
1. Importazione dei Dati
Il primo passo per lavorare con i dati è importarli. Pandas supporta una vasta gamma di formati di file, rendendo facile l’integrazione con diverse fonti di dati.
- CSV:
pd.read_csv('file.csv')
I file CSV sono uno dei formati più comuni per i dati tabellari. Pandas permette di importarli con una semplice funzione. - Excel:
pd.read_excel('file.xlsx')
Se i dati sono in un foglio di calcolo Excel, Pandas può leggerli direttamente. - SQL:
pd.read_sql(query, connection)
Pandas può interfacciarsi con database SQL, permettendo di eseguire query e importare i risultati direttamente in un DataFrame. - JSON:
pd.read_json('file.json')
Per dati strutturati in formato JSON, Pandas offre un supporto nativo. - Parquet:
pd.read_parquet('file.parquet')
Il formato Parquet è ottimizzato per l’archiviazione di grandi volumi di dati ed è supportato da Pandas.
2. Manipolazione dei Dati
Una volta importati i dati, è possibile manipolarli per adattarli alle proprie esigenze. Pandas offre una vasta gamma di operazioni per raggruppare, unire, pivotare e ordinare i dati.
- Grouping:
df.groupby('colonna').mean()
Raggruppa i dati in base a una colonna e applica una funzione di aggregazione, come la media. - Merging:
pd.merge(df1, df2, on='chiave')
Unisce due DataFrame in base a una chiave comune, simile a un JOIN in SQL. - Pivoting:
df.pivot(index='data', columns='categoria', values='valore')
Trasforma i dati da un formato lungo a uno largo, utile per analisi tabellari. - Sorting:
df.sort_values(by='colonna')
Ordina i dati in base ai valori di una colonna specifica. - Melting:
pd.melt(df, id_vars=['id'], value_vars=['A', 'B'])
Trasforma i dati da un formato largo a uno lungo, utile per la preparazione dei dati. - Applying functions:
df.apply(lambda x: x*2)
Applica una funzione a ogni elemento del DataFrame.
3. Pulizia dei Dati
La pulizia dei dati è un passaggio cruciale per garantire che l’analisi sia accurata. Pandas offre diverse funzioni per gestire dati mancanti, duplicati e valori errati.
- Gestione dei dati mancanti:
df.dropna(),df.fillna(valore)
Rimuove le righe con valori mancanti o li sostituisce con un valore specifico. - Rimozione duplicati:
df.drop_duplicates()
Elimina le righe duplicate nel DataFrame. - Sostituzione valori:
df.replace({'vecchio': 'nuovo'})
Sostituisce valori specifici con altri. - Cambio tipo di dati:
df['colonna'].astype('int')
Cambia il tipo di dati di una colonna, ad esempio da float a intero. - Interpolazione:
df.interpolate()
Riempie i valori mancanti interpolando tra i valori esistenti.
4. Operazioni su Stringhe
Pandas offre strumenti potenti per lavorare con dati di tipo stringa, come la ricerca di pattern, l’estrazione di sottostringhe e la conversione di case.
- Pattern matching:
df['colonna'].str.contains('pattern')
Verifica se una stringa contiene un determinato pattern. - Estrazione:
df['colonna'].str.extract(r'(pattern)')
Estrae parti di una stringa che corrispondono a un pattern. - Splitting:
df['colonna'].str.split(' ')
Divide una stringa in più parti in base a un delimitatore. - Conversione case:
df['colonna'].str.upper()
Converte tutte le lettere in maiuscolo. - Stripping:
df['colonna'].str.strip()
Rimuove spazi bianchi all’inizio e alla fine di una stringa. - Sostituzione:
df['colonna'].str.replace('vecchio', 'nuovo')
Sostituisce una sottostringa con un’altra.
5. Esportazione dei Dati
Dopo aver manipolato e analizzato i dati, è spesso necessario esportarli in un formato specifico per condividerli o archiviarli.
- CSV:
df.to_csv('file.csv')
Esporta i dati in un file CSV. - Excel:
df.to_excel('file.xlsx')
Esporta i dati in un file Excel. - SQL:
df.to_sql('tabella', connessione)
Salva i dati in una tabella SQL. - JSON:
df.to_json('file.json')
Esporta i dati in formato JSON. - Parquet:
df.to_parquet('file.parquet')
Esporta i dati in formato Parquet.
6. Selezione dei Dati
Pandas permette di selezionare dati specifici in base a condizioni o posizioni.
- Per colonna:
df['colonna']
Seleziona una singola colonna. - Per riga:
df.iloc[0]
Seleziona una riga specifica. - Subset:
df.loc[df['colonna'] > valore]
Seleziona un sottoinsieme di righe in base a una condizione. - SQL-like queries:
df.query('colonna > valore')
Esegue query simili a SQL direttamente sul DataFrame. - Value checks:
df[df['colonna'].isin([valore1, valore2])]
Seleziona righe in cui i valori di una colonna sono in un elenco specifico.
7. Analisi Statistica
Pandas offre funzioni integrate per calcolare statistiche descrittive e analisi avanzate.
- Summary statistics:
df.describe()
Fornisce statistiche di base come media, deviazione standard e quantili. - Aggregazioni:
df.agg(['mean', 'sum'])
Applica più funzioni di aggregazione contemporaneamente. - Value counts:
df['colonna'].value_counts()
Conta le occorrenze di ciascun valore in una colonna. - Correlazioni:
df.corr()
Calcola la correlazione tra le colonne. - Covarianza:
df.cov()
Calcola la covarianza tra le colonne. - Quantili:
df.quantile(0.25)
Calcola i quantili specificati.
8. Serie Temporali
Pandas è particolarmente potente quando si lavora con dati temporali, come serie storiche o dati finanziari.
- Resampling:
df.resample('M').mean()
Ricampiona i dati in base a un intervallo di tempo, ad esempio mensile. - Rolling calculations:
df.rolling(window=3).mean()
Calcola una media mobile su una finestra di tempo. - Shifting values:
df.shift(1)
Sposta i valori di una colonna in avanti o indietro nel tempo. - Generazione date:
pd.date_range(start='1/1/2022', periods=5)
Genera un intervallo di date. - Formattazione date:
df['data'].dt.strftime('%Y-%m-%d')
Formatta le date in un formato specifico.
9. Funzionalità Avanzate
Pandas offre anche funzionalità avanzate per ottimizzare il flusso di lavoro e migliorare l’efficienza.
- Method chaining:
df.query('colonna > valore').groupby('categoria').mean()
Combina più operazioni in una singola linea di codice. - Expression evaluation:
pd.eval('df1 + df2')
Valuta espressioni complesse in modo efficiente. - Memory usage:
df.memory_usage(deep=True)
Mostra l’utilizzo della memoria da parte del DataFrame. - Selezione tipi di dati:
df.select_dtypes(include=['int'])
Seleziona solo le colonne di un tipo di dato specifico. - Top values:
df.nlargest(3, 'colonna')
Trova i valori più grandi in una colonna. - Exploding list columns:
df.explode('colonna_lista')
Espande una colonna contenente liste in righe separate.
10. Consigli e Best Practices
Per lavorare in modo efficiente con Pandas, ecco alcuni consigli utili:
- Usare
.copy():df_copy = df.copy()
Crea una copia del DataFrame per evitare modifiche indesiderate. - Method chaining:
(df.filter(items=['A', 'B']).assign(C=lambda x: x['A'] + x['B']))
Combina più operazioni in una catena per migliorare la leggibilità. - Attenzione a
inplace=True:df.dropna(inplace=True)
Usainplace=Truecon cautela, poiché modifica direttamente il DataFrame.
Di seguito fornisco un esempio di codice che copre alcune delle operazioni descritte nel testo, come l’importazione dei dati, la manipolazione, la pulizia, l’analisi statistica e le operazioni su stringhe.
Codice Completo
import pandas as pd # 1. Importazione dei Dati # Importiamo un dataset da un file CSV df = pd.read_csv('data.csv') # 2. Manipolazione dei Dati # Aggiungiamo una nuova colonna calcolata df['nuova_colonna'] = df['colonna1'] + df['colonna2'] # Raggruppiamo i dati per una colonna e calcoliamo la media grouped = df.groupby('categoria')['valore'].mean() # Uniamo due DataFrame in base a una chiave comune df2 = pd.read_csv('data2.csv') merged_df = pd.merge(df, df2, on='chiave') # 3. Pulizia dei Dati # Rimuoviamo i duplicati df = df.drop_duplicates() # Sostituiamo i valori mancanti con 0 df['colonna'].fillna(0, inplace=True) # Cambiamo il tipo di dati di una colonna df['colonna'] = df['colonna'].astype(int) # 4. Operazioni su Stringhe # Convertiamo una colonna di stringhe in maiuscolo df['colonna_stringa'] = df['colonna_stringa'].str.upper() # Estraiamo una sottostringa usando un pattern df['sottostringa'] = df['colonna_stringa'].str.extract(r'(\d+)') # 5. Analisi Statistica # Calcoliamo le statistiche di base summary_stats = df.describe() # Calcoliamo la correlazione tra due colonne correlation = df[['colonna1', 'colonna2']].corr() # 6. Serie Temporali # Convertiamo una colonna in formato datetime df['data'] = pd.to_datetime(df['data']) # Ricampioniamo i dati su base mensile resampled_df = df.resample('M', on='data').mean() # 7. Esportazione dei Dati # Esportiamo il DataFrame pulito in un nuovo file CSV df.to_csv('dati_puliti.csv', index=False) # 8. Selezione dei Dati # Selezioniamo un sottoinsieme di righe in base a una condizione subset_df = df.loc[df['colonna'] > 10] # 9. Funzionalità Avanzate # Usiamo il method chaining per filtrare e aggregare i dati result = (df.query('colonna > 5') .groupby('categoria') .agg({'valore': ['mean', 'sum']})) # 10. Consigli e Best Practices # Creiamo una copia del DataFrame per evitare modifiche indesiderate df_copy = df.copy() # Usiamo il method chaining per migliorare la leggibilità df_filtered = (df.filter(items=['colonna1', 'colonna2']) .assign(nuova_colonna=lambda x: x['colonna1'] + x['colonna2'])) # Stampiamo i risultati print("Statistiche di Base:\n", summary_stats) print("Correlazione tra colonna1 e colonna2:\n", correlation) print("Dati Ricampionati:\n", resampled_df) print("Risultato del Method Chaining:\n", result)
Spiegazione del Codice
- Importazione dei Dati: Il dataset viene importato da un file CSV utilizzando
pd.read_csv(). - Manipolazione dei Dati: Viene creata una nuova colonna calcolata, i dati vengono raggruppati e viene eseguita un’operazione di merge tra due DataFrame.
- Pulizia dei Dati: I duplicati vengono rimossi, i valori mancanti vengono sostituiti con 0 e il tipo di dati di una colonna viene cambiato.
- Operazioni su Stringhe: Una colonna di stringhe viene convertita in maiuscolo e viene estratta una sottostringa usando un pattern.
- Analisi Statistica: Vengono calcolate le statistiche di base e la correlazione tra due colonne.
- Serie Temporali: Una colonna viene convertita in formato datetime e i dati vengono ricampionati su base mensile.
- Esportazione dei Dati: Il DataFrame pulito viene esportato in un nuovo file CSV.
- Selezione dei Dati: Viene selezionato un sottoinsieme di righe in base a una condizione.
- Funzionalità Avanzate: Viene utilizzato il method chaining per filtrare e aggregare i dati.
- Consigli e Best Practices: Viene creata una copia del DataFrame e viene utilizzato il method chaining per migliorare la leggibilità.
Questo esempio copre molte delle operazioni descritte nel testo e fornisce una panoramica pratica su come utilizzare Pandas per la manipolazione e l’analisi dei dati.
Domande Frequenti (FAQ)
1. Qual è la differenza tra loc e iloc in Pandas?
loc seleziona in base alle etichette (label), mentre iloc seleziona in base agli indici di posizione.
2. Come posso unire due DataFrame in Pandas?
Puoi usare pd.merge(df1, df2, on='chiave') per unire due DataFrame in base a una colonna comune.
3. Come posso gestire i dati mancanti in Pandas?
Puoi usare df.dropna() per rimuovere righe con valori mancanti o df.fillna(valore) per sostituirli con un valore specifico.
4. Qual è il modo migliore per lavorare con dati temporali in Pandas?
Pandas offre funzioni come resample, rolling e shift per gestire efficacemente i dati temporali.
Conclusione
In questa lezione avanzata, abbiamo esplorato le operazioni essenziali di Pandas, dall’importazione dei dati alla manipolazione, pulizia e analisi statistica. Abbiamo anche visto esempi pratici e consigli per lavorare in modo efficiente con questa potente libreria. Ora dovresti avere una solida base per affrontare progetti di analisi dati più complessi.
Se vuoi approfondire ulteriormente, ti consiglio di consultare la documentazione ufficiale di Pandas e il libro “Python for Data Analysis” di Wes McKinney, il creatore di Pandas. Non aver paura di sperimentare e applicare quanto hai imparato: la pratica è la chiave per padroneggiare Pandas!
