0Pricing
Pandas & NumPy Academy · Lezione

crosstab per tabelle di frequenza

Calcoli una tabulazione incrociata di frequenze o proporzioni tra due colonne categoriche con pd.crosstab.

crosstab per tabelle di frequenza è una lezione Pandas & NumPy Academy gratuita su CoddyKit. Questa è la lezione 4 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 tabulazione incrociata?

Una tabulazione incrociata (crosstab) conta quante volte ciascuna combinazione di valori di due o più variabili categoriali compare in un dataset. È un caso particolare di tabella pivot progettato appositamente per il conteggio. Pandas fornisce pd.crosstab() come metodo conciso per calcolare queste tabelle di frequenza senza dover chiamare esplicitamente groupby() o pivot_table().

Chiamata di base a crosstab()

La chiamata minima pd.crosstab(index, columns) accetta due input simili ad array, in genere colonne di un DataFrame, e restituisce una tabella di frequenza. Le righe corrispondono ai valori univoci del primo argomento e le colonne ai valori univoci del secondo. Ogni cella contiene il conteggio delle righe in cui entrambi i valori compaiono contemporaneamente nei dati originali.

import pandas as pd

df = pd.DataFrame({
    'gender':  ['M', 'F', 'M', 'F', 'M', 'F', 'M'],
    'product': ['A', 'A', 'B', 'B', 'A', 'B', 'B']
})

ct = pd.crosstab(df['gender'], df['product'])
print(ct)
# product  A  B
# gender
# F        1  2
# M        2  2

Personalizzare i nomi di righe e colonne

Utilizzi i parametri rownames e colnames per assegnare nomi significativi agli assi delle righe e delle colonne nell'output, sostituendo i nomi predefiniti delle Series. È utile quando i nomi delle colonne originali del DataFrame non sono sufficientemente esplicativi nel contesto della tabella prodotta.

ct = pd.crosstab(
    df['gender'], df['product'],
    rownames=['Customer Gender'],
    colnames=['Purchased Product']
)
print(ct)
# Purchased Product  A  B
# Customer Gender
# F                  1  2
# M                  2  2

Aggiungere i totali di riga e colonna

Passi margins=True per includere una riga e una colonna con i totali di tutti i valori. L'etichetta del margine è 'All' per impostazione predefinita, ma può essere personalizzata con margins_name. La riga dei margini mostra il conteggio totale per colonna, la colonna dei margini mostra il conteggio totale per riga e la cella in basso a destra mostra il totale complessivo.

ct = pd.crosstab(df['gender'], df['product'],
                 margins=True, margins_name='Total')
print(ct)
# product  A  B  Total
# gender
# F        1  2      3
# M        2  2      4
# Total    3  4      7

Normalizzare in proporzioni

Passi il parametro normalize per convertire i conteggi in proporzioni. normalize=True o normalize='all' divide per il totale complessivo. normalize='index' calcola le proporzioni per riga (ogni riga ha somma pari a 1.0). normalize='columns' calcola le proporzioni per colonna (ogni colonna ha somma pari a 1.0). Le proporzioni sono più informative dei conteggi grezzi quando le dimensioni dei gruppi differiscono.

# Row proportions: what fraction of each gender bought each product?
print(pd.crosstab(df['gender'], df['product'], normalize='index').round(2))
# product     A     B
# gender
# F        0.33  0.67
# M        0.50  0.50

# All proportions: each cell as fraction of grand total
print(pd.crosstab(df['gender'], df['product'], normalize=True).round(2))

Aggregare valori invece di contarli

Per impostazione predefinita, crosstab conta le righe. In alternativa, può aggregare una colonna numerica passando i parametri values e aggfunc, in modo simile a pivot_table(). Ad esempio, può calcolare il fatturato totale per ogni combinazione di genere e prodotto. In questo modo crosstab diventa quasi equivalente a pivot_table, ma con una sintassi leggermente più concisa per i casi d'uso basati sulle tabelle di frequenza.

df['revenue'] = [100, 80, 150, 120, 200, 90, 130]

# Sum revenue by gender and product instead of counting
ct_rev = pd.crosstab(
    df['gender'], df['product'],
    values=df['revenue'],
    aggfunc='sum'
)
print(ct_rev)
# product    A    B
# gender
# F         80  210
# M        300  280

Crosstab multilivello

Passi una lista a index o columns per creare una crosstab con più livelli nelle righe o nelle colonne. Il risultato ha un MultiIndex e offre una suddivisione più dettagliata. Ad esempio, una tabulazione incrociata per genere e area geografica nelle righe e per prodotto nelle colonne mostra ogni combinazione genere-area geografica-prodotto.

df['region'] = ['East', 'West', 'East', 'West', 'East', 'East', 'West']

ct_multi = pd.crosstab(
    [df['gender'], df['region']],
    df['product'],
    margins=True
)
print(ct_multi)
# product         A  B  All
# gender region
# F      East     0  1    1
#        West     1  1    2
# M      East     2  1    3
#        West     0  1    1
# All            3  4    7

crosstab() e pivot_table() a confronto

pd.crosstab() e pd.pivot_table() si sovrappongono notevolmente. crosstab è ottimizzato per il conteggio delle frequenze e accetta direttamente input simili ad array (non un DataFrame), risultando quindi leggermente più conciso per le tabulazioni rapide. pivot_table opera su un DataFrame e supporta nativamente qualsiasi funzione di aggregazione. Per i semplici conteggi, crosstab è la scelta idiomatica; per aggregare valori numerici, è preferibile pivot_table.

# crosstab (more concise for counting)
print(pd.crosstab(df['gender'], df['product']))

# Equivalent pivot_table
print(pd.pivot_table(df, index='gender', columns='product',
                     aggfunc='size', fill_value=0))
# Both produce the same result

Preparazione al test del chi quadrato

Una crosstab è l'input standard per un test del chi quadrato di indipendenza, che verifica se due variabili categoriali sono statisticamente correlate. La funzione scipy.stats.chi2_contingency() accetta direttamente un array crosstab. Questo è uno degli usi più comuni di crosstab nell'analisi statistica dei dati: si calcola la tabella e la si sottopone al test all'interno dello stesso flusso di lavoro.

from scipy import stats

ct = pd.crosstab(df['gender'], df['product'])
# Convert to numpy array for scipy
chi2, p, dof, expected = stats.chi2_contingency(ct.values)
print(f'Chi2: {chi2:.2f}')
print(f'P-value: {p:.4f}')
print(f'Degrees of freedom: {dof}')
# p > 0.05 means no significant association

Visualizzare una crosstab come heatmap

Le crosstab con molte categorie sono difficili da interpretare come semplici numeri. Visualizzarle come heatmap con sns.heatmap() rende immediatamente visibili i modelli: le celle con frequenza elevata appaiono con colori più brillanti. Passi la versione normalizzata per mostrare le proporzioni anziché i conteggi grezzi e utilizzi annot=True per visualizzare i valori in ogni cella.

import seaborn as sns
import matplotlib.pyplot as plt

ct_norm = pd.crosstab(df['gender'], df['product'], normalize='index')

# sns.heatmap(ct_norm, annot=True, fmt='.0%', cmap='Blues')
# plt.title('Purchase Rate by Gender and Product')
# plt.tight_layout()
# plt.show()
print('Normalised crosstab ready for heatmap:')
print(ct_norm.round(2))

Esempio pratico: analisi di un sondaggio

Un flusso di lavoro completo per le tabelle a doppia entrata: caricare i dati del sondaggio, calcolare le tabelle di frequenza tra variabili demografiche e variabili di risposta, normalizzare per righe per ottenere i tassi di risposta e individuare eventuali schemi rilevanti. Questa è la pipeline di analisi standard nelle ricerche di mercato, nei test A/B e nella segmentazione degli utenti, e può essere completata con meno di 10 righe di codice Pandas.

# Simulate a survey dataset
survey = pd.DataFrame({
    'age_group': ['18-25', '26-35', '18-25', '36-45', '26-35', '36-45'],
    'satisfaction': ['High', 'Low', 'High', 'Medium', 'High', 'Low']
})

ct = pd.crosstab(survey['age_group'], survey['satisfaction'],
                 margins=True, margins_name='Total')
print(ct)

rates = pd.crosstab(survey['age_group'], survey['satisfaction'],
                    normalize='index').round(2)
print(rates)

Controllo rapido

Verifichi la Sua comprensione di pd.crosstab per creare tabelle di frequenza a partire dai contenuti di questa lezione.

Riepilogo della lezione

In questa lezione ha imparato che: pd.crosstab() calcola i conteggi di frequenza per le combinazioni di due variabili categoriche; normalize converte i conteggi in proporzioni per riga, per colonna o totali; margins=True aggiunge i totali di riga e colonna; inoltre, l'output di crosstab è direttamente compatibile con i test del chi quadrato e le visualizzazioni a mappa di calore. Prossimamente lavoreremo con dati di serie temporali usando DatetimeIndex e intervalli di periodi.

Domande Frequenti

La lezione «crosstab per tabelle di frequenza» è gratuita?

Sì — il testo completo di «crosstab per tabelle di frequenza» è 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 «crosstab per tabelle di frequenza»?

Calcoli una tabulazione incrociata di frequenze o proporzioni tra due colonne categoriche con pd.crosstab. 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 4 di 4.

Quanto tempo richiede la lezione «crosstab per tabelle di frequenza»?

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