Pandas & NumPy Academy · Lektion

Mønsteret split-apply-combine

Forstå det konceptuelle forløb i groupby: opdeling af DataFrame i grupper, anvendelse af en funktion og samling af resultaterne.

Lektion 1 af 413 trin

Mønsteret split-apply-combine er en gratis Pandas & NumPy Academy-lektion på CoddyKit. Dette er lektion 1 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.

Hvad er GroupBy?

Handlingen GroupBy er et af de mest effektive mønstre inden for dataanalyse. Den lader dig opdele en DataFrame i grupper, anvende en funktion på hver gruppe uafhængigt af de andre og derefter samle resultaterne i en ny struktur. Denne arbejdsgang kaldes mønstret split-apply-combine, et begreb statistikeren Hadley Wickham har opfundet.

Opdelingstrinnet

I trinnet split opdeler Pandas DataFrame-en i under-DataFrames baseret på de entydige værdier i én eller flere kolonner. Hvis dine data for eksempel har en region-kolonne med værdier som 'North', 'South' og 'West', opretter opdelingstrinnet tre separate grupper. Der flyttes eller kopieres endnu ingen data — Pandas registrerer blot, hvilke rækker der hører til hvilken gruppe.

import pandas as pd

df = pd.DataFrame({
    'region': ['North', 'South', 'North', 'West', 'South'],
    'sales': [200, 150, 300, 180, 220]
})

# split: create a GroupBy object
grouped = df.groupby('region')
print(type(grouped))  # DataFrameGroupBy

Anvendelsestrinnet

I trinnet apply anvendes en funktion på hver gruppe uafhængigt af de andre. Funktionen kan være en indbygget aggregering som sum() eller mean() eller en brugerdefineret funktion, du definerer. Rækkerne i hver gruppe gives til funktionen, som returnerer en skalar, en Series eller en DataFrame som resultat.

# apply: compute the sum of 'sales' within each region group
total_sales = grouped['sales'].sum()
print(total_sales)
# region
# North    500
# South    370
# West     180
# Name: sales, dtype: int64

Sammenlægningstrinnet

I trinnet combine samler Pandas automatisk resultaterne for de enkelte grupper i ét objekt — typisk en Series eller DataFrame. Gruppenøglerne bliver resultatets indeks. Dette trin foregår automatisk, når du kalder en aggregeringsmetode på et GroupBy-objekt, så du får en overskuelig opsummeringstabel med én række pr. gruppe.

# combine happens automatically — result is a Series indexed by 'region'
print(total_sales.index)   # Index(['North', 'South', 'West'])
print(total_sales.values)  # [500, 370, 180]

Oprettelse af et GroupBy-objekt

Du opretter et GroupBy-objekt ved at kalde df.groupby(column). Der beregnes ikke noget på dette tidspunkt — det er et dovenobjekt. Du kan gennemløbe det for at se grupperne eller kæde en aggregeringsmetode på for at udløse beregningen. Hvis du angiver as_index=False, forbliver grupperingskolonnen en almindelig kolonne i stedet for at blive resultatets indeks.

grouped = df.groupby('region', as_index=False)
result = grouped['sales'].sum()
print(result)
#   region  sales
# 0  North    500
# 1  South    370
# 2   West    180

Gennemløb af grupper

Du kan gennemløbe et GroupBy-objekt for at undersøge hver gruppe individuelt. Hver gentagelse returnerer en tupel med (group_key, sub_dataframe). Det er nyttigt til fejlfinding, eller når du vil behandle hver gruppe med vilkårlig Python-kode. I produktion bør du dog af hensyn til ydeevnen foretrække vektoriserede aggregeringsmetoder frem for eksplicit gennemløb.

for name, group in df.groupby('region'):
    print(f'--- {name} ---')
    print(group)
# --- North ---
#   region  sales
# 0  North    200
# 2  North    300
# --- South ---
#   region  sales
# 1  South    150
# 4  South    220

Almindelige aggregeringsfunktioner

Pandas GroupBy understøtter mange indbyggede aggregeringsfunktioner: sum(), mean(), count(), min(), max(), std(), median() og flere. De er højt optimerede og køres på alle grupper i én gennemgang. Foretræk dem altid frem for at skrive en brugerdefineret Python-funktion, når den indbyggede funktion findes.

print(df.groupby('region')['sales'].mean())
# region
# North    250.0
# South    185.0
# West     180.0

print(df.groupby('region')['sales'].count())
# region
# North    2
# South    2
# West     1

Gruppering af flere kolonner på én gang

Du kan anvende aggregeringer på flere kolonner samtidigt ved at vælge dem, før du kalder aggregeringsmetoden, eller ved at undlade kolonnevalg for at aggregere alle numeriske kolonner. Resultatet er en DataFrame i stedet for en Series med én kolonne pr. aggregeret variabel.

df2 = pd.DataFrame({
    'region': ['North', 'South', 'North', 'South'],
    'units': [10, 8, 12, 9],
    'revenue': [200, 160, 240, 180]
})

print(df2.groupby('region').sum())
#         units  revenue
# region
# North      22      440
# South      17      340

Den mentale model for GroupBy

Tænk på GroupBy som SQL's GROUP BY-klausul. Pandas-koden df.groupby('region')['sales'].sum() svarer til SELECT region, SUM(sales) FROM df GROUP BY region i SQL. Når du forstår denne sammenhæng, bliver det lettere at skifte mellem de to værktøjer og vælge den rette abstraktion til din datapipeline.

# Pandas GroupBy is equivalent to SQL GROUP BY
# SQL:    SELECT region, SUM(sales) FROM df GROUP BY region
# Pandas: df.groupby('region')['sales'].sum()

result = df.groupby('region')['sales'].sum().reset_index()
result.columns = ['region', 'total_sales']
print(result)

Hvorfor ikke bruge en løkke i stedet?

Du tænker måske, at du bare kan gennemløbe entydige værdier og beregne statistikker manuelt. Svaret er ydeevne og læsbarhed. En Python-løkke over grupper er meget langsommere end et enkelt vektoriseret groupby-kald, især for store datasæt. GroupBy-handlinger kører internt i kompileret C-kode, hvilket gør dem 10-100 gange hurtigere end tilsvarende Python-løkker.

# Slow approach with a loop
results = {}
for region in df['region'].unique():
    subset = df[df['region'] == region]
    results[region] = subset['sales'].sum()

# Fast approach with GroupBy
results_fast = df.groupby('region')['sales'].sum().to_dict()
# Both give the same answer, but GroupBy is orders of magnitude faster

GroupBy med flere gruppenøgler

Når du har brug for større detaljeringsgrad, kan du gruppere efter flere kolonner ved at sende en liste til groupby(). Resultatet har et MultiIndex, hvor hvert niveau svarer til én grupperingskolonne. Hvis du for eksempel grupperer efter både 'region' og 'quarter', får du totaler for hver kombination af region og kvartal.

df3 = pd.DataFrame({
    'region': ['North', 'North', 'South', 'South'],
    'quarter': ['Q1', 'Q2', 'Q1', 'Q2'],
    'sales': [200, 300, 150, 220]
})

print(df3.groupby(['region', 'quarter'])['sales'].sum())
# region  quarter
# North   Q1         200
#         Q2         300
# South   Q1         150
#         Q2         220

Hurtigt tjek

Test din forståelse af mønstret split-apply-combine fra denne lektion.

Besvar den i den interaktive lektion

Opsummering af lektionen

I denne lektion har du lært: mønstret split-apply-combine, som ligger til grund for alle GroupBy-handlinger, hvordan du opretter et GroupBy-objekt med df.groupby(), og hvordan du anvender indbyggede aggregeringer som sum() og mean() for at få ét resultat pr. gruppe. Dernæst undersøger vi gruppering efter en eller flere nøgler med flere aggregeringsmetoder.

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

Start gratis Se hele kurset

Ofte stillede spørgsmål

Er lektionen “Mønsteret split-apply-combine” gratis?

Ja — hele teksten til “Mønsteret split-apply-combine” 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 “Mønsteret split-apply-combine”?

Forstå det konceptuelle forløb i groupby: opdeling af DataFrame i grupper, anvendelse af en funktion og samling af resultaterne. 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 1 af 4.

Hvor lang tid tager lektionen “Mønsteret split-apply-combine”?

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

← Tilbage til Pandas & NumPy Academy