Pandas & NumPy Academy · leksjon

melt: fra bredt til langt format

Konverter en bred DataFrame til langt format med pd.melt, og angi id_vars og value_vars.

Leksjon 2 av 413 trinn

melt: fra bredt til langt format er en gratis leksjon i Pandas & NumPy Academy på CoddyKit. Dette er leksjon 2 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Pandas & NumPy Academy, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.

Bredt kontra langt dataformat

Data kan struktureres i to grunnleggende former. Bredt format har én rad per enhet og fordeler målingene over flere kolonner — for eksempel separate kolonner for salg i januar, februar og mars. Langt format har én rad per observasjon, med én kolonne for variabelnavnet og en annen for verdien. De fleste analysefunksjonene i Pandas, maskinlæringsbiblioteker og visualiseringsverktøy foretrekker langt format, noe som gjør melt() til et viktig verktøy for omforming.

Funksjonen pd.melt()

pd.melt(df) (også tilgjengelig som df.melt()) konverterer en bred DataFrame til langt format. De viktigste parameterne er id_vars (kolonner som skal beholdes som uendrede identifikatorer), value_vars (kolonner som skal omformes til rader), var_name (navnet på den nye variabelkolonnen) og value_name (navnet på den nye verdikolonnen).

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

Grunnleggende kall til melt()

Kall melt() med id_vars satt til kolonnene du vil beholde som identifikatorer. Alle andre kolonner omformes: navnet blir en verdi i den nye variabelkolonnen, og celleverdiene flyttes til verdikolonnen. Antallet rader i resultatet er lik antallet rader i inndataene multiplisert med antallet verdikolonner som omformes.

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

Velge hvilke kolonner som skal omformes

Som standard omformes alle kolonner som ikke er oppført i id_vars. Bruk value_vars for å omforme bare et utvalg av kolonnene. Kolonner som verken finnes i id_vars eller value_vars, fjernes fra resultatet. Dette er nyttig når den brede DataFrame-en inneholder en blanding av tidsseriekolonner og andre attributter som du ikke vil omforme.

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)

Tilbakestille indeksen etter melt()

melt() bevarer de opprinnelige radindeksene ved å gjenta dem for hver variabel. Resultatet får ofte en indeks som ikke følger rekkefølgen, for eksempel [0, 1, 0, 1, 0, 1]. Det er god praksis å kalle reset_index(drop=True) umiddelbart etter melt() for å få en ren, sekvensiell indeks fra 0 til n-1 i resultatet.

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 det motsatte av pivot()

melt() er konseptuelt det motsatte av pivot() / pivot_table(). Du kan gå fra langt til bredt format med pivot_table(), og fra bredt tilbake til langt format med melt(). Denne tur-retur-konverteringen brukes ofte i arbeidsflyter: motta data i bredt format, omform dem til langt format for visualisering med Seaborn eller maskinlæringsfunksjoner, og pivoter dem eventuelt tilbake for en rapporttabell.

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

Bruke melt() til plotting med Seaborn

Seaborns kategoriske og relasjonelle plott fungerer best med data i langt format. En typisk arbeidsflyt er å starte med en bred DataFrame som har én kolonne per gruppe, konvertere den til langt format ved å smelte den slik at én kolonne identifiserer gruppen og en annen inneholder verdiene, og deretter sende begge til Seaborns hue- og x/y-parametere. Dette er en av de vanligste grunnene til å bruke 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)

Navngi resultatkolonnene

Som standard gir melt() den nye variabelkolonnen navnet 'variable' og verdikolonnen navnet 'value'. Overstyr alltid disse med meningsfulle navn ved å bruke var_name og value_name. Beskrivende kolonnenavn gjør etterfølgende kode enklere å lese og forebygger forvirring når en DataFrame har dusinvis av 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']

Smelte spørreundersøkelsesdata

Et klassisk bruksområde for melt() er svar fra spørreundersøkelser, der hver kolonne er et spørsmål og hver rad er en respondent. Smelting konverterer dette brede formatet til langt format med kolonner for respondent-ID, spørsmålsnavn og svarverdi. Deretter kan De enkelt beregne fordelingen av svarene for hvert spørsmål ved å bruke 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())

Sortere det smeltede resultatet

Etter smelting er radene ordnet etter den opprinnelige kolonnerekkefølgen (jan., feb., mars for hver rad). Ofte vil De sortere først etter identifikatorkolonnen og deretter etter variabelkolonnen. Bruk sort_values() på den smeltede DataFrame-en for å få den rekkefølgen som passer best for analysen eller den videre behandlingen.

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 datapipeline

I en typisk datapipeline kommer melt() rett etter at data i bredt format er lastet inn eller renset, og før et analyse- eller modelleringssteg. Plasser den tidlig i pipelinen for raskt å konvertere dataene til langt format. Da kan alle etterfølgende operasjoner (groupby, seaborn, sklearn) arbeide med de rene dataene i langt format uten særtilpasninger.

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)

Kort kunnskapssjekk

Test forståelsen Deres av transformasjonen fra bredt til langt format med pd.melt fra denne leksjonen.

Besvar den i den interaktive leksjonen

Oppsummering av leksjonen

I denne leksjonen lærte De at melt() konverterer bredt til langt format ved å gjøre kolonner om til rader; id_vars angir hvilke kolonner som skal forbli faste, og value_vars velger hvilke kolonner som skal smeltes; var_name og value_name gir de nye kolonnene beskrivende navn; og langt format foretrekkes for Seaborn-, groupby- og ML-pipelines. Neste gang utforsker vi stack og unstack for omforming av MultiIndex-DataFrame-er.

Gratis å komme i gang

Lær deg Python med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 30
Leksjoner: 120

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «melt: fra bredt til langt format» gratis?

Ja – hele teksten i «melt: fra bredt til langt format» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Pandas & NumPy Academy-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Pandas & NumPy Academy inneholder totalt 4 leksjoner.

Hva lærer jeg i «melt: fra bredt til langt format»?

Konverter en bred DataFrame til langt format med pd.melt, og angi id_vars og value_vars. Du øver på Pandas & NumPy Academy med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Pandas & NumPy Academy?

Ingen tidligere erfaring er nødvendig. Pandas & NumPy Academy på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 2 av 4.

Hvor lang tid tar leksjonen «melt: fra bredt til langt format»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Pandas & NumPy Academy-leksjonen?

Ja. Alle Pandas & NumPy Academy-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Pandas & NumPy Academy