0Pricing
Pandas & NumPy Academy · Lezione

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))  # DataFrameGroupBy

Il 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: int64

Il 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    180

Iterazione 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    220

Funzioni 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     1

Raggruppamento 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      340

Il 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 faster

GroupBy 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         220

Verifica 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

  1. Il pattern Split-Apply-Combine
  2. GroupBy con una o più chiavi
  3. Il metodo agg()
  4. Trasformazione e filtro con GroupBy
← Torna a Pandas & NumPy Academy