Pandas & NumPy Academy · Lezione

pivot_table: tabulazione incrociata

Crei tabelle pivot in stile Excel con pd.pivot_table, impostando index, columns, values e aggfunc.

Lezione 1 di 413 passaggi

pivot_table: tabulazione incrociata è 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'è una tabella pivot

Una tabella pivot è una tabulazione incrociata che riassume i dati in base a due dimensioni categoriali: una forma le righe e l'altra le colonne, con un valore aggregato in ogni cella. Se ha già creato una tabella pivot in Excel, riconoscerà immediatamente il concetto. Pandas mette a disposizione pd.pivot_table() (e la corrispondente versione come metodo del DataFrame) per creare questi riepiloghi interamente in Python.

Chiamata di base a pivot_table

I quattro parametri principali di pd.pivot_table() sono: values (la colonna da aggregare), index (la colonna che diventa le righe), columns (la colonna che diventa le colonne) e aggfunc (la funzione di aggregazione, che per impostazione predefinita è 'mean'). Il risultato è un DataFrame in cui ogni cella contiene il valore aggregato per quella combinazione di riga e colonna.

import pandas as pd

df = pd.DataFrame({
    'region':  ['East', 'West', 'East', 'West', 'East', 'West'],
    'product': ['A',    'A',    'B',    'B',    'A',    'B'],
    'revenue': [200,    340,    150,    290,    310,    410]
})

table = pd.pivot_table(df,
                       values='revenue',
                       index='region',
                       columns='product',
                       aggfunc='sum')
print(table)
# product    A    B
# region
# East     510  150
# West     340  700

Scegliere aggfunc

Il parametro aggfunc accetta il nome, sotto forma di stringa, di qualsiasi funzione di aggregazione di NumPy/Pandas, un oggetto callable oppure un elenco di oggetti callable. Scelte comuni: 'sum' per i totali, 'mean' per le medie, 'count' per le frequenze, 'min'/'max' per i valori estremi. Quando passa un elenco, ogni aggregazione ottiene il proprio livello nel MultiIndex delle colonne.

# Using mean (default)
table_mean = pd.pivot_table(df, values='revenue',
                            index='region', columns='product',
                            aggfunc='mean')
print(table_mean.round(1))
# product      A      B
# region
# East     255.0  150.0
# West     340.0  350.0

# Using count
table_count = pd.pivot_table(df, values='revenue',
                             index='region', columns='product',
                             aggfunc='count')
print(table_count)

Gestire le celle mancanti con fill_value

Quando una combinazione di etichette di riga e colonna non contiene dati, per impostazione predefinita la cella contiene NaN. Passi fill_value per sostituire le celle mancanti con un valore predefinito significativo, ad esempio 0 per i conteggi o i ricavi. In questo modo la tabella è più facile da leggere e si evita che le operazioni aritmetiche successive producano silenziosamente risultati NaN.

df2 = pd.DataFrame({
    'region':  ['East', 'West', 'East'],
    'product': ['A',    'A',    'B'],
    'revenue': [200,    340,    150]
})

# West-B combination has no data -> NaN by default
table = pd.pivot_table(df2, values='revenue', index='region',
                       columns='product', aggfunc='sum', fill_value=0)
print(table)
# product    A    B
# region
# East     200  150
# West     340    0  <- filled with 0 instead of NaN

Aggiungere subtotali con margins

Passi margins=True per aggiungere i totali delle righe e delle colonne alla tabella pivot. Pandas aggiunge una riga 'All' in fondo e una colonna 'All' a destra, contenenti i valori aggregati per tutte le categorie. Può rinominare l'etichetta dei margini con margins_name. Questo comportamento corrisponde alla riga "Totale complessivo" delle tabelle pivot di Excel.

table = pd.pivot_table(df, values='revenue', index='region',
                       columns='product', aggfunc='sum',
                       fill_value=0, margins=True, margins_name='Total')
print(table)
# product    A     B  Total
# region
# East     510   150    660
# West     340   700   1040
# Total    850   850   1700

Più valori in pivot_table

Il parametro values può essere un elenco di nomi di colonne per aggregare più metriche contemporaneamente. Il risultato presenta un MultiIndex delle colonne, in cui il livello esterno è la colonna del valore e quello interno è la categoria. Ciò consente di creare una tabella riepilogativa completa con una sola chiamata, invece di costruire e unire più tabelle pivot separate.

df['units'] = [10, 15, 8, 12, 14, 18]

table = pd.pivot_table(df,
                       values=['revenue', 'units'],
                       index='region',
                       columns='product',
                       aggfunc='sum')
print(table)
# Columns: (revenue, A), (revenue, B), (units, A), (units, B)
print(table.columns.tolist())

Indice e colonne gerarchici

Quando passa un elenco a index o columns, la tabella pivot presenta un MultiIndex sull'asse corrispondente. Ciò consente di creare riepiloghi più dettagliati: ad esempio, suddividendo i ricavi per area geografica e trimestre nelle righe e per prodotto nelle colonne. Acceda ai livelli secondari con .loc e con le tuple di indici, come di consueto.

df['quarter'] = ['Q1', 'Q1', 'Q2', 'Q2', 'Q1', 'Q2']

table = pd.pivot_table(df, values='revenue',
                       index=['region', 'quarter'],
                       columns='product',
                       aggfunc='sum', fill_value=0)
print(table)
# product         A    B
# region quarter
# East   Q1     510    0
#        Q2       0  150
# West   Q1     340    0
#        Q2       0  700

Appiattire il risultato

Dopo aver creato una tabella pivot, l'indice rappresenta la colonna di raggruppamento e il MultiIndex delle colonne (quando si usano più valori) può risultare poco maneggevole. Un comune schema di pulizia consiste nel chiamare reset_index() per appiattire l'indice delle righe, quindi nel ridurre il MultiIndex delle colonne a un unico livello unendo i livelli con un carattere di sottolineatura tramite una list comprehension.

table = pd.pivot_table(df, values=['revenue', 'units'],
                       index='region', columns='product', aggfunc='sum')

# Flatten MultiIndex columns
table.columns = ['_'.join(str(c) for c in col) for col in table.columns]
table = table.reset_index()
print(table.columns.tolist())
# ['region', 'revenue_A', 'revenue_B', 'units_A', 'units_B']

pivot_table rispetto a groupby().agg()

Sia pivot_table sia groupby().agg() producono statistiche riepilogative. La differenza riguarda la forma dell'output: groupby().agg() restituisce un DataFrame in formato lungo, con una riga per ogni combinazione di gruppi, mentre pivot_table restituisce una tabella in formato ampio, in cui una dimensione diventa l'insieme delle colonne. Per dashboard e report, il formato ampio delle tabelle pivot è spesso più leggibile; per ulteriori analisi di machine learning o statistiche, è preferibile il formato lungo.

# Long format (groupby)
long = df.groupby(['region', 'product'])['revenue'].sum().reset_index()
print(long)
# region product  revenue
# East        A      510
# East        B      150

# Wide format (pivot_table)
wide = pd.pivot_table(df, 'revenue', 'region', 'product', 'sum', fill_value=0)
print(wide)
# product    A    B
# region
# East     510  150

Ordinare e formattare la tabella pivot

Una tabella pivot è un normale DataFrame, quindi può ordinarla, calcolare colonne derivate e formattarla esattamente come qualsiasi altro DataFrame Pandas. Ad esempio, può ordinare in ordine decrescente in base a una specifica colonna di prodotto per classificare le aree geografiche in base ai risultati di quel prodotto, oppure aggiungere una colonna percentuale dividendo ogni cella per il totale della riga.

table = pd.pivot_table(df, 'revenue', 'region', 'product', 'sum', fill_value=0)

# Sort by product A revenue descending
table_sorted = table.sort_values('A', ascending=False)
print(table_sorted)

# Add percentage of row total
table['A_pct'] = (table['A'] / table.sum(axis=1) * 100).round(1)
print(table)

Uso pratico: tabella per una dashboard delle vendite

Le tabelle pivot sono uno strumento fondamentale per creare report gestionali e dashboard. Un flusso di lavoro tipico consiste nel caricare i dati grezzi delle transazioni, creare una tabella pivot con i mesi come colonne e le categorie di prodotto come righe, aggiungere i totali dei margini ed esportare il risultato in Excel. L'intero flusso, dai dati grezzi a una tabella pronta per essere presentata alla direzione, richiede solo poche chiamate a Pandas.

# Simulated monthly product revenue pivot
result = pd.pivot_table(
    df,
    values='revenue',
    index='product',
    columns='region',
    aggfunc='sum',
    fill_value=0,
    margins=True,
    margins_name='Grand Total'
)
print(result)
# Export to Excel
# result.to_excel('sales_pivot.xlsx')

Verifica rapida

Verifichi la Sua comprensione di pd.pivot_table in questa lezione.

Riepilogo della lezione

In questa lezione ha imparato che pd.pivot_table() crea riepiloghi tramite tabulazione incrociata, con una dimensione come righe e un'altra come colonne; fill_value gestisce le celle mancanti e margins=True aggiunge i totali; è possibile aggregare più valori contemporaneamente; e le tabelle pivot producono un output in formato ampio, ideale per i report. Ora esamineremo l'operazione inversa: melt() per convertire i dati dal formato ampio a quello lungo.

Gratis per iniziare

Impara Python con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi
30
Lezioni
120

Domande Frequenti

La lezione «pivot_table: tabulazione incrociata» è gratuita?

Sì — il testo completo di «pivot_table: tabulazione incrociata» è 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 «pivot_table: tabulazione incrociata»?

Crei tabelle pivot in stile Excel con pd.pivot_table, impostando index, columns, values e aggfunc. 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 «pivot_table: tabulazione incrociata»?

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. pivot_table: tabulazione incrociata
  2. melt: dal formato ampio al formato lungo
  3. stack e unstack con MultiIndex
  4. crosstab per tabelle di frequenza
← Torna a Pandas & NumPy Academy