Groeperen en aggregeren met pandas

Een groep bevat rijen met dezelfde sleutelwaarde. Als de sleutel region is, hoort elke bestelling uit North bij één groep, ook als die bestellingen verspreid door de tabel staan. Splitsen, toepassen en combineren betekent dat je deze groepen vaststelt, binnen elke groep dezelfde bewerking uitvoert en de resultaten samenvoegt.

Begin met de bestelgegevens

De voorbeelden gebruiken pandas 3 met import pandas as pd en NumPy als np. Maak de tabel met drankbestellingen:

sales = pd.DataFrame({
    "region": ["North", "South", "North", "East", "South", "East", "North", "South"],
    "product": ["tea", "tea", "coffee", "coffee", "coffee", "tea", "tea", "coffee"],
    "units": [10, 4, 7, 5, 9, 3, 6, 8],
    "revenue": [30, 12, 28, 20, 36, 9, 18, 32]
})

De omzet heeft hier geen munteenheid. Thee heeft een omzet van 3 per stuk en koffie van 4 per stuk. De standaardrijlabels lopen van 0 tot en met 7.

Van een GroupBy-object naar een antwoord

sales.groupby("region") geeft een GroupBy-object terug, dat de groeperingsinformatie bevat. Het is geen samenvattingstabel. Kies een kolom en roep een methode aan om een resultaat te berekenen:

g = sales.groupby("region")
totals = g["units"].sum()

East bevat rijen 3 en 5, dus het totaal is 5 + 3 = 8. North bevat rijen 0, 2 en 6, wat 10 + 7 + 6 = 23 geeft. South bevat rijen 1, 4 en 7, wat 4 + 9 + 8 = 21 geeft. pandas combineert deze tot een Series met de naam units, met de regionamen als index. De totalen tellen op tot 52, het oorspronkelijke kolomtotaal.

De standaardvolgorde van de uitvoer is East, North, South omdat groepssleutels worden gesorteerd. sales.groupby("region", sort=False) gebruikt de volgorde van eerste voorkomen: North, South, East. Geen van beide keuzes sorteert de waarnemingen binnen een groep of wijzigt sales.

Inspecteren en selecteren

g.ngroups is 3. g.size() rapporteert 2, 3 en 3 rijen voor East, North en South. g.groups koppelt sleutels aan rijlabels en g.get_group("North") geeft de drie rijen van North terug. Je kunt één groep tegelijk inspecteren:

for name, group in g:
    print(name, group["units"].tolist())

Het doorlopen van groepen helpt bij inspectie of export. Voor een statistiek voorkomt een ingebouwde groepsmethode dat je zelf een Python-lus moet schrijven en de resultaten moet verzamelen.

Als je g["units"] selecteert, krijg je een SeriesGroupBy; de som daarvan is een Series. Als je g[["units"]] selecteert, krijg je een DataFrameGroupBy; de som daarvan is een DataFrame met één kolom. Selecteer g[["units", "revenue"]] wanneer je beide numerieke kolommen nodig hebt.

Kies de vorm van de uitvoer

Een aggregatie zoals sum geeft één samenvattende waarde per groep en kolom. Een transformatie geeft een waarde voor elke invoerrij, zoals het aandeel van elke bestelling in het totaal van de regio. Een filtering behoudt geselecteerde rijen of groepen. De algemene methode apply verwerkt minder regelmatige groepsresultaten.

Filteren met sales[sales["region"] == "North"] haalt de rijen van één regio op. Door te groeperen kun je elke regio met dezelfde bewerking verwerken.

Sleutels kunnen uit kolommen, berekeningen of de rijindex komen. De belangrijke vraag is welke waarde elke rij als sleutel krijgt. Rijen met dezelfde combinatie van sleutels worden samen verwerkt.

Gebruik meerdere kolommen

Geef een lijst met kolomnamen door om op combinaties te groeperen:

pair_totals = sales.groupby(["region", "product"])["units"].sum()

Het resultaat heeft een MultiIndex met twee niveaus. De vermeldingen zijn East–coffee 5, East–tea 3, North–coffee 7, North–tea 16, South–coffee 17 en South–tea 4. North–tea combineert de twee theebestellingen met 10 en 6 eenheden. Als je alleen op regio zou groeperen, zou de koffiebestelling uit North ook meetellen.

pair_totals.unstack() verplaatst het binnenste niveau product naar de kolommen. De rijen zijn regio's en de kolommen zijn coffee en tea. Een ontbrekende combinatie wordt NaN; unstack(fill_value=0) kan die als nul weergeven wanneer die afwezigheid betekent dat er geen eenheden zijn.

Gebruik een lijst voor meerdere kolomnamen. groupby(("region", "product")) behandelt de tuple als één kolomlabel en zoekt een kolom met die tuple als naam.

Leid een sleutel af uit waarden

Een booleaanse Series kan bestellingen op grootte verdelen zonder een kolom toe te voegen:

sales.groupby(sales["units"] >= 7)["revenue"].sum()

De groep True bevat aantallen 10, 7, 9 en 8; de omzet is 126. De groep False bevat de andere vier bestellingen en heeft een omzet van 59. De toets maakt groepslabels; die verwijdert de kleinere bestellingen niet.

Een waardetoewijzing kan regio's in zones samenvoegen:

zones = {"North": "Zone 1", "East": "Zone 1", "South": "Zone 2"}
zone_key = sales["region"].map(zones)
sales.groupby(zone_key)["units"].sum()

Zone 1 krijgt de 23 eenheden van North en de 8 van East, samen 31. Zone 2 krijgt de 21 van South. Wijs eerst de kolomwaarden toe: een dictionary die je rechtstreeks aan groupby doorgeeft, wijst indexlabels toe, geen regiowaarden.

Groepeer met de index

Een functie die je als sleutel doorgeeft, ontvangt ook indexlabels. Voor een voorraad met productcodes als index kan de eerste letter de productfamilie aanduiden:

stock = pd.Series([12, 8, 5, 9, 4],
                  index=["T01", "T02", "C01", "C02", "C03"])
stock.groupby(lambda code: code[0]).sum()

Het totaal van C is 18 en het totaal van T is 20. Bij een bestaande MultiIndex groepeert pair_totals.groupby(level="product").sum() opnieuw op het benoemde indexniveau, met coffee 29 en tea 23 als resultaat.

Controleer de uitlijning vóór het groeperen

Een NumPy-array als sleutel levert labels op positie en moet één element per rij hebben. Een Series als sleutel wordt op indexlabel uitgelijnd. Als de labels alleen rijen 0 en 1 omvatten, krijgen de andere rijen ontbrekende sleutels en worden ze bij het standaardgroeperingsgedrag weggelaten. Een Series met een gewijzigde volgorde kan nog steeds correct groeperen wanneer de labels overeenkomen; als je de Series vervangt door de waarden, verandert de bewerking in koppeling op positie.

Een gegroepeerde berekening heeft twee onderdelen die je moet inspecteren: de waarden en de labels eromheen. Met pandas kun je kiezen waar sleutels verschijnen, hoe groepen worden geordend en of ontbrekende of ongebruikte sleutels in het rapport verschijnen.

Behoud sleutels in de index of in kolommen

Standaard worden sleutels de index van het resultaat:

sales.groupby("region")["revenue"].sum()

Deze Series heeft East 29, North 76 en South 80. Gebruik voor een plat rapport:

report = sales.groupby("region", as_index=False)["revenue"].sum()

report heeft gewone kolommen region en revenue en een nieuwe index met gehele getallen. Als je .reset_index() op de oorspronkelijke Series aanroept, krijg je dezelfde indeling. Bij meerdere sleutels zet die methode elk MultiIndex-niveau om in een kolom. unstack() heeft een ander doel: die methode verplaatst een indexniveau naar de kolommen van een raster.

Een Series als resultaat behoudt de naam van de geselecteerde kolom. Gebruik .rename("total_revenue") voor een duidelijkere Series-naam of .to_frame("total_revenue") voor een DataFrame met één kolom. Aggregatie met benoemde uitvoerkolommen kan tijdens de berekening beschrijvende kolomnamen opleveren.

Sorteer sleutels of rangschik waarden

sort=True sorteert de sleutels, dus de alfabetische regiovolgorde blijft East, North, South, hoewel South de grootste omzet heeft. Sorteer het resultaat om totalen te rangschikken:

sales.groupby("region")["revenue"].sum().sort_values(ascending=False)

De uitvoer is South 80, North 76, East 29. Gebruik sort=False om de volgorde van eerste voorkomen van de sleutels te behouden en onnodig sorteren van sleutels in een grote dataset te vermijden. Dit sorteert de rijen binnen groepen niet.

Houd rekening met ontbrekende sleutels

De standaardinstelling dropna=True sluit rijen met een ontbrekende groepssleutel uit. Voeg een bestelling met 5 eenheden maar zonder regio toe: de volledige kolom met aantallen heeft nu een totaal van 57, terwijl de groepstotalen nog steeds optellen tot 52. De weggelaten rij heeft geen benoemde regio.

sales.groupby("region", dropna=False)["units"].sum()

Op de uitgebreide tabel voegt dit een groep voor ontbrekende sleutels toe met een totaal van 5. Ontbrekende sleutels bepalen of een rij in een groep terechtkomt; ontbrekende waarden bepalen wat een aggregatie binnen een groep telt of berekent. Dat zijn afzonderlijke beslissingen.

Toon ongebruikte categorieën wanneer dat nodig is

Een categorische kolom region kan East, North, South en West bevatten, ook als er geen bestellingen uit West zijn. Sinds pandas 3.0 is observed=True de standaardinstelling en worden alleen categorieën getoond die in de gegevens voorkomen. Met observed=False verschijnt West ook: de som en het aantal zijn 0, terwijl het gemiddelde NaN is.

Kies deze instelling expliciet wanneer een rapport telkens dezelfde categorieën moet tonen. Een ongebruikte categorie en een ontbrekende sleutel zijn verschillend: observed verwerkt vastgelegde categorische waarden; dropna verwerkt ontbrekende sleutelwaarden.

as_index en sort bepalen de vorm van aggregatieresultaten. Transformaties en filterbewerkingen zoals head, nth en filter behouden de indexen van de invoerrijen. Bij een rapport met sommen kun je de som van de groepstotalen vergelijken met het oorspronkelijke kolomtotaal om uitgesloten sleutels of een eerder filter op te sporen.

Een aggregatie brengt elke groep terug tot een samenvattende waarde voor elke geselecteerde kolom. Kies de maat op basis van de vraag: een aantal rijen, een totaal, een gemiddelde of een spreidingsmaat beschrijft steeds een ander kenmerk van de gegevens.

Kies de statistiek

Veelgebruikte methoden zijn sum, prod, mean, median, min, max, count, size, nunique, std, var, first, last en quantile. Zowel een rechtstreekse aanroep zoals .mean() als .agg("mean") vraagt een groepsgemiddelde van pandas op. nunique() telt standaard unieke aanwezige waarden.

sales.groupby("product")["revenue"].agg(["mean", "median"])

De koffieomzetten zijn 28, 20, 36 en 32. Hun gemiddelde is 29; na sortering zijn de middelste waarden 28 en 32, dus de mediaan is 30. De theeomzetten zijn 30, 12, 9 en 18. Hun gemiddelde is 17,25 en de mediaan 15. De grote theebestelling van 30 trekt het gemiddelde boven de mediaan.

Tel rijen of vastgelegde waarden

size() telt rijen. count() telt aanwezige waarden in elke geselecteerde kolom. Als aantallen ontbreken voor rij 2 van North en rij 5 van East, blijven de groepsgroottes East 2, North 3, South 3, maar zijn de aantallen aanwezige waarden voor units 1, 2 en 3. Verschillende kolommen kunnen binnen dezelfde groep dus verschillende aantallen hebben.

De meeste numerieke reducties slaan ontbrekende waarden over. De resterende aantallen 10 en 6 van North hebben een gemiddelde van 8, berekend met twee vastgelegde waarden. Als je hun som door alle drie de rijen zou delen, krijg je het verkeerde gemiddelde. Een groep waarin alles ontbreekt, heeft standaard som 0 maar gemiddelde NaN. Sinds pandas 3.0 accepteren reducties zoals sum en mean skipna=False, zodat ze een ontbrekend resultaat teruggeven wanneer een groep een ontbrekende waarde bevat.

Interpreteer spreiding en gecombineerde samenvattingen

std() en var() gebruiken steekproefstatistieken, met ddof=1: de deler is één minder dan het aantal vastgelegde waarnemingen. De waarden 1 en 3 hebben een steekproefstandaardafwijking van ongeveer 1,414. Een groep met alleen de waarde 5 heeft een steekproefstandaardafwijking van NaN.

describe() bundelt aantal, gemiddelde, standaardafwijking, minimum, kwartielen en maximum. Voor de omzetten 12, 36 en 32 van South is het gemiddelde ongeveer 26,67 en de mediaan 32. De kolom 50% is de mediaan.

Bepaal de kolommen en rijvolgorde

Door numerieke kolommen te selecteren, voorkom je dat je tekst probeert te middelen:

sales.groupby("region")[["units", "revenue"]].mean()

Een .mean() op de hele tabel mislukt door de tekstkolom product; numeric_only=True is een andere oplossing. Een .sum() op de hele tabel kan tekst samenvoegen, wat voor East "coffeetea" oplevert, geen bruikbare productsamenvatting.

first() en last() kiezen per kolom de eerste en laatste aanwezige waarde in de huidige rijvolgorde. Ze kunnen waarden uit verschillende rijen nemen. Gebruik nth(0) om de werkelijke eerste rij op te halen, inclusief ontbrekende waarden; sorteer eerst wanneer “eerste” de vroegste betekent.

Ongelijke groepsgroottes beïnvloeden ook de interpretatie. Het gemiddelde van de regionale omzetgemiddelden is ongeveer 22,17, maar het totale gemiddelde is 185 gedeeld door 8, oftewel 23,125. Als je elk regiogemiddelde even zwaar laat wegen, krijgt de groep East met twee rijen evenveel invloed als elke groep met drie rijen.

Een bruikbaar rapport heeft vaak meerdere maten uit dezelfde groepen nodig. Met agg, een afkorting van aggregate, kun je die maten samen opvragen en bepalen hoe hun uitvoerkolommen worden genoemd.

Geef één kolom meerdere functies

sales.groupby("region")["revenue"].agg(["sum", "mean", "max"])

East geeft 29; 14,5 en 20. North geeft 76; ongeveer 25,33 en 30. South geeft 80; ongeveer 26,67 en 36. Elke rij vertegenwoordigt één regio, terwijl de functienamen kolomnamen worden.

Een lijst die op meerdere waardekolommen wordt toegepast, levert hiërarchische kolommen op:

result = sales.groupby("region")[["units", "revenue"]].agg(["sum", "mean"])

De vier kolomlabels zijn de paren ("units", "sum"), ("units", "mean"), ("revenue", "sum") en ("revenue", "mean"). Het eerste niveau duidt de invoerkolom aan; het tweede duidt de berekening aan. Dit zijn kolomniveaus, los van eventuele groeperingsniveaus in de rijindex.

Wijs functies toe aan specifieke kolommen

Een dictionary selecteert de invoerkolommen en hun functies:

sales.groupby("region").agg({
    "units": "sum",
    "revenue": ["mean", "max"]
})

Dit vraagt het totale aantal eenheden op, maar de gemiddelde en maximale omzet. Kolommen die niet in de dictionary staan, verschijnen niet. Voor verschillende maten kunnen verschillende functies zinvol zijn; een hoeveelheid optellen en een frequentie middelen zijn geen uitwisselbare keuzes.

Benoem de uitvoer rechtstreeks

Aggregatie met benoemde uitvoerkolommen geeft elk resultaat een expliciete naam:

report = sales.groupby("region").agg(
    total_units=("units", "sum"),
    avg_revenue=("revenue", "mean")
)

Elk sleutelwoord benoemt een uitvoerkolom. De bijbehorende tuple bevat de bronkolom en de functie. total_units is 8, 23 en 21; avg_revenue is 14,5; ongeveer 25,33 en ongeveer 26,67. pd.NamedAgg(column="units", aggfunc="sum") is een alternatieve hulpfunctie om de bron en functie op te geven.

Gebruik na het selecteren van één Series functiesleutelwoorden zonder tuples met bronkolommen:

sales.groupby("region")["units"].agg(total="sum", most="max")

De totalen zijn 8, 23 en 21 en de maxima 5, 10 en 9. Een dictionary zoals {"total": "sum"} op deze geselecteerde Series geeft een SpecificationError; dit is niet de dictionaryvorm die op een DataFrame wordt gebruikt.

Een lijst met benoemde paren werkt ook op een geselecteerde kolom: .agg([("average", "mean"), ("spread", "std")]). Als je al MultiIndex-kolommen hebt die uit tekenreekslabels zijn gemaakt, maakt result.columns = ["_".join(col) for col in result.columns] die plat en ontstaan namen zoals units_sum.

Kies de functie bewust

Namen als tekenreeks gebruiken de ingebouwde groepsberekeningen van pandas. Sinds pandas 3.0 wordt een NumPy- of Python-functie die aan agg wordt doorgegeven, aangeroepen zoals opgegeven. Voor de omzetten 20 en 9 van East gebruikt "std" de steekproefdeler en geeft ongeveer 7,78, terwijl np.std de populatiedeler gebruikt en 5,5 geeft.

Een zelfgeschreven aggregatie drukt een samenvatting uit die een ingebouwde naam niet biedt. De functie ontvangt de waarden van één groep als Series en moet die terugbrengen tot één bruikbaar resultaat.

Schrijf de functie en geef die door

def value_range(s):
    return s.max() - s.min()

sales.groupby("region")["revenue"].agg(value_range)

De spreidingsbreedte van East is 20 min 9, oftewel 11. Die van North is 30 min 18, oftewel 12. Die van South is 36 min 12, oftewel 24. Geef value_range zelf door; value_range() zou de functie onmiddellijk aanroepen zonder de groeps-Series die nodig is.

Een lambda is geschikt voor een korte berekening:

sales.groupby("region")["revenue"].agg(
    share_20=lambda s: (s >= 20).mean()
)

Booleaanse waarden werken als 1 voor True en 0 voor False, dus hun gemiddelde is het aandeel dat aan de voorwaarde voldoet. East heeft één geschikte bestelling van de twee, oftewel 0,5. North en South hebben er elk twee van de drie, oftewel ongeveer 0,667. Door het resultaat te benoemen, maak je de betekenis duidelijker dan met een automatisch lambdalabel. Lijsten met meerdere functies geven lambda's de labels <lambda_0>, <lambda_1> enzovoort; een enkele lambda in een lijst krijgt het label <lambda>.

Bereid kolommen voor om snelle reducties te gebruiken

Een Python-functie wordt eenmaal voor elke groep uitgevoerd. Bij veel groepen zijn ingebouwde reducties meestal sneller. Je kunt de berekening van het aandeel herschrijven door eerst de booleaanse kolom te maken:

sales.assign(big=sales["revenue"] >= 20).groupby("region")["big"].mean()

De vergelijking wordt op de volledige kolom uitgevoerd, waarna pandas de groepsgemiddelden berekent.

Combineer twee kolommen via hun totalen

Een agg-functie verwerkt steeds één kolom. Voor de gemiddelde omzet per eenheid vat je eerst beide kolommen samen:

totals = sales.groupby("region")[["units", "revenue"]].sum()
avg_price = totals["revenue"] / totals["units"]

De resultaten zijn East 29/8 = 3,625, North 76/23 ≈ 3,304 en South 80/21 ≈ 3,810. Elke eenheid krijgt hetzelfde gewicht. Als je in plaats daarvan de bestelprijzen middelt, krijg je East 3,5, North ongeveer 3,333 en South ongeveer 3,667, omdat elke bestelling dan even zwaar weegt, ongeacht de omvang. Bepaal voordat je de formule kiest of de vraag over een typische eenheid of een typische bestelling gaat.

Houd de retourwaarde en ontbrekende gegevens duidelijk

Een functie die de twee kleinste waarden teruggeeft, maakt via agg geen twee gewone samenvattingsrijen; in pandas 3.1 slaat lambda s: s.nsmallest(2) een lijstachtig object in elke cel op. Gebruik apply wanneer een groep meerdere waarden of rijen moet teruggeven.

De ingevoerde Series bevat nog steeds ontbrekende waarden. s.mean() slaat die over, terwijl len(s) de rijen ervan telt. Als aantallen op rijen 2 en 5 ontbreken, geeft .agg(len) groepsgroottes 2, 3 en 3, niet de aantallen aanwezige waarden 1, 2 en 3.

Extra argumenten kunnen na de functie volgen: .agg("quantile", 0.9) geeft het 90e percentiel van elke groep. De omzetten 9 en 20 van East geven door lineaire interpolatie 18,9. De rechtstreekse aanroep .quantile(0.9) is voor deze ene bewerking gemakkelijker te lezen.

Een samenvatting heeft één rij per groep, maar soms heeft elke oorspronkelijke rij de statistiek van de eigen groep nodig. transform geeft een resultaat terug met de oorspronkelijke lengte en index, waardoor het geschikt is als nieuwe kolom.

Verspreid een totaal naar de juiste rijen

g = sales.groupby("region")["revenue"]
regional_total = g.transform("sum")
sales["share"] = sales["revenue"] / regional_total

De Series met totalen bevat 76, 80, 76, 29, 80, 29, 76 en 80 in de oorspronkelijke rijvolgorde. Het totaal van North, 76, wordt alleen op rijen van North herhaald. Rij 0 krijgt een aandeel van 30/76 ≈ 0,395; rij 3 van East krijgt 20/29 ≈ 0,690. Binnen elke regio tellen deze omzetaandelen op tot 1.

Als je g.sum() rechtstreeks zou toekennen, zouden de waarden niet met de rijen overeenkomen. De index bevat regionamen, terwijl sales rijlabels 0 tot en met 7 heeft. pandas lijnt uit op indexlabel, dus de toegekende kolom krijgt ontbrekende waarden. Gebruik transform of voeg een samenvatting expliciet samen op region.

Vergelijk een rij met de eigen groep

Door het groepsgemiddelde af te trekken, krijg je een afwijking van het groepsgemiddelde:

x = sales["revenue"]
deviation = x - g.transform("mean")

Rij 0 van North ligt ongeveer 4,67 boven het groepsgemiddelde van ongeveer 25,33. Rij 1 van South ligt ongeveer 14,67 onder het groepsgemiddelde van ongeveer 26,67. Elke vergelijking gebruikt de eigen regio van de rij, niet het gemiddelde van de hele tabel.

Een z-score deelt die afwijking door de standaardafwijking van de groep:

z = (x - g.transform("mean")) / g.transform("std")

Voor rij 0 van North is de steekproefstandaardafwijking ongeveer 6,43 en de z-score ongeveer 0,73. Rij 3 van East heeft een z-score van ongeveer 0,71 en ligt dus boven het gemiddelde van de regio, hoewel de omzet van 20 onder het totale gemiddelde van 23,125 ligt. Bij een standaardafwijking van nul of te weinig vastgelegde waarden is een gestandaardiseerde score niet gedefinieerd.

Vul een ontbrekende waarde aan vanuit de eigen groep

Stel dat de aantallen op rijen 2 en 5 ontbreken. De vastgelegde aantallen van North zijn 10 en 6, met gemiddelde 8; de enige vastgelegde waarde voor het aantal van East is 5.

with_missing = sales.copy()
with_missing.loc[[2, 5], "units"] = np.nan
means = with_missing.groupby("region")["units"].transform("mean")
filled_units = with_missing["units"].fillna(means)

In die gewijzigde tabel krijgt rij 2 de waarde 8 en rij 5 de waarde 5. Bestaande waarden blijven ongewijzigd. Wanneer groepen verschillende typische waarden hebben, kunnen hun eigen gemiddelden realistischere vervangingen bieden dan één totaal gemiddelde. Een groep zonder vastgelegde waarden heeft nog steeds geen gemiddelde om te gebruiken.

Begrijp een eigen transformatie

Een functie die je aan transform doorgeeft, kan een scalaire waarde teruggeven, die pandas binnen de groep herhaalt, of een Series met de rijen van de groep als index. Zo berekent g.transform(lambda s: s - s.mean()) dezelfde afwijkingen als het ingebouwde gemiddelde gevolgd door aftrekken, maar roept het voor elke groep Python aan.

Een teruggegeven kortere Series wordt op label gekoppeld. g.transform(lambda s: s.head(1)) levert alleen de waarde van de eerste rij in elke groep; de andere rijen krijgen NaN. Behoud bij berekeningen per rij de oorspronkelijke index wanneer je het resultaat weer aan de tabel wilt toekennen.

Cumulatieve berekeningen en vergelijkingen met eerdere waarnemingen hebben zowel een groep als een rijvolgorde nodig. Groeperen voorkomt dat een berekening naar een andere groep doorloopt; sorteren bepaalt wat “vorige” of “tot dan toe” betekent.

Accumuleer binnen elke groep

Ga ervan uit dat de bestelrijen al in tijdsvolgorde staan:

sales["running_units"] = sales.groupby("region")["units"].cumsum()

De aantallen 10, 7 en 6 van North geven cumulatieve totalen 10, 17 en 23. De aantallen 4, 9 en 8 van South geven 4, 13 en 21. De aantallen 5 en 3 van East geven 5 en 8. Deze waarden blijven gekoppeld aan hun oorspronkelijke rijlabels, dus de volledige uitvoer in rijvolgorde is 10, 4, 17, 5, 13, 8, 23 en 21.

Zonder groupby zou sales["units"].cumsum() één totaal over alle bestellingen geven: 10, 14, 21, 26, 35, 38, 44 en 52. De gegroepeerde berekening begint voor elke regio opnieuw. Verwante methoden zijn cumprod, cummax en cummin voor cumulatieve producten, maxima en minima.

cumcount() telt posities binnen groepen vanaf nul. Hier geeft het 0, 0, 1, 0, 1, 1, 2 en 2. Tel er 1 bij op voor het eerste, tweede en derde bestelnummer binnen elke regio.

Ken rangnummers toe zonder rijen te verplaatsen

sales.groupby("region")["revenue"].rank(ascending=False)

De grootste omzet krijgt rangnummer 1 in de eigen regio: rij 0 van North, rij 4 van South en rij 3 van East. De uitvoer behoudt de invoerindex; rangnummering verplaatst de grootste rijen niet naar de bovenkant van de tabel.

Standaard krijgen gelijke waarden het gemiddelde van hun rangnummers. Als twee waarden de eerste plaats delen, krijgen beide 1,5 en krijgt de volgende 3. method="min" geeft de gelijke waarden 1 en de volgende nog steeds 3. method="dense" geeft de gelijke waarden 1 en de volgende 2. Kies een regel voor gelijke waarden die past bij de interpretatie van de rangnummers.

Vergelijk opeenvolgende waarden

g = sales.groupby("region")["units"]
previous = g.shift(1)
change = g.diff()
relative_change = g.pct_change()

De vorige waarden van North zijn ontbrekend, 10 en 7. De verschillen zijn ontbrekend, −3 en −1. De relatieve veranderingen zijn ontbrekend, −0,3 en ongeveer −0,143: het verschil wordt gedeeld door de vorige waarde. pct_change() geeft een fractie terug, dus −0,3 betekent een daling van 30%, niet van 0,3%.

De eerste waarneming van elke groep heeft geen vorige waarneming en krijgt NaN. Een gewone shift() op de kolom zou de vorige rij van de hele tabel gebruiken, die bij een andere regio kan horen.

Sorteer vóór deze volgordeafhankelijke berekeningen de rijen op de kolom die de volgorde bepaalt, zoals een datum of gebeurtenisnummer. groupby(sort=True) sorteert alleen groepssleutels; het kan waarnemingen niet chronologisch ordenen. Rangnummering vergelijkt waarden en verwerkt gelijke waarden onafhankelijk van de chronologie, terwijl cumulatieve berekeningen en berekeningen met vertraagde waarden afhangen van de gekozen volgorde.

Een groep behouden en een groep samenvatten zijn verschillende bewerkingen. Een groepsfilter gebruikt een voorwaarde voor de hele groep om te bepalen welke oorspronkelijke rijen blijven; rijselectiemethoden kiezen specifieke waarnemingen uit elke groep.

Behoud hele groepen

sales.groupby("region").filter(lambda g: len(g) >= 3)

North en South hebben elk drie bestellingen, terwijl East er twee heeft. Het resultaat bevat rijen 0, 1, 2, 4, 6 en 7, in de oorspronkelijke volgorde en met hun oorspronkelijke labels. Het geeft geen twee regionale samenvattingsrijen terug.

De voorwaarde moet voor elke groep één booleaanse waarde opleveren. lambda g: g["units"] > 5 levert een booleaanse Series op en is ongeldig voor filter. Breng die voorwaarde terug tot één waarde met all() of any():

sales.groupby("region").filter(lambda g: (g["units"] > 5).all())

Alleen North voldoet, omdat alle aantallen, 10, 7 en 6, groter zijn dan 5. Met any() behoud je ook South, omdat minstens één bestelling daar meer dan 5 eenheden heeft.

Een getransformeerde groepsgrootte levert voor de eerste taak een sneller masker dat op de rijen is uitgelijnd:

sizes = sales.groupby("region")["units"].transform("size")
sales[sizes >= 3]

Dit masker kun je met & en | combineren met andere rijvoorwaarden. Als je in plaats daarvan sales.groupby("region")["revenue"].sum() zou filteren, zou je samenvattingswaarden behouden, niet de oorspronkelijke bestellingen.

Neem rijen op positie

head(n) neemt de eerste n rijen per groep, tail(n) de laatste n en nth(k) de rij op positie k, geteld vanaf nul. sales.groupby("region").head(1) geeft rijen 0, 1 en 3 terug: de eerst waargenomen bestelling uit elke regio. Door ontbrekende waarden zoekt head(1) niet naar een latere rij zonder ontbrekende waarde.

Om de grootste bestelling per regio te selecteren, sorteer je eerst op omzet:

sales.sort_values("revenue", ascending=False).groupby("region").head(1)

De geselecteerde rijen zijn rij 4 van South met omzet 36, rij 0 van North met 30 en rij 3 van East met 20. Het sorteren bepaalt welke waarneming eerst komt; de groepsbewerking neemt vervolgens die eerste rij. Bij unieke rijlabels haalt sales.loc[sales.groupby("region")["revenue"].idxmax()] dezelfde maxima op via hun labels.

Trek binnen elke groep een steekproef

sales.groupby("region").sample(n=1, random_state=0)

Dit trekt één bestelling uit elke regio. Door random_state in te stellen, leveren herhaalde uitvoeringen op dezelfde gegevens dezelfde trekking op. Een steekproef uit het hele DataFrame zou een regio kunnen missen, zelfs als die in totaal drie rijen heeft.

Gebruik frac=0.5 om ongeveer de helft van de rijen in elke groep te trekken. De steekproefgrootte per groep wordt afgerond: met frac=0.2 leveren de twee rijen van East 0,4 rijen op, afgerond naar nul. Gebruik expliciet n=1 wanneer elke niet-lege groep één waarneming moet bijdragen. De gevraagde steekproefgrootte moet voor de groepen haalbaar zijn bij de gekozen steekproefinstellingen.

Met apply kan een functie een hele groep bekijken en een scalaire waarde, een Series of een DataFrame teruggeven. Die flexibiliteit is handig wanneer kolommen samen nodig zijn of het resultaat meerdere rijen bevat. Daardoor is de vorm van het resultaat ook minder voorspelbaar dan bij agg of transform.

Gebruik meerdere kolommen samen

def price_per_unit(g):
    return g["revenue"].sum() / g["units"].sum()

sales.groupby("region").apply(price_per_unit)

De functie ontvangt de rijen van één regio. Ze geeft één waarde terug, dus pandas combineert de uitvoer tot een Series met regio's als index: East 3,625, North ongeveer 3,304 en South ongeveer 3,810. Een verhouding van ingebouwde gegroepeerde sommen geeft hetzelfde resultaat met minder extra werk in Python. np.average(g["revenue"] / g["units"], weights=g["units"]) drukt het equivalente gewogen gemiddelde uit.

Voor een statistiek met twee kolommen, zoals de correlatie tussen studie-uren en score binnen elke lesgroep, kan apply de twee Series van elke groep aan .corr() doorgeven.

Voorspel hoe uitvoer wordt gecombineerd

Een functie die voor elke groep een Series met dezelfde labels teruggeeft, maakt één tabelrij per groep:

sales.groupby("region").apply(
    lambda g: pd.Series({
        "orders": len(g),
        "avg_price": g["revenue"].sum() / g["units"].sum()
    })
)

De kolommen zijn orders en avg_price. De aantallen verschijnen als 2.0, 3.0 en 3.0 omdat de teruggegeven Series ook een prijs als drijvendekommagetal bevat. Als de teruggegeven Series verschillende labels gebruiken, stapelt pandas ze tot een langere Series, met groepssleutels als buitenste indexniveau.

Een DataFrame per groep wordt gestapeld tot een groter DataFrame:

def top(g, n=2, col="revenue"):
    return g.sort_values(col, ascending=False).head(n)

sales.groupby("region").apply(top)

De rijen zijn East 3 en 5, North 0 en 2 en South 4 en 7. Elke groep wordt afzonderlijk gesorteerd. Extra argumenten volgen na de functie: .apply(top, n=1, col="units") wijzigt de selectie naar de bestelling met het grootste aantal eenheden.

Bepaal sleutels en uitlijning

Voor deze teruggegeven rijen voegt de standaardinstelling group_keys=True de regio toe als buitenste indexniveau. sales.groupby("region", group_keys=False).apply(top) behoudt alleen de oorspronkelijke rijlabels. De methode stelt het resultaat nog steeds groep voor groep samen; de rijvolgorde van de invoertabel is niet gegarandeerd.

Sinds pandas 3.0 sluit het DataFrame dat aan een gegroepeerde apply wordt doorgegeven de groeperingskolommen uit. In dit voorbeeld heeft het product, units en revenue, maar niet region. Lees de huidige groepssleutel uit g.name wanneer de functie die nodig heeft.

Gebruik een specifiekere methode wanneer die past

apply voert voor elke groep Python-code uit en leidt af hoe de uitvoer moet worden samengesteld. Gebruik agg voor samenvattende waarden per kolom, transform voor resultaten die op elke invoerrij zijn uitgelijnd en filter om te beslissen of hele groepen worden behouden of verwijderd.

Als je bijvoorbeeld via apply op een geselecteerde Series het gemiddelde van elke regio aftrekt, krijg je verschillen onder een MultiIndex met regio en rij. transform geeft de verschillen terug met de oorspronkelijke index, klaar om als kolom toe te kennen.

Klasse-indeling, ook discretisatie genoemd, vervangt numerieke waarden door intervalcategorieën. Gebruik die wanneer een rapport betekenisvolle bereiken nodig heeft, zoals scoreklassen, in plaats van een afzonderlijke groep voor elk getal.

Stel expliciete grenzen in

scores = pd.Series([42, 50, 55, 64, 68, 70, 73, 81, 85, 88, 97, 100])
bands = pd.cut(scores, [0, 50, 70, 85, 100])
bands.value_counts(sort=False)

Vijf grenzen bepalen vier klassen: (0, 50], (50, 70], (70, 85] en (85, 100]. Ze bevatten 2, 4, 3 en 3 scores. Expliciete grenzen kunnen ongelijke breedtes opleveren omdat ze betekenisvolle grenzen beschrijven.

Een rond haakje sluit een grenspunt uit en een vierkant haakje sluit het in. Met de standaardinstelling right=True hoort 50 in de eerste klasse, 70 in de tweede, 85 in de derde en 100 in de vierde. Lees (50, 70] als “groter dan 50 en hoogstens 70”.

Verwerk de buitenste grenzen

Met deze expliciete grenzen is 0 uitgesloten van het eerste interval en ligt 101 voorbij het laatste interval. Beide krijgen NaN. Gebruik include_lowest=True om een waarde op te nemen die gelijk is aan de laagste grens. Waarden onder de laagste grens of boven de hoogste krijgen nog steeds geen klasse.

Gebruik right=False voor links gesloten intervallen. Dezelfde grenzen bepalen dan [0, 50), [50, 70), [70, 85) en [85, 100). Nu gaat 50 naar de tweede klasse en is 100 uitgesloten. De aantallen in het voorbeeld worden 1, 4, 3 en 3, met één ontbrekende klassetoewijzing. Een bovengrens van 101 zou de score 100 opnemen in de laatste links gesloten klasse.

Als je de inclusie van grenzen verandert, verandert de indeling van waarden op een grens. Controleer een minimum, een binnengrens en een maximum voordat je de klassen in een rapport gebruikt.

Voeg leesbare labels toe

bands = pd.cut(
    scores, [0, 50, 70, 85, 100],
    labels=["fail", "pass", "merit", "distinction"]
)

Geef één label per interval op: vier labels voor vijf grenzen. De uitvoer is een geordende categorische variabele, dus de volgorde is fail, pass, merit, distinction, niet alfabetisch. labels=False geeft voor toegewezen waarden in plaats daarvan klassecodes 0 tot en met 3 terug.

value_counts() sorteert normaal op frequentie. Gebruik sort=False of sorteer de resulterende index om de intervalvolgorde te behouden. Anders kan de meest voorkomende klasse eerst verschijnen en de verdeling moeilijker leesbaar maken.

Vraag pandas om gelijke breedtes

Als je een geheel getal doorgeeft, vraag je dat aantal klassen met gelijke breedte op:

bands, edges = pd.cut(scores, 4, retbins=True)

Het bereik van 42 tot 100 beslaat 58, wat breedtes van 14,5 geeft. De binnengrenzen zijn 56,5, 71,0 en 85,5. pandas verlengt de onderkant iets voor deze rechts gesloten klassen en geeft een eerste grens van 41,942, zodat het minimum wordt opgenomen. Elke klasse bevat hier toevallig drie scores; gelijke breedtes leveren doorgaans geen gelijke aantallen op.

retbins=True geeft zowel de werkelijke grenzen als de toewijzingen terug. Expliciete grenzen moeten oplopen: [0, 70, 50, 100] kan de bedoelde volgorde van intervallen niet bepalen.

Een kwantiel beschrijft een positie in gesorteerde gegevens. De mediaan is het 0,5-kwantiel; kwartielen verdelen de verdeling in kwarten, decielen in tienden en percentielen in honderdsten. qcut gebruikt steekproefkwantielen als klassengrenzen.

Bereken een kwantiel

Voor de scores 42, 50, 55, 64, 68, 70, 73, 81, 85, 88, 97 en 100:

scores.quantile([0.25, 0.5, 0.75])

De resultaten zijn 61,75, 71,5 en 85,75. pandas gebruikt standaard lineaire interpolatie. Voor het 0,25-kwantiel is de positie, geteld vanaf nul:

Positie 2 bevat 55 en positie 3 bevat 64. Neem driekwart van de afstand ertussen:

Een steekproefkwantiel kan dus tussen waargenomen waarden liggen. Het hoeft niet gelijk te zijn aan een score die iemand daadwerkelijk heeft behaald.

Maak kwantielgroepen

quartile = pd.qcut(scores, 4, labels=["Q1", "Q2", "Q3", "Q4"])

Deze steekproef geeft drie scores per kwartielgroep. De binnengrenzen zijn de drie berekende kwartielen. Het eerste interval bevat het minimum; de intervalweergave past het onderste label aan tot iets onder 42. Gebruik labels=False voor codes 0 tot en met 3 of retbins=True om de numerieke grenzen op te halen.

Een lijst met aandelen bepaalt de kwantielbereiken. pd.qcut(x, [0, 0.1, 0.5, 0.9, 1]) scheidt de laagste 10%, twee middendelen gescheiden door de mediaan en de hoogste 10%.

Kies breedtes of aantallen

Levertijden van 5, 6, 7, 7, 8, 9, 10, 12, 15, 20, 35 en 60 minuten laten het verschil zien. Drie klassen met gelijke breedte bevatten 10, 1 en 1 waarnemingen. Drie kwantielklassen bevatten elk 4 waarnemingen, met binnengrenzen rond 7,67 en 13 minuten. Lange vertragingen rekken het bereik van de klassen met gelijke breedte uit, waardoor de meeste waarnemingen in de eerste klasse vallen.

Gebruik vaste grenzen wanneer dezelfde tijdbereiken tussen datasets moeten worden vergeleken. Kwantielgrenzen veranderen wanneer de steekproef verandert.

Houd gelijke waarden zichtbaar

Voor de waarden 2, 3, 3, 4, 5, 6, 6, 7, 8, 9, 10 en 12 zijn de kwartielgrenzen 3,75, 6 en 8,25. Beide waarden van 6 horen bij elkaar, dus de klassenaantallen zijn 3, 4, 2 en 3. Een klasse-indeling met gelijke aantallen is bij gelijke waarden een benadering.

Bij veel gelijke waarden kunnen kwantielgrenzen samenvallen. Voor 1, 1, 1, 1, 1, 1, 2 en 3 levert het opvragen van kwartielen herhaalde grenzen op. duplicates="drop" verwijdert dubbele grenzen en laat slechts twee klassen over, met aantallen 6 en 2. Door eerst rangnummers toe te kennen met rank(method="first") kun je vier even grote groepen afdwingen, maar worden gelijke waarden op rijvolgorde verdeeld. Daardoor verandert de betekenis van waarde-intervallen naar groepen op basis van rangnummers waarbij gelijke waarden zijn onderscheiden.

Een klasselabel kan als groepssleutel dienen. Zo kun je vragen hoe één variabele verandert over bereiken van een andere, zoals de gemiddelde examenscore per klasse van studie-uren. De samenvatting beschrijft de waarnemingen in elke klasse.

Maak een samenvatting per klasse

Maak de studentgegevens:

students = pd.DataFrame({
    "group": ["day", "evening", "day", "evening", "day", "evening", "day", "evening", "day", "day", "evening", "day"],
    "hours": [2, 3, 3, 5, 4, 6, 6, 8, 7, 9, 10, 12],
    "score": [42, 50, 55, 64, 68, 70, 73, 81, 85, 88, 97, 100]
})
hour_band = pd.cut(students["hours"], [0, 3, 6, 9, 12])
students.groupby(hour_band)["score"].agg(["count", "mean"])

De vier klassen bevatten 3, 4, 3 en 2 studenten. Hun gemiddelde scores zijn 49, 68,75, ongeveer 84,67 en 98,5. In de eerste klasse zijn de scores 42, 50 en 55; hun gemiddelde is 147/3 = 49. Het aantal toont hoeveel vastgelegde scores elk gemiddelde ondersteunen.

De Series met klassen heeft één element per student en dezelfde index, zodat de toewijzingen tijdens het groeperen met de rijen overeenkomen. De numerieke kolom hours blijft beschikbaar voor andere berekeningen.

Behoud lege klassen wanneer een rapport die nodig heeft

Sinds pandas 3.0 is observed=True de standaardinstelling voor groepering met categorische sleutels. Voeg een grens van 15 toe en de ongebruikte klasse (12, 15] wordt weggelaten. observed=False behoudt die met aantal 0 en gemiddelde NaN. Nul studenten is een aantal; een gemiddelde van nul zou ten onrechte suggereren dat waargenomen scores gemiddeld nul zijn.

Klassen zijn geordende categorieën, dus de normale gegroepeerde uitvoer volgt de intervalvolgorde van laag naar hoog. Benoemde labels behouden de volgorde die aan hun intervallen is toegekend.

Analyseer kwantielgroepen en combinaties

quartile = pd.qcut(students["hours"], 4,
                   labels=["Q1", "Q2", "Q3", "Q4"])
students.groupby(quartile)["score"].agg(["count", "min", "max", "mean"])

De aantallen zijn 3, 4, 2 en 3, met gemiddelde scores 49, 68,75, 83 en 95. De gelijke waarden van 6 verklaren de ongelijke aantallen. Om dag- en avondstudenten binnen elk kwartiel te vergelijken, groepeer je op [quartile, "group"] en roep je .mean().unstack() aan. De gemiddelden voor Q1 zijn day 48,5 en evening 50; voor Q4 zijn ze day 94 en evening 97.

De richting van de analyse doet ertoe. Studie-uren groeperen op scoreklassen beantwoordt een andere vraag: de gemiddelde uren voor de klassen fail, pass, merit en distinction zijn 2,5, 4,5, 7 en ongeveer 10,33.

Bepaal welke populatie een kwantiel vastlegt

Een indeling van de scores op de totale mediaan gebruikt 71,5. Een indeling binnen elke lesgroep gebruikt de eigen mediaan: daggroep 73 en avondgroep 70.

within_class = students.groupby("group")["score"].transform(
    lambda s: pd.qcut(s, 2, labels=["lower", "upper"])
)

De student uit de daggroep met score 73 zit boven de totale mediaan, maar hoort binnen de daggroep bij de onderste helft. Beide labels zijn correct omdat ze verschillende vergelijkingsvragen beantwoorden.

Een stijgend gemiddelde over klassen van uren is een samenhang. Studenten in verschillende klassen kunnen ook op andere manieren verschillen, dus de tabel alleen kan niet aantonen dat extra studietijd het scoreverschil heeft veroorzaakt. Kleine aantallen maken een gemiddelde ook gevoeliger voor één waarneming.

Een draaitabel vat waarden samen voor combinaties van rij- en kolomsleutels. Elke cel verzamelt de waarnemingen op één snijpunt en past een functie toe, zoals een som of gemiddelde.

Wijs de rollen expliciet toe

sales.pivot_table(
    index="region", columns="product",
    values="revenue", aggfunc="sum"
)

index levert de rijsleutels, columns de kolomsleutels, values de gemeten variabele en aggfunc de berekening. De tabel is:

North–tea combineert omzetten 30 en 18, dus de som is 48. South–coffee combineert 36 en 32, wat 68 geeft. Dezelfde gegevens kun je samenvatten met sales.groupby(["region", "product"])["revenue"].sum().unstack().

De standaardwaarde van aggfunc is "mean". Als je die weglaat, krijg je North–tea 24 en South–coffee 34. Geef aggfunc="sum" op wanneer de vraag om totalen vraagt; de indeling van een tabel vertelt niet welke statistiek die bevat.

Vul ontbrekende combinaties zorgvuldig aan

Combinaties zonder waarnemingen verschijnen als NaN. Verwijder de theebestelling van East en die cel wordt ontbrekend. fill_value=0 kan in een rapport met sommen of aantallen weergeven dat er geen bestellingen zijn. Als je bij een gemiddelde een lege cel door 0 vervangt, suggereert dat een waargenomen gemiddelde dat nooit is gemeten. Behoud de ontbrekende status wanneer er geen gemiddelde bestaat.

Categorische sleutels volgen de keuze voor observed; sinds pandas 3.0 toont de standaardinstelling waargenomen categorieën. Stel die expliciet in wanneer een rapport ongebruikte categorieën moet behouden.

Voeg randtotalen toe met dezelfde functie

sales.pivot_table(
    index="region", columns="product", values="revenue",
    aggfunc="sum", margins=True, margins_name="Total"
)

De rijtotalen zijn East 29, North 76 en South 80. De kolomtotalen zijn coffee 116 en tea 69; het eindtotaal is 185. margins_name vervangt het standaardlabel All.

Randtotalen worden met de aggregatiefunctie opnieuw uit de onderliggende rijen berekend. Bij een draaitabel met gemiddelden is de hoekcel 23,125, het gemiddelde van alle acht bestellingen. Het middelen van de zes weergegeven celgemiddelden zou ongeveer 21,17 geven, omdat de cellen verschillende aantallen waarnemingen bevatten. Een randtotaal is geen algemene opdracht om de getoonde getallen op te tellen of te middelen.

Breid de tabel uit of tel

aggfunc=["sum", "mean"] maakt voor elke statistiek een blok kolommen. Met units heeft North–tea som 16 en gemiddelde 8. Een functiedictionary zoals {"units": "sum", "revenue": "max"} wijst functies toe aan afzonderlijke waardekolommen. Meerdere sleutels kunnen ook hiërarchische rijen of kolommen maken en in klassen ingedeelde waarden werken als categorische sleutels.

aggfunc="size" telt rijen per cel, terwijl "count" aanwezige waarden in de gekozen waardekolom telt. North heeft één koffiebestelling en twee theebestellingen.

pivot aggregeert niet en vereist unieke rij- en kolomcombinaties. De verkooptabel heeft herhaalde combinaties North–tea en South–coffee, dus pivot geeft een fout over dubbele vermeldingen. Gebruik pivot_table wanneer meerdere waarnemingen in één cel moeten worden gecombineerd.

Een kruistabel, of contingentietabel, telt waarnemingen voor combinaties van categorische variabelen. Met aandelen kun je vervolgens groepen met verschillende aantallen waarnemingen vergelijken.

Tel combinaties

De enquêtegegevens bevatten zes gebruikers met een basisabonnement: vier gebruiken een telefoon en twee een laptop. Van de vier gebruikers met een premiumabonnement gebruikt er één een telefoon en gebruiken er drie een laptop.

survey = pd.DataFrame({
    "plan": ["basic"] * 6 + ["premium"] * 4,
    "device": ["phone", "phone", "phone", "laptop", "phone", "laptop",
               "laptop", "laptop", "phone", "laptop"],
    "minutes": [20, 35, 15, 40, 25, 50, 60, 45, 30, 55]
})
counts = pd.crosstab(survey["plan"], survey["device"], margins=True)

Geef de werkelijke Series door, niet de tekenreeksen "plan" en "device". De eerste variabele levert rijen en de tweede kolommen. De rij basic bevat laptop 2 en phone 4; de rij premium bevat laptop 3 en phone 1. De rijtotalen zijn 6 en 4, de kolomtotalen zijn 5 en 5 en het eindtotaal is 10.

Bij ruwe aantallen wordt een ontbrekende combinatie als nul getoond. Je kunt dezelfde aantallen krijgen met survey.groupby(["plan", "device"]).size().unstack(fill_value=0) of een draaitabel met aggfunc="size". survey.value_counts(["plan", "device"]) geeft een lange frequentielijst gesorteerd op aantal.

Kies de noemer op basis van de vraag

“Welk aandeel van de gebruikers met een premiumabonnement gebruikt een laptop?” begint bij de gebruikers met een premiumabonnement, dus de noemer is 4. Gebruik rijnormalisatie; het antwoord is 3/4 = 0,75. “Welk aandeel van de telefoongebruikers heeft het basisabonnement?” begint bij telefoongebruikers, dus de noemer is 5. Gebruik kolomnormalisatie; het antwoord is 4/5 = 0,8.

Het aantal van drie laptopgebruikers met een premiumabonnement is groter dan het aantal van twee met een basisabonnement, maar de vergelijking binnen de abonnementen is 75% tegenover ongeveer 33,3%. Bepaal welke populatie je vergelijkt voordat je een aantal omzet in een aandeel. Vermenigvuldig genormaliseerde waarden met 100 voor percentages.

Met margins=True hebben ook genormaliseerde randtotalen een betekenis. Rijnormalisatie voegt een rij All toe met de totale apparaataandelen, 0,5 en 0,5. Kolomnormalisatie voegt een kolom All toe met de totale abonnementsaandelen, 0,6 en 0,4.

Vat een derde variabele samen

Geef values en aggfunc op om frequenties door een numerieke statistiek te vervangen:

pd.crosstab(survey["plan"], survey["device"],
            values=survey["minutes"], aggfunc="mean")

Laptopsessies met een basisabonnement van 40 en 50 minuten duren gemiddeld 45 minuten. Telefoonsessies met een basisabonnement van 20, 35, 15 en 25 minuten duren gemiddeld 23,75 minuten. Laptopsessies met een premiumabonnement van 60, 45 en 55 minuten duren gemiddeld ongeveer 53,33 minuten, terwijl de enkele telefoonsessie met een premiumabonnement 30 minuten duurt. Deze cellen beschrijven sessieduur, geen aantallen gebruikers.

Een lijst met Series kan meerdere rij- of kolomniveaus opleveren. Scores die in klassen zijn ingedeeld, werken ook als categorieën: als je fail, pass, merit en distinction kruist met de lesgroep, krijg je voor de daggroep aantallen 1, 2, 2, 2 en voor de avondgroep 1, 2, 1, 1. De betekenis van elke cel volgt nog steeds uit de rijsleutel, kolomsleutel en gekozen statistiek.