Il pattern Split-Apply-Combine
Comprenda il flusso concettuale di groupby: suddividere il DataFrame in gruppi, applicare una funzione e combinare i risultati.
Il pattern Split-Apply-Combine è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Pandas & NumPy Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Pandas & NumPy Academy include 4 lezioni in totale.
Che cos'è GroupBy?
L’operazione GroupBy è uno dei pattern più potenti nell’analisi dei dati. Consente di suddividere un DataFrame in gruppi, applicare una funzione a ciascun gruppo in modo indipendente e combinare quindi i risultati in una nuova struttura. Questo flusso di lavoro è noto come pattern split-apply-combine, un termine coniato dallo statistico Hadley Wickham.
Il passaggio split
Nel passaggio split, Pandas divide il DataFrame in sotto-DataFrame in base ai valori univoci presenti in una o più colonne. Ad esempio, se i dati contengono una colonna region con valori come 'North', 'South' e 'West', il passaggio split crea tre gruppi separati. Non vengono ancora spostati né copiati dati: Pandas registra semplicemente quali righe appartengono a ciascun gruppo.
import pandas as pd
df = pd.DataFrame({
'region': ['North', 'South', 'North', 'West', 'South'],
'sales': [200, 150, 300, 180, 220]
})
# split: create a GroupBy object
grouped = df.groupby('region')
print(type(grouped)) # DataFrameGroupByIl passaggio apply
Nel passaggio apply, una funzione viene applicata a ciascun gruppo in modo indipendente. La funzione può essere un’aggregazione integrata come sum() o mean(), oppure una funzione personalizzata definita da Lei. Le righe di ciascun gruppo vengono passate alla funzione, che restituisce come risultato uno scalare, una Series o un DataFrame.
# apply: compute the sum of 'sales' within each region group
total_sales = grouped['sales'].sum()
print(total_sales)
# region
# North 500
# South 370
# West 180
# Name: sales, dtype: int64Il passaggio combine
Nel passaggio combine, Pandas riunisce automaticamente i risultati dei singoli gruppi in un unico oggetto, in genere una Series o un DataFrame. Le chiavi dei gruppi diventano l’indice del risultato. Questo passaggio avviene automaticamente quando si chiama un metodo di aggregazione su un oggetto GroupBy, fornendo una tabella riepilogativa ordinata con una riga per ogni gruppo.
# combine happens automatically — result is a Series indexed by 'region'
print(total_sales.index) # Index(['North', 'South', 'West'])
print(total_sales.values) # [500, 370, 180]Creazione di un oggetto GroupBy
Per creare un oggetto GroupBy, chiami df.groupby(column). In questa fase non viene eseguito alcun calcolo: si tratta di un oggetto lazy. Può iterarvi sopra per visualizzare i gruppi oppure concatenare un metodo di aggregazione per avviare il calcolo. Passando as_index=False, la colonna di raggruppamento rimane una colonna normale invece di diventare l’indice del risultato.
grouped = df.groupby('region', as_index=False)
result = grouped['sales'].sum()
print(result)
# region sales
# 0 North 500
# 1 South 370
# 2 West 180Iterazione sui gruppi
Può iterare su un oggetto GroupBy per esaminare ogni gruppo singolarmente. Ogni iterazione restituisce una tupla di (group_key, sub_dataframe). Questa tecnica è utile per il debugging o quando desidera elaborare ogni gruppo con codice Python arbitrario. Tuttavia, in produzione, per ottenere prestazioni migliori, preferisca i metodi di aggregazione vettorializzati all’iterazione esplicita.
for name, group in df.groupby('region'):
print(f'--- {name} ---')
print(group)
# --- North ---
# region sales
# 0 North 200
# 2 North 300
# --- South ---
# region sales
# 1 South 150
# 4 South 220Funzioni di aggregazione comuni
Pandas GroupBy supporta molte funzioni di aggregazione integrate: sum(), mean(), count(), min(), max(), std(), median() e altre. Queste funzioni sono altamente ottimizzate ed elaborano tutti i gruppi in un’unica scansione. Quando esiste una funzione integrata, la preferisca sempre alla scrittura di una funzione Python personalizzata.
print(df.groupby('region')['sales'].mean())
# region
# North 250.0
# South 185.0
# West 180.0
print(df.groupby('region')['sales'].count())
# region
# North 2
# South 2
# West 1Raggruppamento simultaneo di più colonne
Può applicare aggregazioni simultaneamente a più colonne selezionandole prima di chiamare il metodo di aggregazione oppure omettendo la selezione delle colonne per aggregare tutte le colonne numeriche. Il risultato è un DataFrame anziché una Series, con una colonna per ogni variabile aggregata.
df2 = pd.DataFrame({
'region': ['North', 'South', 'North', 'South'],
'units': [10, 8, 12, 9],
'revenue': [200, 160, 240, 180]
})
print(df2.groupby('region').sum())
# units revenue
# region
# North 22 440
# South 17 340Il modello mentale di GroupBy
Consideri GroupBy come la clausola GROUP BY di SQL. Il codice Pandas df.groupby('region')['sales'].sum() equivale a SELECT region, SUM(sales) FROM df GROUP BY region in SQL. Comprendere questa corrispondenza La aiuta a passare da uno strumento all’altro e a scegliere l’astrazione giusta per la pipeline.
# Pandas GroupBy is equivalent to SQL GROUP BY
# SQL: SELECT region, SUM(sales) FROM df GROUP BY region
# Pandas: df.groupby('region')['sales'].sum()
result = df.groupby('region')['sales'].sum().reset_index()
result.columns = ['region', 'total_sales']
print(result)Perché non usare un ciclo?
Potrebbe chiedersi perché non iterare semplicemente sui valori univoci e calcolare manualmente le statistiche. La risposta è prestazioni e leggibilità. Un ciclo Python sui gruppi è molto più lento di una singola chiamata groupby vettorializzata, soprattutto con dataset di grandi dimensioni. Le operazioni GroupBy vengono eseguite internamente in codice C compilato, risultando da 10 a 100 volte più veloci di cicli Python equivalenti.
# Slow approach with a loop
results = {}
for region in df['region'].unique():
subset = df[df['region'] == region]
results[region] = subset['sales'].sum()
# Fast approach with GroupBy
results_fast = df.groupby('region')['sales'].sum().to_dict()
# Both give the same answer, but GroupBy is orders of magnitude fasterGroupBy con più chiavi di raggruppamento
Quando serve un livello di dettaglio maggiore, raggruppi i dati per più colonne passando un elenco a groupby(). Il risultato presenta un MultiIndex, in cui ogni livello corrisponde a una colonna di raggruppamento. Ad esempio, il raggruppamento per 'region' e 'quarter' restituisce i totali per ogni combinazione di regione e trimestre.
df3 = pd.DataFrame({
'region': ['North', 'North', 'South', 'South'],
'quarter': ['Q1', 'Q2', 'Q1', 'Q2'],
'sales': [200, 300, 150, 220]
})
print(df3.groupby(['region', 'quarter'])['sales'].sum())
# region quarter
# North Q1 200
# Q2 300
# South Q1 150
# Q2 220Verifica rapida
Verifichi la Sua comprensione del pattern split-apply-combine presentato in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato: il pattern split-apply-combine alla base di tutte le operazioni GroupBy, come creare un oggetto GroupBy con df.groupby() e come applicare aggregazioni integrate come sum() e mean() per ottenere un risultato per ogni gruppo. Ora vedremo il raggruppamento con una o più chiavi e altri metodi di aggregazione.
Domande Frequenti
La lezione «Il pattern Split-Apply-Combine» è gratuita?
Sì — il testo completo di «Il pattern Split-Apply-Combine» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Pandas & NumPy Academy, passa a CoddyKit PRO. Il corso Pandas & NumPy Academy include 4 lezioni in totale.
Cosa imparerò in «Il pattern Split-Apply-Combine»?
Comprenda il flusso concettuale di groupby: suddividere il DataFrame in gruppi, applicare una funzione e combinare i risultati. Eserciti Pandas & NumPy Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Pandas & NumPy Academy?
Non è richiesta alcuna esperienza precedente. Pandas & NumPy Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «Il pattern Split-Apply-Combine»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Pandas & NumPy Academy?
Sì. Ogni lezione Pandas & NumPy Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Il pattern Split-Apply-Combine
- GroupBy con una o più chiavi
- Il metodo agg()
- Trasformazione e filtro con GroupBy