Behersk dataomstrukturering med Python Pandas pivot tables. En dybdegående gennemgang af syntaks, avancerede teknikker og praktiske eksempler til global dataanalyse.
Python Pandas Pivot Tables: En omfattende guide til omstrukturering af data
I en verden af dataanalyse er evnen til at opsummere, aggregere og omstrukturere data ikke bare en færdighed – det er en superkraft. Rådata ligner ofte, i deres oprindelige form, en omfattende, detaljeret fortegnelse. Den er rig på information, men vanskelig at fortolke. For at udtrække meningsfulde indsigter er vi nødt til at transformere denne fortegnelse til et kortfattet resume. Det er netop her, pivot tables udmærker sig, og for Python-programmører giver Pandas-biblioteket et kraftfuldt og fleksibelt værktøj: pivot_table().
Denne guide er designet til et globalt publikum af dataanalytikere, forskere og Python-entusiaster. Vi vil dykke dybt ned i mekanikken i Pandas pivot tables og bevæge os fra grundlæggende koncepter til avancerede teknikker. Uanset om du opsummerer salgstal fra forskellige kontinenter, analyserer klimadata på tværs af regioner eller sporer projektmetrics for et distribueret team, vil mestring af pivot tables fundamentalt ændre, hvordan du griber dataudforskning an.
Hvad er en pivot table egentlig?
Hvis du nogensinde har brugt regnearkssoftware som Microsoft Excel eller Google Sheets, er du sandsynligvis bekendt med konceptet pivot table. Det er en interaktiv tabel, der giver dig mulighed for at omorganisere og opsummere udvalgte kolonner og rækker af data fra et større datasæt for at opnå en ønsket rapport.
En pivot table gør to ting:
- Aggregering: Den beregner en opsummerende statistik (som en sum, et gennemsnit eller en optælling) for numeriske data grupperet efter en eller flere kategorier.
- Omstrukturering: Den transformerer data fra et 'langt' format til et 'bredt' format. I stedet for at have alle værdier i en enkelt kolonne, 'pivoterer' den unikke værdier fra en kolonne til nye kolonner i outputtet.
Pandas-funktionen pivot_table() bringer denne kraftfulde funktionalitet direkte ind i din Python-dataanalyseworkflow, hvilket giver mulighed for reproducerbar, scriptbar og skalerbar dataomstrukturering.
Opsætning af dit miljø og eksempeldata
Før vi begynder, skal du sikre dig, at du har Pandas-biblioteket installeret. Hvis ikke, kan du installere det ved hjælp af pip, Pythons pakkeinstallationsprogram:
pip install pandas
Lad os nu importere det i vores Python-script eller notesbog:
import pandas as pd
import numpy as np
Oprettelse af et globalt salgsdatasæt
For at gøre vores eksempler praktiske og globalt relevante, opretter vi et syntetisk datasæt, der repræsenterer salgsdata for en multinational e-handelsvirksomhed. Dette datasæt vil indeholde information om salg fra forskellige regioner, lande og produktkategorier.
# Opret en ordbog med data
data = {
'TransactionID': range(1, 21),
'Date': pd.to_datetime([
'2023-01-15', '2023-01-16', '2023-01-17', '2023-02-10', '2023-02-11',
'2023-02-12', '2023-03-05', '2023-03-06', '2023-03-07', '2023-01-20',
'2023-01-21', '2023-02-15', '2023-02-16', '2023-03-10', '2023-03-11',
'2023-01-18', '2023-02-20', '2023-03-22', '2023-01-25', '2023-02-28'
]),
'Region': [
'North America', 'Europe', 'Asia', 'North America', 'Europe', 'Asia', 'North America', 'Europe', 'Asia', 'Europe',
'Asia', 'North America', 'Europe', 'Asia', 'North America', 'Asia', 'Europe', 'North America', 'Europe', 'Asia'
],
'Country': [
'USA', 'Germany', 'Japan', 'Canada', 'France', 'India', 'USA', 'UK', 'China', 'Germany',
'Japan', 'USA', 'France', 'India', 'Canada', 'China', 'UK', 'USA', 'Germany', 'India'
],
'Product_Category': [
'Electronics', 'Apparel', 'Electronics', 'Books', 'Apparel', 'Electronics', 'Books', 'Electronics', 'Apparel',
'Apparel', 'Books', 'Electronics', 'Books', 'Apparel', 'Electronics', 'Books', 'Apparel', 'Books', 'Electronics', 'Electronics'
],
'Units_Sold': [10, 5, 8, 20, 7, 12, 15, 9, 25, 6, 30, 11, 18, 22, 14, 28, 4, 16, 13, 10],
'Unit_Price': [1200, 50, 900, 15, 60, 1100, 18, 950, 45, 55, 12, 1300, 20, 40, 1250, 14, 65, 16, 1150, 1050]
}
# Opret DataFrame
df = pd.DataFrame(data)
# Beregn omsætning
df['Revenue'] = df['Units_Sold'] * df['Unit_Price']
# Vis de første par rækker i DataFrame
print(df.head())
Dette datasæt giver os et solidt grundlag med en blanding af kategoriske data (Region, Country, Product_Category), numeriske data (Units_Sold, Revenue) og tidsseriedata (Date).
Anatomien af pivot_table()
Pandas-funktionen pivot_table() er utrolig alsidig. Lad os nedbryde dens vigtigste parametre:
pandas.pivot_table(data, values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, margins_name='All')
- data: Den DataFrame, du vil pivotere.
- values: Den eller de kolonner, der indeholder de data, der skal aggregeres. Hvis det ikke er angivet, bruges alle resterende numeriske kolonner.
- index: Den eller de kolonner, hvis unikke værdier vil danne rækkerne i den nye pivot table. Dette kaldes undertiden 'grupperingsnøglen'.
- columns: Den eller de kolonner, hvis unikke værdier vil blive 'pivoteret' for at danne kolonnerne i den nye tabel.
- aggfunc: Den aggregeringsfunktion, der skal anvendes på 'værdierne'. Dette kan være en streng som 'sum', 'mean', 'count', 'min', 'max' eller en funktion som
np.sum. Du kan også sende en liste over funktioner eller en ordbog for at anvende forskellige funktioner på forskellige kolonner. Standard er 'mean'. - fill_value: En værdi, der skal erstatte eventuelle manglende resultater (NaN'er) i pivot table.
- margins: En boolesk værdi. Hvis den er sat til
True, tilføjer den subtotaler for rækker og kolonner (også kendt som en total). - margins_name: Navnet på den række/kolonne, der indeholder totalerne, når
margins=True. Standard er 'All'.
Din første pivot table: Et simpelt eksempel
Lad os starte med et almindeligt forretningsspørgsmål: "Hvad er den samlede omsætning genereret af hver produktkategori?"
For at besvare dette skal vi:
- Bruge
Product_Categoryfor rækkerne (index). - Aggregere kolonnen
Revenue(values). - Bruge summen som vores aggregeringsfunktion (aggfunc).
# Simpel pivot table for at se den samlede omsætning efter produktkategori
category_revenue = pd.pivot_table(df,
values='Revenue',
index='Product_Category',
aggfunc='sum')
print(category_revenue)
Output:
Revenue
Product_Category
Apparel 1645
Books 1184
Electronics 56850
Med det samme har vi et klart, kortfattet resume. Den rå transaktionslog med 20 rækker er blevet omformet til en tabel med 3 rækker, der direkte besvarer vores spørgsmål. Dette er den grundlæggende styrke ved en pivot table.
Tilføjelse af en kolonne dimension
Lad os nu udvide dette. Hvad hvis vi vil se den samlede omsætning efter produktkategori, men også opdelt efter region? Det er her, parameteren columns kommer i spil.
# Pivot table med indeks og kolonner
revenue_by_category_region = pd.pivot_table(df,
values='Revenue',
index='Product_Category',
columns='Region',
aggfunc='sum')
print(revenue_by_category_region)
Output:
Region Asia Europe North America Product_Category Apparel 1125.0 625.0 NaN Books 336.0 360.0 488.0 Electronics 13200.0 14550.0 29100.0
Dette output er meget rigere. Vi har pivoteret de unikke værdier fra kolonnen 'Region' ('Asia', 'Europe', 'North America') til nye kolonner. Vi kan nu nemt sammenligne, hvordan forskellige produktkategorier klarer sig på tværs af regioner. Vi ser også en NaN-værdi (Not a Number). Dette indikerer, at der ikke blev registreret noget 'Apparel'-salg for 'North America' i vores datasæt. Dette er værdifuld information i sig selv!
Avancerede pivoteringsteknikker
Det grundlæggende er kraftfuldt, men den sande fleksibilitet af pivot_table() afsløres i dens avancerede funktioner.
Håndtering af manglende værdier med fill_value
NaN i vores tidligere tabel er korrekt, men til rapportering eller yderligere beregninger kan det være at foretrække at vise det som nul. Parameteren fill_value gør dette nemt.
# Brug af fill_value til at erstatte NaN med 0
revenue_by_category_region_filled = pd.pivot_table(df,
values='Revenue',
index='Product_Category',
columns='Region',
aggfunc='sum',
fill_value=0)
print(revenue_by_category_region_filled)
Output:
Region Asia Europe North America Product_Category Apparel 1125 625 0 Books 336 360 488 Electronics 13200 14550 29100
Tabellen er nu renere og lettere at læse, især for et ikke-teknisk publikum.
Arbejde med flere indekser (hierarkisk indeksering)
Hvad hvis du har brug for at gruppere efter mere end én kategori på rækkerne? Lad os for eksempel opdele salget efter Region og derefter efter Country inden for hver region. Vi kan sende en liste over kolonner til parameteren index.
# Pivot table på flere niveauer ved hjælp af en liste til indekset
multi_index_pivot = pd.pivot_table(df,
values='Revenue',
index=['Region', 'Country'],
aggfunc='sum',
fill_value=0)
print(multi_index_pivot)
Output:
Revenue
Region Country
Asia China 488
India 1760
Japan 10860
Europe France 1020
Germany 14440
UK 1115
North America Canada 17800
USA 12058
Pandas har automatisk oprettet et MultiIndex på rækkerne. Denne hierarkiske struktur er fantastisk til at dykke ned i dine data og se indlejrede relationer. Du kan anvende den samme logik på parameteren columns for at oprette hierarkiske kolonner.
Brug af flere aggregeringsfunktioner
Nogle gange er en opsummerende statistik ikke nok. Du vil måske se både den samlede omsætning (sum) og den gennemsnitlige transaktionsstørrelse (gennemsnit) for hver gruppe. Du kan sende en liste over funktioner til aggfunc.
# Brug af flere aggregeringsfunktioner
multi_agg_pivot = pd.pivot_table(df,
values='Revenue',
index='Region',
aggfunc=['sum', 'mean', 'count'])
print(multi_agg_pivot)
Output:
sum mean count
Revenue Revenue Revenue
Region
Asia 13108.000000 2184.666667 6
Europe 16575.000000 2762.500000 6
North America 29858.000000 4976.333333 6
Denne enkelt kommando giver os et omfattende resume: den samlede omsætning, den gennemsnitlige omsætning pr. transaktion og antallet af transaktioner for hver region. Læg mærke til, hvordan Pandas opretter hierarkiske kolonner for at holde outputtet organiseret.
Anvendelse af forskellige funktioner på forskellige værdier
Du kan blive endnu mere granulær. Forestil dig, at du vil se summen af Revenue, men gennemsnittet af Units_Sold. Du kan sende en ordbog til aggfunc, hvor nøglerne er kolonnenavnene ('værdier'), og værdierne er de ønskede aggregeringsfunktioner.
# Forskellige aggregeringer for forskellige værdier
dict_agg_pivot = pd.pivot_table(df,
index='Region',
values=['Revenue', 'Units_Sold'],
aggfunc={
'Revenue': 'sum',
'Units_Sold': 'mean'
},
fill_value=0)
print(dict_agg_pivot)
Output:
Revenue Units_Sold
Region
Asia 13108 17.833333
Europe 16575 8.166667
North America 29858 14.333333
Dette kontrolniveau er det, der gør pivot_table() til et førende værktøj til sofistikeret dataanalyse.
Beregning af totaler med margins
Til rapporteringsformål er det ofte vigtigt at have række- og kolonnetotaler. Argumentet margins=True giver dette uden ekstra indsats.
# Tilføjelse af totaler med margins=True
revenue_with_margins = pd.pivot_table(df,
values='Revenue',
index='Product_Category',
columns='Region',
aggfunc='sum',
fill_value=0,
margins=True,
margins_name='Grand Total') # Brugerdefineret navn til totaler
print(revenue_with_margins)
Output:
Region Asia Europe North America Grand Total Product_Category Apparel 1125 625 0 1750 Books 336 360 488 1184 Electronics 13200 14550 29100 56850 Grand Total 14661 15535 29588 59784
Pandas beregner automatisk summen for hver række (den samlede omsætning pr. produktkategori på tværs af alle regioner) og hver kolonne (den samlede omsætning pr. region på tværs af alle kategorier) plus en total for alle data i nederste højre hjørne.
Praktisk anvendelse: Tidsbaseret analyse
Pivot tables er ikke begrænset til statiske kategorier. De er utroligt nyttige til at analysere tidsseriedata. Lad os finde den samlede omsætning for hver måned.
Først skal vi udtrække måneden fra vores 'Date'-kolonne. Vi kan bruge .dt-accessoren i Pandas til dette.
# Udtræk måneden fra kolonnen Date
df['Month'] = df['Date'].dt.month_name()
# Pivot for at se månedlig omsætning efter produktkategori
monthly_revenue = pd.pivot_table(df,
values='Revenue',
index='Month',
columns='Product_Category',
aggfunc='sum',
fill_value=0)
# Valgfrit: Bestil månederne korrekt
month_order = ['January', 'February', 'March']
monthly_revenue = monthly_revenue.reindex(month_order)
print(monthly_revenue)
Output:
Product_Category Apparel Books Electronics Month January 250 360 23100 February 795 794 24250 March 705 30 9500
Denne tabel giver os et klart overblik over salgsresultaterne for hver kategori over tid, hvilket giver os mulighed for nemt at se trends, sæsonudsving eller anomalier.
pivot_table() vs. groupby(): Hvad er forskellen?
Dette er et almindeligt spørgsmål for dem, der lærer Pandas. De to funktioner er tæt beslægtede, og faktisk er pivot_table() bygget oven på groupby().
groupby()er en mere generel og grundlæggende operation. Den grupperer data baseret på nogle kriterier og lader dig derefter anvende en aggregeringsfunktion. Resultatet er typisk en Pandas Series eller DataFrame med et hierarkisk indeks, men det forbliver i et 'langt' format.pivot_table()er et specialiseret værktøj, der foretager en group-by og derefter omformer dataene. Dens primære formål er at transformere dataene fra et langt format til et bredt format, hvilket ofte er mere menneskeligt læsbart.
Lad os vende tilbage til vores første eksempel ved hjælp af groupby():
# Samme resultat som vores første pivot table, men ved hjælp af groupby
category_revenue_groupby = df.groupby('Product_Category')['Revenue'].sum()
print(category_revenue_groupby)
Resultatet er en Pandas Series, der funktionelt svarer til DataFrame fra vores første pivot table. Men når du introducerer en anden grupperingsnøgle (som 'Region'), bliver forskellen tydelig.
# Gruppering efter to kolonner
groupby_multi = df.groupby(['Product_Category', 'Region'])['Revenue'].sum()
print(groupby_multi)
Output (en Series med et MultiIndex):
Product_Category Region
Apparel Asia 1125
Europe 625
Books Asia 336
Europe 360
North America 488
Electronics Asia 13200
Europe 14550
North America 29100
Name: Revenue, dtype: int64
For at få det samme 'brede' format som pivot_table(index='Product_Category', columns='Region'), skal du bruge groupby() efterfulgt af unstack():
# Replikering af en pivot table med groupby().unstack()
groupby_unstack = df.groupby(['Product_Category', 'Region'])['Revenue'].sum().unstack(fill_value=0)
print(groupby_unstack)
Dette producerer det nøjagtige samme output som vores pivot table med kolonner. Så du kan tænke på pivot_table() som en praktisk genvej til det almindelige groupby().aggregate().unstack()-workflow.
Hvornår skal man bruge hvilken?
- Brug
pivot_table(), når du vil have et menneskeligt læsbart output i bredt format, især til rapportering eller oprettelse af krydstabeller. - Brug
groupby(), når du har brug for mere fleksibilitet, udfører mellemliggende beregninger i en databehandlingspipeline, eller når det omformede, brede format ikke er dit endelige mål.
Ydeevne og bedste praksis
Selvom pivot_table() er kraftfuld, er det vigtigt at bruge den effektivt, især med store datasæt.
- Filtrer først, pivot senere: Hvis du kun har brug for at analysere et undersæt af dine data (f.eks. salg fra det seneste år), skal du filtrere DataFrame før du anvender pivot table. Dette reducerer mængden af data, som funktionen skal behandle.
- Brug kategoriske typer: For kolonner, som du ofte bruger som indekser eller kolonner i dine pivot tables (som 'Region' eller 'Product_Category'), skal du konvertere dem til typen 'category' i Pandas. Dette kan reducere hukommelsesforbruget betydeligt og fremskynde grupperingsoperationer.
df['Region'] = df['Region'].astype('category') - Hold det læseligt: Undgå at oprette pivot tables med for mange indekser og kolonner. Selvom det er muligt, kan en pivot table, der er hundredvis af kolonner bred og tusindvis af rækker lang, blive lige så ulæselig som de originale rådata. Brug den til at oprette målrettede resuméer.
- Forstå aggregeringen: Vær opmærksom på dit valg af
aggfunc. Det giver ikke mening at bruge 'sum' på priser, mens 'mean' måske er mere passende. Sørg altid for, at din aggregering stemmer overens med det spørgsmål, du forsøger at besvare.
Konklusion: Dit værktøj til indsigtsfulde resuméer
Pandas-funktionen pivot_table() er et uundværligt værktøj i enhver dataanalytikers værktøjskasse. Det giver en deklarativ, udtryksfuld og kraftfuld måde at flytte fra rodede, detaljerede data til rene, indsigtsfulde resuméer. Ved at forstå og mestre dens kernekomponenter – values, index, columns og aggfunc – og udnytte dens avancerede funktioner som indeksering på flere niveauer, brugerdefinerede aggregeringer og margener, kan du omforme dine data til at besvare komplekse forretningsspørgsmål med blot et par linjer Python-kode.
Næste gang du står over for et stort datasæt, skal du modstå trangen til at rulle gennem endeløse rækker. Tænk i stedet over de spørgsmål, du skal besvare, og hvordan en pivot table kan omforme dine data for at afsløre de historier, der er skjult indeni. God pivotering!