0 dní v řadě · 0 bodů

Práce s daty · 24 min

Filtrování, groupby a spojování

Vybereš z tabulky potřebné řádky, spočítáš souhrny po skupinách a spojíš dvě tabulky podle společného klíče.

Hloubka
Úkoly
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])
Výstup
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'"))
Výstup
  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    35
Úkol

Dlouhé 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ň
Výstup
Najdi chybu

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.

text
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        20

Vyber 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())
Výstup
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    94

Vý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)
Výstup
         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é.

Kvíz

Co je rozdíl mezi size a count v groupby?

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)
Výstup
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      80

transform: 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))
Výstup
     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
Kvíz

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")?

Roztřiď

Kolik řádků vyjde?

Roztřiď operace podle toho, kolik řádků má jejich výsledek ve srovnání s tabulkou df.

Úkol

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ň
Výstup

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í.

text
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 obou

NaN 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()
Výstup
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.0

Vnitř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")))
Výstup
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.

Kvíz

Levá tabulka má 10 řádků. V pravé je každý klíč nejvýš jednou. Kolik řádků má výsledek how="left"?

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"]))
Výstup
  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.0

Bez ignore_index=True by se čísla řádků opakovala. keys zase přidá popisek, odkud řádek pochází.

Úkol

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ň
Výstup
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í:

  • groupby ve 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í.
  • merge považuje prázdné klíče za shodné. SQL se chová opačně, protože tam NULL = NULL neplatí, takže přepis dotazu do pandas může tiše přidat řádky.
  • Součet skupiny ze samých NaN je 0. Chceš-li NaN, použij sum(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())
Výstup
    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