Pandas & NumPy Academy · Lektion

melt: fra bredt til langt format

Konvertér en bred DataFrame til langt format med pd.melt, og angiv id_vars og value_vars.

Lektion 2 af 413 trin

melt: fra bredt til langt format er en gratis Pandas & NumPy Academy-lektion på CoddyKit. Dette er lektion 2 af 4. Du kan læse hele lektionen gratis nedenfor — og derefter øve dig praktisk i browseren med en indbygget kodeeditor og en AI-vejleder, der er tilgængelig døgnet rundt. Den er en del af læringsforløbet i Pandas & NumPy Academy, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Pandas & NumPy Academy-kurset indeholder 4 lektioner i alt.

Brede og lange dataformater

Data kan struktureres i to grundlæggende former. Bredt format har én række pr. enhed og fordeler målinger på flere kolonner — f.eks. separate kolonner for salget i januar, februar og marts. Langt format har én række pr. observation med en kolonne for variabelnavnet og en anden for værdien. De fleste analysefunktioner i Pandas, biblioteker til maskinlæring og værktøjer til visualisering foretrækker langt format, hvilket gør melt() til et vigtigt værktøj til dataomformning.

Funktionen pd.melt()

pd.melt(df) (som også findes som df.melt()) konverterer en bred DataFrame til langt format. De vigtigste parametre er id_vars (kolonner, der skal bevares som uændrede identifikatorer), value_vars (kolonner, der skal omdannes til rækker), var_name (navnet på den nye variabelkolonne) og value_name (navnet på den nye værdikolonne).

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  160

Grundlæggende kald af melt()

Kald melt() med id_vars sat til de kolonner, du vil bevare som identifikatorer. Alle andre kolonner omdannes: deres navn bliver en værdi i den nye variabelkolonne, og deres celleværdier flyttes til værdikolonnen. Antallet af outputrækker svarer til antallet af inputrækker gange antallet af værdikolonner, der omdannes.

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    160

Valg af kolonner, der skal omdannes

Som standard omdannes alle kolonner, der ikke står i id_vars. Brug value_vars til kun at omdanne en delmængde af kolonnerne. Kolonner, der hverken står i id_vars eller value_vars, fjernes fra resultatet. Det er nyttigt, når din brede DataFrame indeholder en blanding af tidsserie kolonner og andre attributter, som du ikke vil omdanne.

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)

Nulstilling af indekset efter melt()

melt() bevarer de oprindelige rækkeindeks ved at gentage dem for hver variabel. Resultatet har ofte et ikke-sekventielt indeks som [0, 1, 0, 1, 0, 1]. Det er god praksis at kalde reset_index(drop=True) umiddelbart efter melt() for at få et rent, sekventielt indeks fra 0 til n-1 i outputtet.

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() er den omvendte operation af pivot()

melt() er begrebsmæssigt den omvendte operation af pivot() / pivot_table(). Du kan gå fra langt til bredt format med pivot_table() og fra bredt tilbage til langt format med melt(). Denne tur-retur-omformning bruges ofte i datapipelines: modtag data i bredt format, omform dem til langt format til visualisering med Seaborn eller til ML-funktioner, og omdan dem eventuelt tilbage til en rapporttabel.

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

Brug af melt() til visualisering med Seaborn

Seaborns kategoriske og relationelle diagrammer fungerer bedst med data i langt format. En typisk arbejdsgang er: Start med en bred DataFrame, der har én kolonne pr. gruppe, konvertér den til langt format, så én kolonne identificerer gruppen, og en anden indeholder værdierne, og giv derefter begge videre til Seaborns parametre hue og x/y. Dette er en af de mest almindelige grunde til at bruge 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)

Navngivning af outputkolonnerne

Som standard navngiver melt() den nye variabelkolonne 'variable' og værdikolonnen 'value'. Overskriv altid disse med meningsfulde navne ved hjælp af var_name og value_name. Beskrivende kolonnenavne gør efterfølgende kode lettere at læse og forhindrer forvirring, når en DataFrame har dusinvis af kolonner.

# 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']

Konvertering af spørgeskemadata

Et klassisk anvendelsesområde for melt() er svar på spørgeskemaer, hvor hver kolonne er et spørgsmål, og hver række er en respondent. Konverteringen omdanner dette brede format til langt format med kolonner for respondent-id, spørgsmålsnavn og svarværdi. Derefter kan du nemt beregne fordelingen af svar for hvert spørgsmål ved hjælp af 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())

Sortering af det konverterede resultat

Efter konverteringen er rækkerne ordnet efter den oprindelige kolonnerækkefølge (Jan, Feb, Mar for hver række). Ofte vil du sortere efter identifikatorkolonnen først og derefter efter variabelkolonnen. Brug sort_values() på den konverterede DataFrame for at opnå den rækkefølge, der giver mest mening for din analyse eller efterfølgende behandling.

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    160

melt() i en databehandlingsarbejdsgang

I en typisk databehandlingsarbejdsgang optræder melt() lige efter indlæsning eller oprydning i data i bredt format og før et analyse- eller modelleringsskridt. Placér den tidligt i arbejdsgangen, så du hurtigt får data i langt format. Derefter kan alle efterfølgende operationer (groupby, seaborn, sklearn) arbejde med de rene data i langt format uden særbehandling.

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)

Hurtigt tjek

Test din forståelse af pd.melts transformation fra bredt til langt format i denne lektion.

Opsummering af lektionen

I denne lektion har du lært, at melt() konverterer bredt til langt format ved at omdanne kolonner til rækker; id_vars angiver, hvilke kolonner der forbliver faste, og value_vars vælger, hvilke kolonner der skal konverteres; var_name og value_name giver de nye kolonner beskrivende navne; og langt format foretrækkes til Seaborn, groupby og ML-arbejdsgange. Nu går vi videre til stack og unstack for at omforme MultiIndex-DataFrames.

Gratis at komme i gang

Lær Python med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
30
Lektioner
120

Ofte stillede spørgsmål

Er lektionen “melt: fra bredt til langt format” gratis?

Ja — hele teksten til “melt: fra bredt til langt format” kan læses gratis her på nettet. Hvis du vil øve dig interaktivt med en indbygget kodeeditor og en AI-vejleder døgnet rundt og få adgang til resten af Pandas & NumPy Academy-kurset, skal du opgradere til CoddyKit PRO. Pandas & NumPy Academy-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “melt: fra bredt til langt format”?

Konvertér en bred DataFrame til langt format med pd.melt, og angiv id_vars og value_vars. Du øver dig i Pandas & NumPy Academy med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Pandas & NumPy Academy?

Der kræves ingen tidligere erfaring. Pandas & NumPy Academy på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 2 af 4.

Hvor lang tid tager lektionen “melt: fra bredt til langt format”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Pandas & NumPy Academy-lektion?

Ja. Alle Pandas & NumPy Academy-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. pivot_table: krydstabulering
  2. melt: fra bredt til langt format
  3. stack og unstack med MultiIndex
  4. crosstab til frekvenstabeller
← Tilbage til Pandas & NumPy Academy