Guida Pratica a Pandas: Esercizi Svolti di Data Manipulation e Pivot Table

Quando si lavora con i dati, c’è una linea sottile che separa un foglio di calcolo illeggibile da un’analisi strategica su cui un’azienda può investire del budget. Pandas è lo standard industriale per muoversi oltre quella linea, ma chiunque ci abbia sbattuto la testa sa che basta una virgola fuori posto, un valore nullo non gestito o un’aggregazione mal calcolata per bloccare un’intera pipeline di produzione.

In questa guida analizzeremo direttamente tre scenari reali di complessità crescente: dal filtraggio di base della pipeline delle vendite, passando per la pulizia dei dati mancanti nei database relazionali, fino alla ristrutturazione di serie temporali complesse con le tabelle pivot.

📌 Esercizio 1 – Livello: Medio

Argomento: DataFrame Pandas – selezione, filtri, nuove colonne

💡 Quando un manager ti chiede un report sulle vendite, la tentazione di scaricare il file in Excel e usare i filtri manuali è forte. Ma cosa succede se domani arrivano altri 50 file di dati? Imparare a usare la logica booleana di Pandas per filtrare i dati ti permette di automatizzare questa operazione una volta per tutte. Scrivi il codice oggi, lo riusi per i prossimi dieci anni.

Testo

Sei un analista in una piccola azienda.

Hai il seguente DataFrame con le vendite:

import pandas as pd

df = pd.DataFrame({
    'prodotto': ['A', 'B', 'C', 'A', 'B', 'C', 'A', 'B'],
    'regione': ['Nord', 'Sud', 'Nord', 'Centro', 'Nord', 'Sud', 'Sud', 'Centro'],
    'quantità': [10, 15, 7, 12, 9, 14, 8, 11],
    'prezzo_unitario': [5.0, 3.5, 8.0, 5.0, 3.5, 8.0, 5.0, 3.5]
})

1. Aggiungi una colonna ricavo = quantità * prezzo_unitario.
2. Filtra solo le righe dove regione è Nord.
3. Calcola il ricavo medio per prodotto (groupby).
4. Quale prodotto ha il ricavo totale più alto?

Soluzione Completa in Python

Ecco il codice commentato passo dopo passo per risolvere tutti i punti dell’esercizio:

import pandas as pd

# Creazione del DataFrame originale
df = pd.DataFrame({
    'prodotto': ['A', 'B', 'C', 'A', 'B', 'C', 'A', 'B'],
    'regione': ['Nord', 'Sud', 'Nord', 'Centro', 'Nord', 'Sud', 'Sud', 'Centro'],
    'quantità': [10, 15, 7, 12, 9, 14, 8, 11],
    'prezzo_unitario': [5.0, 3.5, 8.0, 5.0, 3.5, 8.0, 5.0, 3.5]
})

# 1. Aggiungi la colonna ricavo
df['ricavo'] = df['quantità'] * df['prezzo_unitario']
print("--- 1. DataFrame con colonna 'ricavo' ---")
print(df)
print("\n")

# 2. Filtra solo le righe dove regione è Nord
df_nord = df[df['regione'] == 'Nord']
print("--- 2. Righe filtrate per regione 'Nord' ---")
print(df_nord)
print("\n")

# 3. Calcola il ricavo medio per prodotto (usando il DataFrame intero)
ricavo_medio = df.groupby('prodotto')['ricavo'].mean()
print("--- 3. Ricavo medio per prodotto ---")
print(ricavo_medio)
print("\n")

# 4. Quale prodotto ha il ricavo totale più alto?
ricavo_totale = df.groupby('prodotto')['ricavo'].sum()
prodotto_top = ricavo_totale.idxmax()
valore_top = ricavo_totale.max()

print("--- 4. Prodotto con il ricavo totale più alto ---")
print(f"Il prodotto con il ricavo più alto è il prodotto '{prodotto_top}' con un totale di {valore_top}")

📌 Esercizio 2 – Livello: Medio/Difficile

Argomento: Merge di DataFrame, handling dati mancanti (missing data)

⚠️ ATTENZIONE ai finti dati puliti: Nei database aziendali reali i dati mancanti (NaN o None) sono la norma, non l’eccezione. Molti analisti alle prime armi cancellano brutalmente le righe vuote o le sovrascrivono con la media generale dell’intera colonna. È il modo perfetto per falsare i dati e presentare un report statistico completamente distorto. In questo esercizio vedremo come fare una “pulizia chirurgica” e contestuale.

Testo

Hai a disposizione due dataset relazionali:

• studenti con le colonne: id_studente, nome, classe
• voti con le colonne: id_studente, materia, voto

Alcuni studenti non hanno voti inseriti, mentre alcuni record nei voti presentano valori mancanti (None / NaN).

import pandas as pd
import numpy as np

studenti = pd.DataFrame({
    'id_studente': [1, 2, 3, 4, 5],
    'nome': ['Anna', 'Luca', 'Maria', 'Giulia', 'Marco'],
    'classe': [5, 5, 4, 5, 4]
})

voti = pd.DataFrame({
    'id_studente': [1, 1, 2, 3, 3, 4, 5],
    'materia': ['Mate', 'Fisica', 'Mate', 'Mate', 'Fisica', 'Fisica', 'Mate'],
    'voto': [8, 7, 6, None, 8, 9, None]
})

1. Unisci i due DataFrame con un merge esterno (full outer) sulla chiave id_studente.
2. Sostituisci i valori None (NaN) nella colonna voto con la media dei voti della rispettiva materia.
3. Calcola la media dei voti per singolo studente.
4. Mostra il nome e la media finale degli studenti appartenenti esclusivamente alla classe 5.

Soluzione Completa in Python

Di seguito viene mostrato il codice commentato passo dopo passo per eseguire l’intera pipeline di manipolazione dati:

import pandas as pd
import numpy as np

# Dataset di partenza
studenti = pd.DataFrame({
    'id_studente': [1, 2, 3, 4, 5],
    'nome': ['Anna', 'Luca', 'Maria', 'Giulia', 'Marco'],
    'classe': [5, 5, 4, 5, 4]
})

voti = pd.DataFrame({
    'id_studente': [1, 1, 2, 3, 3, 4, 5],
    'materia': ['Mate', 'Fisica', 'Mate', 'Mate', 'Fisica', 'Fisica', 'Mate'],
    'voto': [8, 7, 6, None, 8, 9, None]
})

# 1. Full Outer Merge
df_merged = pd.merge(studenti, voti, on='id_studente', how='outer')
print("--- 1. DataFrame dopo il Full Outer Merge ---")
print(df_merged)
print("\n")

# 2. Imputazione dei missing values con la media della specifica materia
# Calcoliamo prima le medie per ogni materia per trasparenza algebrica
medie_materie = df_merged.groupby('materia')['voto'].transform('mean')
df_merged['voto'] = df_merged['voto'].fillna(medie_materie)

print("--- 2. DataFrame con NaN sostituiti dalle medie di materia ---")
print(df_merged)
print("\n")

# 3. Calcolo della media voti per ogni studente (mantenendo nome e classe)
# Raggruppiamo per id, nome e classe per non perdere i metadati
df_medie_studenti = df_merged.groupby(['id_studente', 'nome', 'classe'])['voto'].mean().reset_index()
df_medie_studenti.rename(columns={'voto': 'media_voti'}, inplace=True)
print("--- 3. Media voti calcolata per ogni studente ---")
print(df_medie_studenti)
print("\n")

# 4. Filtro per la classe 5 e selezione delle colonne richieste
risultato_classe_5 = df_medie_studenti[df_medie_studenti['classe'] == 5][['nome', 'media_voti']]
print("--- 4. Risultato finale: studenti della classe 5 ---")
print(risultato_classe_5)

Spiegazione dei Passaggi e Calcoli Matematici

Passaggio 1: Il Merge Esterno

L’operazione how='outer' unisce tutte le righe di entrambe le tabelle. In questo caso specifico, i record corrispondono perfettamente per via degli ID, ma la struttura viene linearizzata ripetendo i dati anagrafici dello studente per ogni voto preso.

Passaggio 2: Calcolo e Imputazione delle Medie di Materia

Prima di sostituire i valori mancanti, il motore calcola la media dei voti validi per ciascuna materia presente nel dataset:

• Fisica: I voti validi sono 7 e 9. La media è [math]\frac{7 + 9}{2} = 8.0[/math].
• Mate: I voti validi sono 8 e 6. La media è [math]\frac{8 + 6}{2} = 7.0[/math].

I valori NaN vengono quindi sostituiti in modo mirato:

• Il voto mancante di Maria (id 3) in Mate diventa 7.0.
• Il voto mancante di Marco (id 5) in Mate diventa 7.0.

Passaggio 3 & 4: Aggregazione e Filtro Classe 5

Viene calcolata la media aritmetica dei voti per ogni singolo studente aggregato. Successivamente, isolando solo le righe in cui classe == 5, si ottiene la seguente situazione:

• Anna: Ha i voti 8.0 e 7.0. La sua media è [math]\frac{8 + 7}{2} = 7.5[/math].
• Luca: Ha un solo voto pari a 6.0. La sua media è 6.0.
• Giulia: Ha un solo voto pari a 9.0. La sua media è 9.0.

Output Finale della Classe 5:

• Anna: 7.5
• Luca: 6.0
• Giulia: 9.0

Analisi e Commento Tecnico del Codice 

Questo script rappresenta un caso di studio avanzato sull’utilizzo di Pandas per l’analisi di serie temporali e l’aggregazione di matrici bidimensionali. Vediamo nel dettaglio come funzionano i singoli blocchi di codice e perché sono stati strutturati in questo modo.

1. Inizializzazione del Dataset e Gestione del “Seed”

La prima parte dello script si occupa di generare un dataset fittizio (mock data) che simula le transazioni di un supermercato:

np.random.seed(42)
date = pd.date_range('2025-01-01', periods=7, freq='D')
prodotti = ['Pasta', 'Latte', 'Pane', 'Uova']

Dettaglio tecnico:

• np.random.seed(42): Configura il generatore di numeri pseudocasuali di NumPy con uno stato iniziale fisso (42). Questo garantisce la riproducibilità del codice: ogni volta che lo script viene eseguito, genererà gli stessi identici dati, permettendo di verificare la correttezza dei calcoli algebrici.
• pd.date_range(..., freq='D'): Crea un indice temporale nativo di Pandas composto da 7 giorni consecutivi.

2. Vettorizzazione elementare (Punto 1)

Per calcolare il ricavo di ogni singola transazione, il codice esegue un’operazione nota come vettorizzazione:

df_vendite['ricavo'] = (df_vendite['quantità'] * df_vendite['prezzo']).round(2)

Invece di utilizzare un ciclo iterativo (come un ciclo for) per scorrere le righe una alla volta, Pandas moltiplica gli interi vettori colonna (Series) in un colpo solo. Questa operazione viene eseguita direttamente in memoria a basso livello (linguaggio C), garantendo performance eccezionali anche su milioni di righe. Il metodo .round(2) finale pulisce i decimali fluttuanti tipici delle operazioni binari sui float.

3. Riorganizzazione della Matrice tramite Pivot Table (Punto 2)

La Pivot Table è lo strumento matematico ideale per trasformare dati lineari in strutture cross-tabulari:

pivot_medie = df_vendite.pivot_table(
    values='ricavo', 
    index='data', 
    columns='prodotto', 
    aggfunc='mean'
).round(2)

Qui indichiamo a Pandas di proiettare le date sulle righe ([math]\text{index}[/math]) e le categorie di prodotto sulle colonne ([math]\text{columns}[/math]). Il parametro cruciale è aggfunc='mean': se in una stessa data ci sono più vendite dello stesso prodotto, il motore calcolerà la media aritmetica di quei ricavi. Le combinazioni data-prodotto che non hanno registrato vendite verranno popolate con NaN (valore nullo).

4. Aggregazione Temporale e Risoluzione dei Tipi Scalari (Punto 3)

Per trovare il giorno con l’incasso totale più alto, isoliamo l’asse temporale:

ricavo_totale_giornaliero = df_vendite.groupby('data')['ricavo'].sum()
giorno_top = ricavo_totale_giornaliero.idxmax()
valore_giorno_top = ricavo_totale_giornaliero.max()

Logica applicata:

• .groupby('data')['ricavo'].sum(): Somma tutti i ricavi del supermercato collassando i dati per giorno.
• .idxmax(): Restituisce l’indice associato al valore massimo (ovvero la data esatta del picco di vendite).
• .max(): Restituisce il valore numerico (il ricavo effettivo) di quel picco.

Risoluzione del Bug (Scalari vs Vettori): Quando estraiamo valore_giorno_top tramite .max(), otteniamo un numero float puro (nativo di Python) e non più una Series di Pandas. Per formattarlo senza generare un AttributeError, non possiamo usare il metodo ad oggetti .round(), ma dobbiamo passarlo all’interno della funzione nativa del linguaggio: round(valore_giorno_top, 2).

5. Gestione dei Valori Nulli e Ricerca Multicorrispondenza (Punto 4)

L’ultimo blocco analizza le performance massime di ogni singolo prodotto lungo l’arco della settimana:

pivot_totali = df_vendite.pivot_table(..., aggfunc='sum').fillna(0)
giorni_max_per_prodotto = pivot_totali.idxmax()

In questo caso, la pivot table usa aggfunc='sum' per ottenere i ricavi totali (e non medi). Viene applicato immediatamente .fillna(0): questo passaggio è fondamentale perché la presenza di valori NaN potrebbe falsare l’algoritmo di ricerca del punto di massimo.

Infine, chiamando .idxmax() sull’intero DataFrame pivot_totali, Pandas esegue una scansione verticale su ogni colonna (prodotto), restituendo un dizionario di corrispondenze in cui ad ogni prodotto è associata la data del suo massimo successo commerciale.