Pandas & NumPy Academy · Lektion

GroupBy med én eller flere nøgler

Gruppér efter én eller flere kolonner med groupby(), og anvend aggregeringerne sum, mean, count og min/max.

Lektion 2 af 413 trin

GroupBy med én eller flere nøgler 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.

GroupBy med én nøgle

Det enkleste GroupBy-kald bruger én kolonne som grupperingsnøgle. Du kalder df.groupby('column_name') og kæder en aggregering på. Pandas opretter én gruppe for hver entydig værdi i kolonnen og anvender aggregeringen på alle numeriske kolonner eller den valgte kolonne. Dette er den mest almindelige form for GroupBy i daglig analyse.

import pandas as pd

df = pd.DataFrame({
    'dept': ['Eng', 'HR', 'Eng', 'HR', 'Eng'],
    'salary': [90000, 60000, 95000, 62000, 88000],
    'years': [3, 5, 7, 2, 4]
})

print(df.groupby('dept')['salary'].mean())
# dept
# Eng    91000.0
# HR     61000.0

Valg af kolonner, der skal aggregeres

Efter kaldet til groupby() kan du vælge én kolonne med kantparenteser for at få en SeriesGroupBy eller vælge flere kolonner med en liste for at få en DataFrameGroupBy. Hvis du helt undlader at vælge kolonner, aggregerer Pandas alle numeriske kolonner. Det er praktisk, men kan give uventede resultater, hvis du har irrelevante numeriske kolonner.

# Single column result -> SeriesGroupBy
print(df.groupby('dept')['salary'].sum())

# Multiple columns result -> DataFrameGroupBy
print(df.groupby('dept')[['salary', 'years']].mean())
#        salary  years
# dept
# Eng   91000.0    4.667
# HR    61000.0    3.500

Alle almindelige aggregeringer

Pandas understøtter et komplet sæt indbyggede aggregeringsmetoder på GroupBy-objekter: sum(), mean(), median(), min(), max(), count(), std(), var(), first() og last(). Hver metode returnerer en skalar pr. gruppe, så du får en overskuelig opsummeringstabel indekseret efter grupperingsnøglen.

g = df.groupby('dept')['salary']
print('sum:   ', g.sum())
print('mean:  ', g.mean())
print('min:   ', g.min())
print('max:   ', g.max())
print('count: ', g.count())
print('std:   ', g.std().round(2))

GroupBy med flere nøgler

Send en liste med kolonnenavne til groupby() for at gruppere efter mere end én dimension på én gang. Hver entydige kombination af værdier i kolonnerne bliver sin egen gruppe. Resultatet har et MultiIndex med ét niveau pr. grupperingskolonne, så du kan gå i dybden med opsummeringer på tværs af dimensioner i ét trin.

df2 = pd.DataFrame({
    'dept':   ['Eng', 'Eng', 'HR',  'HR',  'Eng', 'HR'],
    'level':  ['L1',  'L2',  'L1',  'L2',  'L1',  'L1'],
    'salary': [80000, 100000, 55000, 70000, 82000, 58000]
})

result = df2.groupby(['dept', 'level'])['salary'].mean()
print(result)
# dept  level
# Eng   L1       81000.0
#       L2      100000.0
# HR    L1       56500.0
#       L2       70000.0

Adgang til MultiIndex-resultater

Når du grupperer efter flere nøgler, er resultatets indeks et MultiIndex. Du kan få adgang til et bestemt ydre niveau med .loc['value'] og navigere i indre niveauer med tupler. Kaldet reset_index() omdanner MultiIndex til almindelige kolonner, hvilket ofte er mere praktisk til videre behandling eller eksport.

result = df2.groupby(['dept', 'level'])['salary'].mean()

# Access Engineering rows only
print(result.loc['Eng'])
# level
# L1     81000.0
# L2    100000.0

# Flatten to a regular DataFrame
print(result.reset_index())
#   dept level    salary
# 0  Eng    L1   81000.0
# 1  Eng    L2  100000.0

Brug af as_index=False

Som standard bliver grupperingskolonnerne resultatets indeks. Hvis du angiver as_index=False, forbliver de i stedet almindelige kolonner, så du får en flad DataFrame, der er lettere at sende videre til andre Pandas-handlinger eller eksportere. Det svarer til at kalde reset_index() på resultatet.

flat = df2.groupby(['dept', 'level'], as_index=False)['salary'].mean()
print(flat)
#   dept level    salary
# 0  Eng    L1   81000.0
# 1  Eng    L2  100000.0
# 2   HR    L1   56500.0
# 3   HR    L2   70000.0

Optælling af rækker pr. gruppe

count() returnerer antallet af ikke-null-værdier i hver gruppe. Hvis du vil have det samlede antal rækker pr. gruppe uanset null-værdier, skal du i stedet bruge size(). Denne forskel er vigtig, når dine data indeholder manglende værdier, fordi count() tæller for få rækker i grupper med NaN-poster.

import numpy as np

df3 = pd.DataFrame({
    'dept': ['Eng', 'Eng', 'HR', 'HR'],
    'bonus': [5000, np.nan, 3000, 4000]
})

print(df3.groupby('dept')['bonus'].count())  # ignores NaN
# dept
# Eng    1
# HR     2

print(df3.groupby('dept')['bonus'].size())   # includes NaN rows
# dept
# Eng    2
# HR     2

Sortering af GroupBy-resultater

Som standard sorterer GroupBy resultatet efter gruppenøglen. Du kan deaktivere sorteringen med sort=False for at bevare den oprindelige rækkefølge for den første forekomst, hvilket er en smule hurtigere på store datasæt. Når du har resultatet som en DataFrame, kan du sortere det yderligere med sort_values() efter en vilkårlig kolonne.

result = (df.groupby('dept', sort=False)['salary']
            .mean()
            .reset_index()
            .sort_values('salary', ascending=False))
print(result)
#   dept    salary
# 0  Eng   91000.0
# 1   HR   61000.0

Kædning af GroupBy med andre metoder

GroupBy-resultater er almindelige Series- eller DataFrame-objekter, så du kan kæde flere Pandas-metoder på dem med det samme. Et almindeligt mønster er at aggregere, derefter kalde reset_index(), omdøbe kolonner og så kalde sort_values() — alt sammen i én læsbar metodekæde uden at gemme mellemliggende variabler.

summary = (
    df
    .groupby('dept')['salary']
    .agg(['mean', 'count'])
    .rename(columns={'mean': 'avg_salary', 'count': 'headcount'})
    .reset_index()
    .sort_values('avg_salary', ascending=False)
)
print(summary)

Anvendelse af sum, mean og count samlet

Du har ofte brug for mere end én statistik pr. gruppe. Send en liste med funktionsnavne til .agg() for at beregne flere på én gang. Resultatet er en DataFrame med én kolonne for hver funktion. Det er mere effektivt end at kalde hver aggregering separat, fordi Pandas behandler dem alle i én gennemgang af dataene.

result = df.groupby('dept')['salary'].agg(['sum', 'mean', 'count', 'max'])
print(result)
#           sum      mean  count    max
# dept
# Eng    273000   91000.0      3  95000
# HR     122000   61000.0      2  62000

Gruppering efter kategoriske kolonner

Når en grupperingskolonne har datatypen Categorical, medtager Pandas som standard alle kategorier i resultatet, også dem uden rækker. Det kan være nyttigt for at sikre, at opsummeringstabellen altid viser alle kategorier, men det opretter rækker med NaN eller 0 for tomme grupper. Du styrer dette med parameteren observed — angiv True for at udelade tomme kategorier.

df['dept'] = df['dept'].astype('category')
# With observed=True, only groups that appear in data are included
print(df.groupby('dept', observed=True)['salary'].mean())
# dept
# Eng    91000.0
# HR     61000.0

Hurtigt tjek

Test din forståelse af GroupBy med enkelte og flere nøgler fra denne lektion.

Besvar den i den interaktive lektion

Opsummering af lektionen

I denne lektion har du lært, hvordan du grupperer efter en enkelt kolonne og anvender almindelige aggregeringer, hvordan du grupperer efter flere kolonner for at lave opsummeringer på tværs af dimensioner, og forskellen mellem count() og size(), når der findes null-værdier. Dernæst undersøger vi den effektive metode agg() til at beregne flere forskellige statistikker i ét kald.

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 “GroupBy med én eller flere nøgler” gratis?

Ja — hele teksten til “GroupBy med én eller flere nøgler” 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 “GroupBy med én eller flere nøgler”?

Gruppér efter én eller flere kolonner med groupby(), og anvend aggregeringerne sum, mean, count og min/max. 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 “GroupBy med én eller flere nøgler”?

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