Guida rapida a pandas e DataFrame

Che cos’è pandas?

Logo di pandas sopra una tabella stilizzata che rappresenta dati tabulari.

pandas è una libreria Python pensata per la manipolazione e l’analisi di dati tabulari. Fornisce strutture dati ad alte prestazioni, come Series e DataFrame, e una vasta collezione di metodi per leggere, trasformare, raggruppare e aggregare dati. È progettata per l’esplorazione interattiva, l’elaborazione di dataset di medie dimensioni e l’integrazione con l’ecosistema scientifico Python (NumPy, Matplotlib, Scikit-learn, Seaborn).

Installazione rapida con PyPI:

pip install pandas

Suggerimento: usa Jupyter Notebook o JupyterLab per analisi esplorative perché mantengono una cronologia dei calcoli e visualizzazioni inline.

Important: pandas non è progettato per dataset molto più grandi della RAM del tuo computer; per questi casi vedi la sezione Alternative.

Cos’è un DataFrame?

Un DataFrame è una struttura dati tabellare bidimensionale con etichette sulle righe e sulle colonne. Puoi immaginarlo come una tabella di database o un foglio di calcolo: ogni colonna ha un nome e contiene valori omogenei dal punto di vista semantico (numerici, stringhe, date). I DataFrame supportano operazioni vettoriali veloci e metodi per selezionare, filtrare, trasformare e aggregare dati.

Breve definizione: DataFrame = tabella etichettata con colonne tipizzate e operazioni vettoriali.

Come creare un DataFrame

Esempio minimo usando NumPy per creare una funzione lineare e trasformarla in DataFrame:

import numpy as np
import pandas as pd

x = np.linspace(-10, 10)
y = 2 * x + 5

df = pd.DataFrame({'x': x, 'y': y})

Spiegazione rapida: pd.DataFrame accetta un dizionario dove le chiavi sono i nomi delle colonne e i valori sono sequenze (liste, array NumPy, Series).

Altri modi per creare DataFrame:

Da lista di dizionari: pd.DataFrame([{‘a’: 1, ‘b’: 2}, {‘a’: 3}])
Da dizionario di Series: pd.DataFrame({‘col1’: pd.Series([…]), ‘col2’: …})
Da array NumPy 2D: pd.DataFrame(np.random.randn(3, 4), columns=[‘A’, ‘B’, ‘C’, ‘D’])

Esempio pratico con colonne derivate:

# aggiungere una colonna derivata
df['x2'] = df['x'] ** 2

Importare un DataFrame

Importare dati da formati comuni:

# Excel
df = pd.read_excel('/path/to/spreadsheet.xls')

# CSV
df = pd.read_csv('/path/to/data.csv')

# Copia dagli appunti (clipboard) - comodo per piccoli dataset
df = pd.read_clipboard()

# JSON
df = pd.read_json('/path/to/data.json')

# Parquet (per dati colonne compressi e veloci)
df = pd.read_parquet('/path/to/data.parquet')

Suggerimenti pratici:

Usa dtype quando importi per forzare tipi (evita conversioni successive più lente).
Per grandi CSV, usa iteratori o chunksize: pd.read_csv(…, chunksize=100000)
Per file con separatori strani, specifica sep e encoding.

Esaminare un DataFrame

Comandi di base per ispezionare rapidamente il contenuto e la qualità dei tuoi dati:

df.head()        # prime 5 righe
df.tail()        # ultime 5 righe
df.head(10)      # prime 10 righe
len(df)          # numero di righe

df.columns       # indice dei nomi di colonna

df.info()        # tipi di colonne, valori non nulli, uso memoria

df.describe()    # statistiche descrittive per colonne numeriche

Esempio con il dataset dei passeggeri del Titanic (esempio didattico):

titanic = pd.read_csv('data/Titanic-Dataset.csv')
titanic.head()

Metodi utili per la qualità dei dati:

titanic.isnull().sum() — conta valori mancanti per colonna
titanic.duplicated().sum() — conta righe duplicate
pd.set_option(‘display.max_rows’, None) — mostra tutte le righe (usa con cautela)

Se vuoi statistiche per una singola colonna:

# descrittori di una colonna
titanic['Age'].describe()

# media e mediana
titanic['Age'].mean()
titanic['Age'].median()

Nota: molte funzioni ignorano automaticamente i NaN per calcoli statistici di base.

Aggiungere e eliminare colonne

Aggiungere una colonna da un’operazione vettoriale:

df['sum'] = df['x'] + df['y']

Eliminare una colonna:

# restituisce una copia senza la colonna; per modificare in-place usa inplace=True
df = df.drop('x2', axis=1)
# oppure
df.drop(columns=['x2'], inplace=True)

Tip: preferisci l’uso esplicito di .drop(columns=…) perché è più leggibile.

Operare sulle colonne

Selezione di colonne singole e multiple:

col = titanic['Name']         # Series
subset = titanic[['Name', 'Age']]  # DataFrame con due colonne

Filtrare righe con condizioni booleane:

# seleziona passeggeri con età > 30
older_than_30 = titanic[titanic['Age'] > 30]

# selezione con loc per righe e colonne
older_names = titanic.loc[titanic['Age'] > 30, ['Name', 'Age']]

Operazioni vettoriali veloci:

# sommare colonne
df['total'] = df['x'] + df['y']

# applicare funzione a una colonna
df['age_bracket'] = df['Age'].apply(lambda a: 'adult' if a >= 18 else 'child')

# usare numpy per condizioni multiple
import numpy as np
mask = np.where(df['x'] > 0, 'pos', 'neg')
df['x_sign'] = mask

Raggruppamenti e aggregazioni:

# conteggi per porto di imbarco
embarked = titanic['Embarked'].value_counts()

# rinominare le etichette per leggibilità
embarked = embarked.rename({'S': 'Southampton', 'C': 'Cherbourg', 'Q': 'Queenstown'})

# grafico a barre
embarked.plot(kind='bar')

Gruppi più complessi:

# aggregazioni multiple per gruppo
titanic.groupby('Pclass').agg({'Age': ['mean', 'median'], 'Fare': 'sum'})

Visualizzare dati e integrazione con librerie

pandas si integra bene con Matplotlib e Seaborn per visualizzazioni rapide:

import matplotlib.pyplot as plt
import seaborn as sns

sns.histplot(titanic['Age'].dropna())
plt.show()

Per grafici interattivi considera plotly o altair, che possono consumare DataFrame direttamente.

Best practice e mini-methodology per l’ispezione dei dati

Passaggi suggeriti quando apri un nuovo dataset:

Mettere in sicurezza i dati: copia una versione immutabile per esperimenti.
df.info() per capire tipi e nullità.
df.head() e df.sample(10) per ispezione visiva.
isnull().sum() e duplicated().sum() per problemi di qualità.
describe() per distribuzioni delle colonne numeriche.
Visualizzazioni rapide (istogrammi, boxplot) per rilevare outlier.
Documentare le trasformazioni e salvare versioni intermedie.

Mini-regola: ordina le operazioni da meno distruttive a più distruttive e verifica ogni passaggio con esempi.

Quando evitare pandas e alternative

Counterexample: pandas può rallentare o esaurire la RAM quando:

il dataset è molto più grande della memoria disponibile;
servono operazioni distribuite o streaming in real-time;
si cerca latenza molto bassa per richieste online.

Alternative comuni:

Dask: API compatibile con pandas ma per calcoli distribuiti o fuori memoria.
Polars: libreria più recente con API simile, focalizzata su prestazioni e basso uso di memoria.
SQLite/PostgreSQL: utile se la logica è basata su query SQL e i dati rimangono su disco.
Vaex: per analisi fuori memoria e visualizzazione di dataset giganti.

Decisione rapida (diagramma):

flowchart TD
  A[Dataset iniziale] --> B{Dimensione > RAM?}
  B -- No --> C[Usa pandas]
  B -- Sì --> D{Operazioni parallele o distribuite?}
  D -- No --> E[Usa SQLite/Postgres o Vaex]
  D -- Sì --> F[Usa Dask o Polars]

Performance e ottimizzazioni pratiche

Usa tipi appropriati: converti oggetti stringa che rappresentano categorie in pd.Categorical.
Evita operazioni in loop su righe; preferisci operazioni vettoriali o .apply con cautela.
Per join su grandi tabelle, assicurati che le chiavi siano indicizzate o usa merge con opzioni adeguate.
Usa chunksize per leggere/trasformare CSV molto grandi in streaming.
Per salvataggi ripetuti, preferisci formati columnar come Parquet.

Checklist per ruolo

Data Scientist

Verifica qualità dati (null, duplicati).
Esegui analisi esplorativa: distribuzioni, correlazioni.
Crea set train/test ripetibili.
Documenta feature engineering.

Data Analyst

Pulizia e normalizzazione colonne.
Aggregazioni e reportistica mensile.
Visualizzazioni per stakeholder.

Ingegnere dati

Automatizza ingestion e versioning dei dati.
Scegli formati efficienti per storage.
Implementa test di qualità dati in pipeline.

Product Manager

Definisci metriche di business chiare.
Verifica che le trasformazioni mantengano significato di metrica.

Privacy e note sulla protezione dei dati

Se il dataset contiene dati personali (ad esempio nomi, contatti, identificatori), applica principi di minimizzazione:

anonimizza o pseudonimizza i dati se possibile;
conserva separatamente le mapping table in ambiente sicuro;
rispetta le regole locali su conservazione e cancellazione dei dati personali (GDPR se applicabile).

Esempio: il dataset Titanic contiene nomi reali: trattali come dati personali durante analisi o condivisione.

Important: non pubblicare file con dati personali senza consenso o senza averli anonimizzati.

Cheat sheet dei comandi più usati

# import
import pandas as pd

# leggi/scrivi
pd.read_csv('file.csv')
df.to_csv('out.csv', index=False)

# selezione
df['col']
df[['a', 'b']]
df.loc[mask, ['a', 'b']]

# filtro
df[df['Age'] > 30]

# raggruppamento
df.groupby('key').agg({'val': ['mean', 'sum']})

# unione
pd.merge(df1, df2, on='id', how='inner')

# pivot
df.pivot_table(index='A', columns='B', values='C', aggfunc='mean')

# salva in parquet
df.to_parquet('data.parquet')

Errori comuni e come risolverli

Problema: valori numerici letti come stringhe. Soluzione: utilizzare dtype o pd.to_numeric(errors=’coerce’) e gestire NaN.
Problema: memory error. Soluzione: usare chunksize, Dask o Polars, o ridurre i tipi (float64 -> float32) quando accettabile.
Problema: operazioni lente con .apply su righe. Soluzione: riscrivere in operazioni vettoriali o usare numba se serve accelerazione.

Esempi di test e criteri di accettazione

Esempi di test automatizzati per trasformazioni di DataFrame:

Test che una colonna di età non contenga valori negativi.
Test che il numero di righe dopo un inner join sia <= min(num_righe_tab1, num_righe_tab2).
Test che nessuna colonna fondamentale (id, timestamp) sia nulla dopo l’import.

Criteri di accettazione standard:

I valori mancanti documentati e gestiti.
Tipi di colonna coerenti con la definizione del dataset.
Metriche aggregate allineate con report di riferimento.

Maturità d’uso di pandas

Livello 0 — Esplorazione: uso di .head(), .describe(), grafici rapidi.

Livello 1 — Pulizia: rewriting di colonne, gestione dei null, join semplici.

Livello 2 — Analisi riproducibile: notebook con pipeline, salvataggio di artefatti.

Livello 3 — Produzione: trasformazioni automatizzate, test, monitoraggio e storage efficiente (Parquet, database).

Breve glossario in una riga

Series: colonna etichettata; DataFrame: tabella; dtype: tipo di dato di una colonna; NaN: valore mancante.

Sommario e prossimi passi

Questo articolo ti ha introdotto ai concetti fondamentali di pandas e DataFrame: creazione, importazione, ispezione, trasformazioni e raggruppamenti. Per approfondire:

Prova a riprodurre gli esempi in un Jupyter Notebook.
Sperimenta con dataset diversi: CSV, JSON, Parquet.
Se lavori con dataset grandi, valuta Dask o Polars.

Note finali:

pandas è uno strumento estremamente utile per l’analisi dati esplorativa e per pipeline di medie dimensioni. Mantieni pratiche di documentazione e test per garantire riproducibilità e qualità.

Riassunto rapido per chi torna al documento:

pandas = libreria principale per dati tabulari in Python.
DataFrame = struttura tabellare per righe/colonne.
Usa Jupyter per esplorare; preferisci Parquet per storage efficiente.
Considera Dask/Polars per dataset fuori memoria.

Guida rapida a pandas e DataFrame in Python

Link veloci