0Pricing
Pandas & NumPy Academy · Lezione

GroupBy con una o più chiavi

Raggruppi in base a una o più colonne con groupby() e applichi le aggregazioni sum, mean, count e min/max.

GroupBy con una o più chiavi è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 2 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.

GroupBy con una singola chiave

La chiamata GroupBy più semplice utilizza una singola colonna come chiave di raggruppamento. Chiami df.groupby('column_name') e concateni un’aggregazione. Pandas crea un gruppo per ogni valore univoco della colonna e applica l’aggregazione a ogni colonna numerica, oppure alla colonna selezionata. Questa è la forma di GroupBy più comune nell’analisi quotidiana.

import pandas as pd

df = pd.DataFrame({
    'dept': ['Eng', 'HR', 'Eng', 'HR', 'Eng'],
    'salary': [90000, 60000, 95000, 62000, 88000],
    'years': [3, 5, 7, 2, 4]
})

print(df.groupby('dept')['salary'].mean())
# dept
# Eng    91000.0
# HR     61000.0

Scelta delle colonne da aggregare

Dopo aver chiamato groupby(), può selezionare una colonna usando la notazione con parentesi quadre per ottenere una SeriesGroupBy, oppure più colonne tramite un elenco per ottenere una DataFrameGroupBy. Se omette completamente la selezione, Pandas aggrega tutte le colonne numeriche: è comodo, ma può produrre risultati imprevisti quando sono presenti colonne numeriche non pertinenti.

# Single column result -> SeriesGroupBy
print(df.groupby('dept')['salary'].sum())

# Multiple columns result -> DataFrameGroupBy
print(df.groupby('dept')[['salary', 'years']].mean())
#        salary  years
# dept
# Eng   91000.0    4.667
# HR    61000.0    3.500

Tutte le aggregazioni comuni

Pandas supporta un insieme completo di metodi di aggregazione integrati sugli oggetti GroupBy: sum(), mean(), median(), min(), max(), count(), std(), var(), first() e last(). Ognuno restituisce uno scalare per gruppo, fornendo una tabella riepilogativa ordinata per chiave di raggruppamento.

g = df.groupby('dept')['salary']
print('sum:   ', g.sum())
print('mean:  ', g.mean())
print('min:   ', g.min())
print('max:   ', g.max())
print('count: ', g.count())
print('std:   ', g.std().round(2))

GroupBy con più chiavi

Passi un elenco di nomi di colonne a groupby() per raggruppare simultaneamente per più dimensioni. Ogni combinazione univoca di valori in tali colonne diventa un gruppo distinto. Il risultato presenta un MultiIndex con un livello per ogni colonna di raggruppamento, consentendo di analizzare riepiloghi su più dimensioni in un solo passaggio.

df2 = pd.DataFrame({
    'dept':   ['Eng', 'Eng', 'HR',  'HR',  'Eng', 'HR'],
    'level':  ['L1',  'L2',  'L1',  'L2',  'L1',  'L1'],
    'salary': [80000, 100000, 55000, 70000, 82000, 58000]
})

result = df2.groupby(['dept', 'level'])['salary'].mean()
print(result)
# dept  level
# Eng   L1       81000.0
#       L2      100000.0
# HR    L1       56500.0
#       L2       70000.0

Accesso ai risultati con MultiIndex

Quando raggruppa i dati per più chiavi, l’indice del risultato è un MultiIndex. Può accedere a uno specifico livello esterno con .loc['value'] e navigare nei livelli interni usando le tuple. La chiamata a reset_index() trasforma il MultiIndex in colonne normali, soluzione spesso più comoda per ulteriori operazioni o per l’esportazione.

result = df2.groupby(['dept', 'level'])['salary'].mean()

# Access Engineering rows only
print(result.loc['Eng'])
# level
# L1     81000.0
# L2    100000.0

# Flatten to a regular DataFrame
print(result.reset_index())
#   dept level    salary
# 0  Eng    L1   81000.0
# 1  Eng    L2  100000.0

Utilizzo di as_index=False

Per impostazione predefinita, le colonne di raggruppamento diventano l’indice del risultato. Passando as_index=False, rimangono invece colonne normali, producendo un DataFrame semplice, più facile da passare ad altre operazioni Pandas o da esportare. È equivalente a chiamare reset_index() sul risultato.

flat = df2.groupby(['dept', 'level'], as_index=False)['salary'].mean()
print(flat)
#   dept level    salary
# 0  Eng    L1   81000.0
# 1  Eng    L2  100000.0
# 2   HR    L1   56500.0
# 3   HR    L2   70000.0

Conteggio delle righe per gruppo

count() restituisce il numero di valori non null in ogni gruppo. Se desidera il numero totale di righe per gruppo indipendentemente dai valori null, utilizzi invece size(). Questa distinzione è importante quando i dati contengono valori mancanti, perché count() sottostima i gruppi che contengono valori NaN.

import numpy as np

df3 = pd.DataFrame({
    'dept': ['Eng', 'Eng', 'HR', 'HR'],
    'bonus': [5000, np.nan, 3000, 4000]
})

print(df3.groupby('dept')['bonus'].count())  # ignores NaN
# dept
# Eng    1
# HR     2

print(df3.groupby('dept')['bonus'].size())   # includes NaN rows
# dept
# Eng    2
# HR     2

Ordinamento dei risultati GroupBy

Per impostazione predefinita, GroupBy ordina il risultato in base alla chiave del gruppo. Può disattivare l’ordinamento con sort=False per mantenere l’ordine originale della prima occorrenza; questa soluzione è anche leggermente più veloce con dataset di grandi dimensioni. Una volta ottenuto il risultato come DataFrame, può ordinarlo ulteriormente con sort_values() in base a qualsiasi colonna.

result = (df.groupby('dept', sort=False)['salary']
            .mean()
            .reset_index()
            .sort_values('salary', ascending=False))
print(result)
#   dept    salary
# 0  Eng   91000.0
# 1   HR   61000.0

Concatenazione di GroupBy con altri metodi

I risultati di GroupBy sono Series o DataFrame normali, quindi può concatenare immediatamente altri metodi Pandas. Un pattern comune consiste nell’aggregare, chiamare reset_index(), rinominare le colonne e infine chiamare sort_values(), tutto in un’unica catena di metodi leggibile, senza memorizzare variabili intermedie.

summary = (
    df
    .groupby('dept')['salary']
    .agg(['mean', 'count'])
    .rename(columns={'mean': 'avg_salary', 'count': 'headcount'})
    .reset_index()
    .sort_values('avg_salary', ascending=False)
)
print(summary)

Applicazione congiunta di sum, mean e count

Spesso è necessario calcolare più di una statistica per gruppo. Passi un elenco di nomi di funzioni a .agg() per calcolarle simultaneamente. Il risultato è un DataFrame con una colonna per ogni funzione. È più efficiente che chiamare separatamente ogni aggregazione, perché Pandas le elabora tutte in un’unica scansione dei dati.

result = df.groupby('dept')['salary'].agg(['sum', 'mean', 'count', 'max'])
print(result)
#           sum      mean  count    max
# dept
# Eng    273000   91000.0      3  95000
# HR     122000   61000.0      2  62000

Raggruppamento per colonne categoriche

Quando una colonna di raggruppamento ha il dtype Categorical, Pandas include per impostazione predefinita tutte le categorie nel risultato, anche quelle senza righe. Questo può essere utile per assicurarsi che la tabella riepilogativa mostri sempre ogni categoria, ma crea righe con NaN o 0 per i gruppi vuoti. Può controllare questo comportamento con il parametro observed (impostandolo su True per ignorare le categorie vuote).

df['dept'] = df['dept'].astype('category')
# With observed=True, only groups that appear in data are included
print(df.groupby('dept', observed=True)['salary'].mean())
# dept
# Eng    91000.0
# HR     61000.0

Verifica rapida

Verifichi la Sua comprensione di GroupBy con chiavi singole e multiple, sulla base di questa lezione.

Riepilogo della lezione

In questa lezione ha imparato a raggruppare i dati per una singola colonna e applicare aggregazioni comuni, a raggrupparli per più colonne per produrre riepiloghi su più dimensioni e a distinguere tra count() e size() quando sono presenti valori null. Ora vedremo il potente metodo agg() per calcolare più statistiche diverse in un’unica chiamata.

Domande Frequenti

La lezione «GroupBy con una o più chiavi» è gratuita?

Sì — il testo completo di «GroupBy con una o più chiavi» è 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 «GroupBy con una o più chiavi»?

Raggruppi in base a una o più colonne con groupby() e applichi le aggregazioni sum, mean, count e min/max. 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 2 di 4.

Quanto tempo richiede la lezione «GroupBy con una o più chiavi»?

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