melt: dal formato ampio al formato lungo
Converta un DataFrame dal formato ampio al formato lungo con pd.melt, specificando id_vars e value_vars.
melt: dal formato ampio al formato lungo è 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.
Formati dei dati ampio e lungo
I dati possono essere strutturati in due forme fondamentali. Il formato ampio ha una riga per soggetto e distribuisce le misurazioni su più colonne, ad esempio colonne separate per le vendite di gennaio, febbraio e marzo. Il formato lungo ha una riga per osservazione, con una colonna per il nome della variabile e un'altra per il valore. La maggior parte delle funzioni di analisi di Pandas, delle librerie di machine learning e degli strumenti di visualizzazione preferisce il formato lungo, rendendo melt() uno strumento di trasformazione essenziale.
La funzione pd.melt()
pd.melt(df) (disponibile anche come df.melt()) converte un DataFrame dal formato ampio a quello lungo. I parametri principali sono id_vars (le colonne da mantenere invariate come identificatori), value_vars (le colonne da trasformare in righe), var_name (il nome della nuova colonna delle variabili) e value_name (il nome della nuova colonna dei valori).
import pandas as pd
# Wide format: separate columns per month
df_wide = pd.DataFrame({
'product': ['A', 'B'],
'Jan': [100, 150],
'Feb': [120, 130],
'Mar': [140, 160]
})
print(df_wide)
# product Jan Feb Mar
# 0 A 100 120 140
# 1 B 150 130 160Chiamata di base a melt()
Chiami melt() impostando id_vars sulle colonne che desidera mantenere come identificatori. Ogni altra colonna viene trasformata: il suo nome diventa un valore nella nuova colonna delle variabili e i valori delle celle vengono spostati nella colonna dei valori. Il numero di righe dell'output è uguale al numero di righe dell'input moltiplicato per il numero di colonne dei valori trasformate.
df_long = df_wide.melt(
id_vars='product',
var_name='month',
value_name='sales'
)
print(df_long)
# product month sales
# 0 A Jan 100
# 1 B Jan 150
# 2 A Feb 120
# 3 B Feb 130
# 4 A Mar 140
# 5 B Mar 160Selezionare le colonne da trasformare
Per impostazione predefinita, viene trasformata ogni colonna non elencata in id_vars. Usi value_vars per trasformare solo un sottoinsieme di colonne. Le colonne che non sono presenti in id_vars o value_vars vengono escluse dal risultato. È utile quando il DataFrame in formato ampio contiene un insieme di colonne di serie temporali e altri attributi che non desidera trasformare.
df_wide2 = pd.DataFrame({
'product': ['A', 'B'],
'category': ['Electronics', 'Clothing'],
'Jan': [100, 150],
'Feb': [120, 130],
'Mar': [140, 160]
})
# Melt only Jan and Feb, keep product and category
df_long2 = df_wide2.melt(
id_vars=['product', 'category'],
value_vars=['Jan', 'Feb'],
var_name='month',
value_name='sales'
)
print(df_long2)Reimpostare l'indice dopo melt()
melt() conserva gli indici originali delle righe, ripetendoli per ogni variabile. Il risultato presenta spesso un indice non sequenziale, come [0, 1, 0, 1, 0, 1]. È buona pratica chiamare subito reset_index(drop=True) dopo melt() per ottenere nell'output un indice sequenziale pulito da 0 a n-1.
df_long = df_wide.melt(id_vars='product', var_name='month', value_name='sales')
print('Before reset:', df_long.index.tolist())
# [0, 1, 0, 1, 0, 1]
df_long = df_long.reset_index(drop=True)
print('After reset:', df_long.index.tolist())
# [0, 1, 2, 3, 4, 5]melt() è l'inverso di pivot()
melt() è concettualmente l'inverso di pivot() / pivot_table(). Può passare dal formato lungo a quello ampio con pivot_table() e dal formato ampio a quello lungo con melt(). Questo percorso di andata e ritorno è spesso usato nelle pipeline: si ricevono dati in formato ampio, li si rimodella in formato lungo per la visualizzazione con Seaborn o per le caratteristiche di ML, quindi, se necessario, li si riporta al formato ampio per una tabella di report.
# long -> wide
table = df_long.pivot_table(values='sales', index='product',
columns='month', aggfunc='sum')
print(table)
# product Feb Jan Mar
# A 120 100 140
# B 130 150 160
# wide -> long again
long_again = table.reset_index().melt(id_vars='product', var_name='month', value_name='sales')
print(long_again.head())Usare melt() per i grafici con Seaborn
I grafici categoriali e relazionali di Seaborn funzionano al meglio con dati in formato long. Un flusso di lavoro tipico consiste nel partire da un DataFrame in formato wide con una colonna per ogni gruppo, convertirlo in formato long con melt() in modo che una colonna identifichi il gruppo e un'altra contenga i valori, quindi passare entrambe a hue e ai parametri x/y di Seaborn. Questo è uno dei motivi più comuni per utilizzare melt().
import seaborn as sns
import matplotlib.pyplot as plt
# Long format is required for sns.lineplot with hue
df_long = df_wide.melt(id_vars='product', var_name='month', value_name='sales')
# sns.lineplot(data=df_long, x='month', y='sales', hue='product')
# plt.show()
print('Long data ready for Seaborn:')
print(df_long)Assegnare un nome alle colonne di output
Per impostazione predefinita, melt() assegna alla nuova colonna delle variabili il nome 'variable' e alla colonna dei valori il nome 'value'. Sostituisca sempre questi nomi con nomi significativi utilizzando var_name e value_name. Nomi descrittivi per le colonne rendono più leggibile il codice successivo e prevengono la confusione quando un DataFrame contiene decine di colonne.
# Default: generic column names 'variable' and 'value'
default = df_wide.melt(id_vars='product')
print(default.columns.tolist())
# ['product', 'variable', 'value']
# Better: descriptive names
good = df_wide.melt(id_vars='product', var_name='month', value_name='revenue_usd')
print(good.columns.tolist())
# ['product', 'month', 'revenue_usd']Convertire i dati di un sondaggio
Un caso d'uso classico di melt() è rappresentato dalle risposte a un sondaggio, in cui ogni colonna corrisponde a una domanda e ogni riga a un rispondente. La conversione trasforma questo formato wide in formato long, con colonne per l'ID del rispondente, il nome della domanda e il valore della risposta. Può quindi calcolare facilmente la distribuzione delle risposte per ogni domanda utilizzando groupby().
survey = pd.DataFrame({
'respondent': [1, 2, 3],
'Q1_rating': [5, 3, 4],
'Q2_rating': [4, 5, 3],
'Q3_rating': [2, 4, 5]
})
long = survey.melt(id_vars='respondent', var_name='question', value_name='rating')
print(long)
print(long.groupby('question')['rating'].mean())Ordinare il risultato della conversione
Dopo la conversione, le righe sono ordinate in base all'ordine originale delle colonne (Gen, Feb, Mar per ogni riga). Spesso è utile ordinare prima in base alla colonna identificativa e poi in base alla colonna delle variabili. Utilizzi sort_values() sul DataFrame convertito per ottenere l'ordine più adatto all'analisi o all'elaborazione successiva.
df_long = df_wide.melt(id_vars='product', var_name='month', value_name='sales')
# Sort by product, then month
df_sorted = df_long.sort_values(['product', 'month']).reset_index(drop=True)
print(df_sorted)
# product month sales
# 0 A Feb 120
# 1 A Jan 100
# 2 A Mar 140
# 3 B Feb 130
# 4 B Jan 150
# 5 B Mar 160melt() in una pipeline di dati
In una pipeline di dati tipica, melt() viene utilizzato subito dopo il caricamento o la pulizia di dati in formato wide, prima di qualsiasi fase di analisi o modellazione. Lo inserisca nelle prime fasi della pipeline per ottenere rapidamente il formato long; in questo modo, tutte le operazioni successive (groupby, seaborn, sklearn) lavorano su dati puliti in formato long senza dover gestire casi speciali.
def load_and_reshape(filepath):
raw = pd.read_csv(filepath)
# Melt all month columns into long format
month_cols = [c for c in raw.columns if c.startswith('month_')]
long = raw.melt(
id_vars=[c for c in raw.columns if c not in month_cols],
value_vars=month_cols,
var_name='month',
value_name='value'
)
return long.reset_index(drop=True)Verifica rapida
Verifichi la Sua comprensione della trasformazione da formato wide a long con pd.melt() illustrata in questa lezione.
Riepilogo della lezione
In questa lezione ha imparato che melt() converte il formato wide in formato long trasformando le colonne in righe; id_vars specifica le colonne che rimangono fisse e value_vars seleziona le colonne da convertire; var_name e value_name assegnano nomi descrittivi alle nuove colonne; infine, il formato long è preferibile per Seaborn, groupby e le pipeline di ML. Ora esamineremo stack e unstack per modificare la forma dei DataFrame con MultiIndex.
Domande Frequenti
La lezione «melt: dal formato ampio al formato lungo» è gratuita?
Sì — il testo completo di «melt: dal formato ampio al formato lungo» è 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 «melt: dal formato ampio al formato lungo»?
Converta un DataFrame dal formato ampio al formato lungo con pd.melt, specificando id_vars e value_vars. 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 «melt: dal formato ampio al formato lungo»?
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
- pivot_table: tabulazione incrociata
- melt: dal formato ampio al formato lungo
- stack e unstack con MultiIndex
- crosstab per tabelle di frequenza