Lidsky řečeno
Máš krabici účtenek z pekárny. Filtrování znamená vytáhnout jen účtenky z Brna. Groupby znamená rozházet je na hromádky podle města, každou hromádku sečíst a výsledky napsat na jeden papír. Spojování znamená přiložit ke každé účtence kartu zákazníka z jiné kartotéky. Skoro každá analýza dat je nějaká kombinace těchhle tří činností.
Filtrování: polož každému řádku otázku
Připomenutí: DataFrame je tabulka a Series jeden její sloupec. Když sloupec porovnáš s hodnotou, pandas položí otázku každému řádku zvlášť. Výsledkem je sloupec hodnot True a False, kterému se říká maska. Dáš ji do hranatých závorek a zůstanou jen řádky s True.
import pandas as pd
prodeje = pd.DataFrame({
"mesto": ["Brno", "Praha", "Brno", "Ostrava", "Praha", "Brno"],
"produkt": ["chleba", "rohlík", "rohlík", "chleba", "koláč", "koláč"],
"kusy": [12, 80, 45, 9, 14, 20],
"cena": [48, 4, 4, 48, 35, 35],
})
maska = prodeje["kusy"] > 15
print(maska)
print()
print(prodeje[maska])
0 False 1 True 2 True 3 False 4 False 5 True Name: kusy, dtype: bool mesto produkt kusy cena 1 Praha rohlík 80 4 2 Brno rohlík 45 4 5 Brno koláč 20 35
Všimni si čísel řádků vlevo. Zůstala ta původní (1, 2 a 5), filtrování je nepřečísluje. Původní tabulka se nezměnila, dostal jsi novou.
Podmínky se skládají operátory & (a zároveň), | (nebo) a ~ (ne). Každá podmínka musí být ve vlastních závorkách. Pro časté případy existují zkratky: isin ověří členství v seznamu, between rozsah a query dovolí napsat podmínku jako text.
import pandas as pd
prodeje = pd.DataFrame({
"mesto": ["Brno", "Praha", "Brno", "Ostrava", "Praha", "Brno"],
"produkt": ["chleba", "rohlík", "rohlík", "chleba", "koláč", "koláč"],
"kusy": [12, 80, 45, 9, 14, 20],
"cena": [48, 4, 4, 48, 35, 35],
})
print(prodeje[(prodeje["mesto"] == "Brno") & (prodeje["kusy"] >= 20)])
print()
print(prodeje[prodeje["produkt"].isin(["chleba", "koláč"])])
print()
print(prodeje[prodeje["kusy"].between(10, 20)])
print()
hranice = 10
print(prodeje.query("cena > @hranice and mesto != 'Praha'"))
mesto produkt kusy cena
2 Brno rohlík 45 4
5 Brno koláč 20 35
mesto produkt kusy cena
0 Brno chleba 12 48
3 Ostrava chleba 9 48
4 Praha koláč 14 35
5 Brno koláč 20 35
mesto produkt kusy cena
0 Brno chleba 12 48
4 Praha koláč 14 35
5 Brno koláč 20 35
mesto produkt kusy cena
0 Brno chleba 12 48
3 Ostrava chleba 9 48
5 Brno koláč 20 35Dlouhé jízdy na kole
V tabulce jizdy najdi jízdy delší než 30 minut, které proběhly v Brně nebo Olomouci. Výsledek ulož do proměnné dlouhe. Musí to být tabulka se všemi původními sloupci.
import pandas as pd
jizdy = pd.DataFrame({
"id": [1, 2, 3, 4, 5, 6],
"mesto": ["Brno", "Olomouc", "Plzeň", "Brno", "Olomouc", "Plzeň"],
"minuty": [42, 12, 55, 31, 38, 8],
})
# doplň
Kde je chyba?
Kód měl vybrat jízdy, které proběhly v Brně a zároveň trvaly déle než 30 minut. Výsledek je ale moc dlouhý.
groupby: rozděl, spočítej, slož
groupby dělá tři kroky. Rozdělí řádky do skupin podle hodnoty ve sloupci, v každé skupině něco spočítá a výsledky složí do nové, kratší tabulky.
mesto kusy rozděl spočítej slož
Brno 12 Brno: 12 45 20 sum = 77 Brno 77
Praha 80 -> Ostrava: 9 sum = 9 -> Ostrava 9
Brno 45 Praha: 80 14 sum = 94 Praha 94
Ostrava 9
Praha 14
Brno 20Vyber sloupec pro seskupení a agregační funkci. Barvy ukazují, do které skupiny který řádek padl, a pod tabulkou je odpovídající kód v pandas.
V kódu to je jeden řádek: podle čeho seskupit, který sloupec zpracovat a jakou funkcí.
import pandas as pd
prodeje = pd.DataFrame({
"mesto": ["Brno", "Praha", "Brno", "Ostrava", "Praha", "Brno"],
"produkt": ["chleba", "rohlík", "rohlík", "chleba", "koláč", "koláč"],
"kusy": [12, 80, 45, 9, 14, 20],
"cena": [48, 4, 4, 48, 35, 35],
})
soucty = prodeje.groupby("mesto")["kusy"].sum()
print(soucty)
print()
print(soucty.sort_values(ascending=False))
print()
print(prodeje.groupby("mesto")["kusy"].mean())
print()
print(prodeje.groupby("mesto").size())
print()
print(prodeje.groupby("mesto", as_index=False)["kusy"].sum())
mesto
Brno 77
Ostrava 9
Praha 94
Name: kusy, dtype: int64
mesto
Praha 94
Brno 77
Ostrava 9
Name: kusy, dtype: int64
mesto
Brno 25.666667
Ostrava 9.000000
Praha 47.000000
Name: kusy, dtype: float64
mesto
Brno 3
Ostrava 1
Praha 2
dtype: int64
mesto kusy
0 Brno 77
1 Ostrava 9
2 Praha 94Výsledek je seřazený podle názvu města, protože groupby klíče ve výchozím stavu řadí. Města se stala indexem výsledku, tedy popiskem řádků. Poslední varianta s as_index=False je nechá jako běžný sloupec, což se hodí pro další práci nebo export.
Když chceš víc čísel naráz, použij agg s pojmenovanými výsledky. Zápis nazev=("sloupec", "funkce") čteš takto: nový sloupec nazev vznikne z sloupec pomocí funkce.
import pandas as pd
prodeje = pd.DataFrame({
"mesto": ["Brno", "Praha", "Brno", "Ostrava", "Praha", "Brno"],
"produkt": ["chleba", "rohlík", "rohlík", "chleba", "koláč", "koláč"],
"kusy": [12, 80, 45, 9, 14, 20],
"cena": [48, 4, 4, 48, 35, 35],
})
prodeje["trzba"] = prodeje["kusy"] * prodeje["cena"]
souhrn = (
prodeje.groupby("mesto")
.agg(
radku=("kusy", "size"),
kusy_celkem=("kusy", "sum"),
nejvetsi_prodej=("kusy", "max"),
trzba_celkem=("trzba", "sum"),
)
.sort_values("trzba_celkem", ascending=False)
)
print(souhrn)
radku kusy_celkem nejvetsi_prodej trzba_celkem mesto Brno 3 77 45 1456 Praha 2 94 80 810 Ostrava 1 9 9 432
Brno vydělalo 12 · 48 + 45 · 4 + 20 · 35 = 1456 Kč a je první, i když Praha prodala víc kusů. Rohlíky jsou levné.
Co je rozdíl mezi size a count v groupby?
Rozdíl uvidíš, jakmile ve sloupci chybí data. Pokud size a count nesedí, máš ve skupině prázdná místa.
Dva klíče a kontingenční tabulka
Seskupovat lze i podle víc sloupců. Přehlednější bývá kontingenční tabulka, kterou znáš z Excelu jako pivot: jeden klíč jde do řádků, druhý do sloupců.
import pandas as pd
prodeje = pd.DataFrame({
"mesto": ["Brno", "Praha", "Brno", "Ostrava", "Praha", "Brno"],
"produkt": ["chleba", "rohlík", "rohlík", "chleba", "koláč", "koláč"],
"kusy": [12, 80, 45, 9, 14, 20],
})
print(prodeje.groupby(["mesto", "produkt"])["kusy"].sum())
print()
tabulka = prodeje.pivot_table(
index="mesto",
columns="produkt",
values="kusy",
aggfunc="sum",
fill_value=0,
)
print(tabulka)
mesto produkt
Brno chleba 12
koláč 20
rohlík 45
Ostrava chleba 9
Praha koláč 14
rohlík 80
Name: kusy, dtype: int64
produkt chleba koláč rohlík
mesto
Brno 12 20 45
Ostrava 9 0 0
Praha 0 14 80transform: souhrn bez zmenšení tabulky
agg udělá z každé skupiny jeden řádek. Někdy ale chceš původní řádky zachovat a jen k nim přidat číslo za celou skupinu. Třeba jakým dílem se každý prodej podílel na tržbě svého města. K tomu slouží transform: vrátí stejně dlouhý sloupec, jaký dostal.
import pandas as pd
prodeje = pd.DataFrame({
"mesto": ["Brno", "Praha", "Brno", "Ostrava", "Praha", "Brno"],
"kusy": [12, 80, 45, 9, 14, 20],
"cena": [48, 4, 4, 48, 35, 35],
})
prodeje["trzba"] = prodeje["kusy"] * prodeje["cena"]
trzba_mesta = prodeje.groupby("mesto")["trzba"].transform("sum")
prodeje["podil_ve_meste"] = (prodeje["trzba"] / trzba_mesta).round(2)
print(prodeje)
print()
print(prodeje.groupby("mesto")["podil_ve_meste"].sum().round(1))
mesto kusy cena trzba podil_ve_meste 0 Brno 12 48 576 0.40 1 Praha 80 4 320 0.40 2 Brno 45 4 180 0.12 3 Ostrava 9 48 432 1.00 4 Praha 14 35 490 0.60 5 Brno 20 35 700 0.48 mesto Brno 1.0 Ostrava 1.0 Praha 1.0 Name: podil_ve_meste, dtype: float64
Tabulka má 100 řádků a 4 různá města. Kolik řádků má df.groupby("mesto")["kusy"].sum() a kolik df.groupby("mesto")["kusy"].transform("sum")?
Agregace vrací jeden řádek za skupinu. transform vrací jednu hodnotu za každý původní řádek, takže výsledek můžeš rovnou uložit jako nový sloupec.
Kolik řádků vyjde?
Roztřiď operace podle toho, kolik řádků má jejich výsledek ve srovnání s tabulkou df.
Souhrn po městech
Z tabulky jizdy vytvoř tabulku souhrn s jedním řádkem za město a se sloupci pocet (počet jízd), minuty_celkem (součet minut) a nejdelsi (nejdelší jízda). Seřaď ji od největšího minuty_celkem.
import pandas as pd
jizdy = pd.DataFrame({
"mesto": ["Brno", "Olomouc", "Plzeň", "Brno", "Olomouc", "Plzeň", "Plzeň"],
"minuty": [42, 12, 55, 31, 38, 8, 20],
})
# doplň
merge: spoj tabulky podle klíče
Data málokdy leží v jedné tabulce. Zákazníci jsou zvlášť, objednávky zvlášť a spojuje je klíč, tady číslo zákazníka. merge najde k řádku z jedné tabulky odpovídající řádky z druhé. Parametr how určuje, co s řádky, které partnera nemají.
how="inner" jen řádky se shodou na obou stranách (výchozí)
how="left" všechny z levé tabulky, chybějící doplní NaN
how="right" všechny z pravé tabulky
how="outer" všechny z obouNaN je značka pro chybějící hodnotu. V ukázce má Cyril nulu objednávek a objednávka číslo 4 patří zákazníkovi, kterého neznáme.
import pandas as pd
zakaznici = pd.DataFrame({
"id": [1, 2, 3],
"jmeno": ["Alena", "Boris", "Cyril"],
})
objednavky = pd.DataFrame({
"zakaznik_id": [1, 1, 2, 4],
"castka": [250, 90, 400, 70],
})
for zpusob in ["inner", "left", "outer"]:
spojeno = zakaznici.merge(
objednavky, left_on="id", right_on="zakaznik_id", how=zpusob
)
print(zpusob, "->", len(spojeno), "řádků")
print(spojeno)
print()
inner -> 3 řádků
id jmeno zakaznik_id castka
0 1 Alena 1 250
1 1 Alena 1 90
2 2 Boris 2 400
left -> 4 řádků
id jmeno zakaznik_id castka
0 1 Alena 1.0 250.0
1 1 Alena 1.0 90.0
2 2 Boris 2.0 400.0
3 3 Cyril NaN NaN
outer -> 5 řádků
id jmeno zakaznik_id castka
0 1.0 Alena 1.0 250.0
1 1.0 Alena 1.0 90.0
2 2.0 Boris 2.0 400.0
3 3.0 Cyril NaN NaN
4 NaN NaN 4.0 70.0Vnitřní spojení dá 3 řádky (dva Aleniny, jeden Borisův), levé 4 (přibude Cyril) a vnější 5 (přibude i neznámý zákazník). Alena je ve výsledku dvakrát, protože má dvě objednávky. Spojení tedy může tabulku prodloužit a právě tady vznikají nejdražší chyby: součty pak počítají něco dvakrát.
Když se klíč opakuje na obou stranách, spáruje se každý s každým. Tipni si, kolik řádků vyjde.
import pandas as pd
a = pd.DataFrame({"k": ["x", "x", "y"], "v": [1, 2, 3]})
b = pd.DataFrame({"k": ["x", "x", "z"], "w": [10, 20, 30]})
print(len(a.merge(b, on="k")))
print(len(a.merge(b, on="k", how="outer")))
4 6
Dva řádky x vlevo krát dva vpravo dávají čtyři dvojice. Vnější spojení k nim přidá osamělé y a z.
Stejné typy spojení na dvou malých tabulkách. Klikáním na čísla zákazníků v objednávkách měň klíče a sleduj, které řádky se spárují. Vizualizace počítá jako SQL, takže prázdný klíč se nespáruje s ničím. pandas se v tomhle chová jinak, viz blok pod kapotou na konci lekce.
Levá tabulka má 10 řádků. V pravé je každý klíč nejvýš jednou. Kolik řádků má výsledek how="left"?
Levé spojení zachová každý levý řádek a unikátní klíč vpravo nemůže nic zdvojit. Kdyby se klíč vpravo opakoval, výsledek by byl delší.
concat: polož tabulky na sebe
merge přidává sloupce podle klíče. concat jen skládá tabulky pod sebe, typicky stejná data z různých měsíců. Sloupce páruje podle názvu, a co v některé tabulce není, doplní jako NaN.
import pandas as pd
leden = pd.DataFrame({"produkt": ["chleba", "rohlík"], "kusy": [30, 200]})
unor = pd.DataFrame({"produkt": ["chleba", "koláč"], "kusy": [28, 15], "sleva": [0, 5]})
print(pd.concat([leden, unor], ignore_index=True))
print()
print(pd.concat([leden, unor], keys=["leden", "únor"]))
produkt kusy sleva
0 chleba 30 NaN
1 rohlík 200 NaN
2 chleba 28 0.0
3 koláč 15 5.0
produkt kusy sleva
leden 0 chleba 30 NaN
1 rohlík 200 NaN
únor 0 chleba 28 0.0
1 koláč 15 5.0Bez ignore_index=True by se čísla řádků opakovala. keys zase přidá popisek, odkud řádek pochází.
Tržby podle města zákazníka
Spoj objednavky se zakaznici tak, aby zůstaly jen objednávky známých zákazníků. Potom sečti castka podle města. Výsledek ulož jako Series podle_mesta s městy v indexu. Město bez objednávek v něm nemá být.
import pandas as pd
zakaznici = pd.DataFrame({
"id": [1, 2, 3, 4],
"mesto": ["Brno", "Praha", "Brno", "Zlín"],
})
objednavky = pd.DataFrame({
"zakaznik_id": [1, 2, 2, 3, 9],
"castka": [100, 250, 50, 300, 999],
})
# doplň
Pod kapotou · co groupby a merge dělají uvnitř
groupby nejdřív faktorizuje klíče: přes hashovací tabulku převede hodnoty na celočíselné kódy, v průměru v čase O(n). Vestavěné agregace (sum, mean, max) pak v Cythonu jednou projdou pole a kód řádku rovnou určuje, do kterého akumulátoru hodnota patří. Podtabulky přitom nevznikají. apply s pythonovou funkcí je naopak vytváří pro každou skupinu, takže při milionu skupin zaplatíš milion objektů. Než sáhneš po apply, zkus agg, transform nebo masku. sort=False ušetří řazení klíčů a nechá je v pořadí prvního výskytu.
Tři věci, které v produkci překvapí:
groupbyve výchozím stavu zahodí řádky s prázdným klíčem (dropna=True). Součet skupin pak nesedí s celkem a nic tě neupozorní.mergepovažuje prázdné klíče za shodné. SQL se chová opačně, protože tamNULL = NULLneplatí, takže přepis dotazu do pandas může tiše přidat řádky.- Součet skupiny ze samých
NaNje 0. Chceš-liNaN, použijsum(min_count=1).
Proti násobení řádků chrání validate. Vyhodí MergeError, pokud klíče neodpovídají očekávané vazbě, a stojí jen kontrolu unikátnosti. Při ladění spojení pomůže indicator=True: přidá sloupec _merge s hodnotami both, left_only a right_only, takže value_counts() hned ukáže, kolik řádků partnera nenašlo. U kategorických klíčů piš vždy observed=True: v pandas 2.2 je výchozí hodnota ještě False a vypisuje upozornění, přitom vytváří i prázdné kombinace kategorií. A pd.concat nevolej v cyklu po jednom řádku. Každé volání kopíruje vše dosavadní, takže celek je O(n²). Nasbírej tabulky do seznamu a spoj je jednou.
import pandas as pd
ceny = pd.DataFrame({"kod": ["A", "A", None], "cena": [10, 12, 99]})
sklad = pd.DataFrame({"kod": ["A", "B", None], "kusy": [1, 2, 3]})
spojeno = sklad.merge(ceny, on="kod", how="left")
print(spojeno)
print("řádků:", len(sklad), "->", len(spojeno))
try:
sklad.merge(ceny, on="kod", how="left", validate="many_to_one")
except pd.errors.MergeError as chyba:
print("MergeError:", chyba)
print(sklad.groupby("kod")["kusy"].sum())
print(sklad.groupby("kod", dropna=False)["kusy"].sum())
kod kusy cena 0 A 1 10.0 1 A 1 12.0 2 B 2 NaN 3 None 3 99.0 řádků: 3 -> 4 MergeError: Merge keys are not unique in right dataset; not a many-to-one merge kod A 1 B 2 Name: kusy, dtype: int64 kod A 1 B 2 NaN 3 Name: kusy, dtype: int64