0 dní v řadě · 0 bodů

Práce s daty · 28 min

pandas: tabulky v kódu

Vytvoříš a prozkoumáš tabulku v pandas, vybereš z ní řádky a sloupce, dopočítáš nové hodnoty a načteš české CSV.

Hloubka
Úkoly
Lidsky řečeno

Představ si excelovou tabulku, kterou neovládáš myší, ale větami: „vezmi sloupec cena, vynásob ho sloupcem kusy, seřaď to od největšího“. Výhoda proti klikání je, že se postup zapíše. Příští měsíc přijde nová tabulka a ty stejné věty jen spustíš znovu.

Series: sloupec se jmenovkami

pandas je knihovna pro práci s tabulkovými daty. Stojí na NumPy a přidává to, co pole nemá: pojmenované sloupce, popsané řádky a různé typy v jedné tabulce. Importuje se pod zkratkou pd.

Základní stavební kámen je Series, řada hodnot se jmenovkami. Těm jmenovkám se říká index. Na rozdíl od pole NumPy se tak k hodnotě dostaneš jménem.

import pandas as pd

prodeje = pd.Series([120, 80, 150], index=["po", "út", "st"], name="kusy")

print(prodeje)
print(prodeje["út"])
print(prodeje * 2)
print(prodeje.sum())
Výstup
po    120
út     80
st    150
Name: kusy, dtype: int64
80
po    240
út    160
st    300
Name: kusy, dtype: int64
350

Výpis má vlevo index a vpravo hodnoty. Násobení funguje jako v NumPy, na všech prvcích najednou. Součet je 350 a za úterý je to 80 kusů.

DataFrame: celá tabulka

DataFrame je tabulka, tedy několik Series se společným indexem. Nejsnáz ji vytvoříš ze slovníku: klíč je název sloupce, hodnota je seznam. Když index nezadáš, pandas očísluje řádky od nuly.

import pandas as pd

df = pd.DataFrame({
    "produkt": ["káva", "čaj", "kakao", "džus"],
    "kusy": [120, 80, 30, 45],
    "cena": [65.0, 45.0, 55.0, 50.0],
})

print(df)
print(df.shape)
print(df.columns.tolist())
Výstup
  produkt  kusy  cena
0    káva   120  65.0
1     čaj    80  45.0
2   kakao    30  55.0
3    džus    45  50.0
(4, 3)
['produkt', 'kusy', 'cena']

shape je stejný jako v NumPy: počet řádků a sloupců. Na neznámou tabulku se vždycky nejdřív podívej. Tyhle čtyři příkazy ti ušetří spoustu překvapení:

  • head() ukáže prvních pár řádků (tail() poslední),
  • dtypes řekne typ každého sloupce,
  • info() shrne sloupce, typy a počet vyplněných hodnot,
  • describe() spočítá základní statistiky číselných sloupců.
import pandas as pd

df = pd.DataFrame({
    "produkt": ["káva", "čaj", "kakao", "džus"],
    "kusy": [120, 80, 30, 45],
    "cena": [65.0, 45.0, 55.0, 50.0],
})

print(df.head(2))
print(df.dtypes)
df.info()
print(df.describe())
Výstup
  produkt  kusy  cena
0    káva   120  65.0
1     čaj    80  45.0
produkt     object
kusy         int64
cena       float64
dtype: object
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 4 entries, 0 to 3
Data columns (total 3 columns):
 #   Column   Non-Null Count  Dtype
---  ------   --------------  -----
 0   produkt  4 non-null      object
 1   kusy     4 non-null      int64
 2   cena     4 non-null      float64
dtypes: float64(1), int64(1), object(1)
memory usage: 152.0+ bytes
             kusy       cena
count    4.000000   4.000000
mean    68.750000  53.750000
std     40.078049   8.539126
min     30.000000  45.000000
25%     41.250000  48.750000
50%     62.500000  52.500000
75%     90.000000  57.500000
max    120.000000  65.000000

V describe je count počet hodnot, mean průměr, std směrodatná odchylka a 50% medián, tedy prostřední hodnota.

Kvíz

Co je DataFrame?

Výběr sloupců a řádků

Jedny hranaté závorky s názvem vrátí jeden sloupec jako Series. Se seznamem názvů, tedy dvojitými závorkami, dostaneš menší tabulku.

import pandas as pd

df = pd.DataFrame({
    "produkt": ["káva", "čaj", "kakao", "džus"],
    "kusy": [120, 80, 30, 45],
    "cena": [65.0, 45.0, 55.0, 50.0],
})

print(df["kusy"])
print(type(df["kusy"]).__name__)
print(df[["produkt", "cena"]])
print(type(df[["produkt", "cena"]]).__name__)
print(df["kusy"].max())
Výstup
0    120
1     80
2     30
3     45
Name: kusy, dtype: int64
Series
  produkt  cena
0    káva  65.0
1     čaj  45.0
2   kakao  55.0
3    džus  50.0
DataFrame
120

Na řádky jsou dva nástroje a je dobré je nemíchat:

  • loc vybírá podle jmenovek indexu a názvů sloupců,
  • iloc vybírá podle pozice, jako by šlo o pole NumPy.

Aby byl rozdíl vidět, nastavíme sloupec produkt jako index přes set_index.

import pandas as pd

df = pd.DataFrame({
    "produkt": ["káva", "čaj", "kakao", "džus"],
    "kusy": [120, 80, 30, 45],
    "cena": [65.0, 45.0, 55.0, 50.0],
}).set_index("produkt")

print(df.loc["čaj"])
print(df.loc["čaj", "cena"])
print(df.loc["čaj":"kakao"])     # včetně kakaa
print(df.iloc[0])
print(df.iloc[0:2])              # bez řádku na pozici 2
print(df.iloc[1, 0])
Výstup
kusy    80.0
cena    45.0
Name: čaj, dtype: float64
45.0
         kusy  cena
produkt
čaj        80  45.0
kakao      30  55.0
kusy    120.0
cena     65.0
Name: káva, dtype: float64
         kusy  cena
produkt
káva      120  65.0
čaj        80  45.0
80
Kvíz

Index tabulky je a, b, c, d. Kolik řádků vrátí df.loc["a":"c"] a kolik df.iloc[0:2]?

Nové sloupce a řazení

Nový sloupec vznikne přiřazením. Počítá se po celých sloupcích, stejně jako v NumPy, takže cyklus nepotřebuješ. sort_values řadí a df[podmínka] vybírá řádky. Filtrováním se do hloubky zabývá další lekce, tady stačí základ.

import pandas as pd

df = pd.DataFrame({
    "produkt": ["káva", "čaj", "kakao", "džus"],
    "kusy": [120, 80, 30, 45],
    "cena": [65.0, 45.0, 55.0, 50.0],
})

df["trzba"] = df["kusy"] * df["cena"]
print(df)

print(df.sort_values("trzba", ascending=False))
print(df[df["kusy"] > 50])
print(df["trzba"].sum())
print(df.drop(columns=["cena"]).head(1))
Výstup
  produkt  kusy  cena   trzba
0    káva   120  65.0  7800.0
1     čaj    80  45.0  3600.0
2   kakao    30  55.0  1650.0
3    džus    45  50.0  2250.0
  produkt  kusy  cena   trzba
0    káva   120  65.0  7800.0
1     čaj    80  45.0  3600.0
3    džus    45  50.0  2250.0
2   kakao    30  55.0  1650.0
  produkt  kusy  cena   trzba
0    káva   120  65.0  7800.0
1     čaj    80  45.0  3600.0
15300.0
  produkt  kusy   trzba
0    káva   120  7800.0

Káva utrží 120 × 65 = 7800 Kč a celkem je to 15 300 Kč. Metody jako sort_values a drop vracejí novou tabulku a původní nechávají být. Když chceš výsledek zachovat, ulož si ho: df = df.sort_values("trzba").

Úkol

Sloupec s tržbou

Napiš funkci pridej_trzbu(df). Dostane tabulku se sloupci kusy a cena a vrátí tabulku s novým sloupcem trzba, kde je součin obou.

import pandas as pd

def pridej_trzbu(df):
    # doplň
    pass
Výstup
Úkol

Dražší než limit

Napiš funkci drazsi_nez(df, limit). Tabulka má sloupce produkt a cena. Funkce vrátí obyčejný seznam názvů produktů s cenou větší než limit, seřazený od nejdražšího.

import pandas as pd

def drazsi_nez(df, limit):
    # doplň
    pass
Výstup

Načtení CSV po česku

Reálná data obvykle přicházejí v souboru. pd.read_csv přijme cestu k souboru, nebo cokoli, co se jako soubor chová. Tady takový soubor nasimulujeme přes io.StringIO, který z textu udělá soubor v paměti.

Český Excel ukládá CSV se středníkem jako oddělovačem a s desetinnou čárkou. Bez nastavení by pandas celý řádek považoval za jeden sloupec. Parametry sep a decimal to spraví.

import io
import pandas as pd

text = """produkt;kusy;cena
káva;120;65,50
čaj;80;45,00
kakao;30;55,90
"""

df = pd.read_csv(io.StringIO(text), sep=";", decimal=",")
print(df)
print(df.dtypes)

print(df.to_csv(index=False, sep=";", decimal=","))
Výstup
  produkt  kusy  cena
0    káva   120  65.5
1     čaj    80  45.0
2   kakao    30  55.9
produkt     object
kusy         int64
cena       float64
dtype: object
produkt;kusy;cena
káva;120;65,5
čaj;80;45,0
kakao;30;55,9

to_csv zapisuje opačným směrem. Bez cesty vrátí text, s cestou uloží soubor. Parametr index=False zabrání tomu, aby se do souboru dostal sloupec s čísly řádků. U souborů z českého Excelu narazíš i na kódování, pak přidej encoding="cp1250".

Úkol

České CSV

Napiš funkci nacti_csv(text), která z textu ve formátu českého Excelu (středník, desetinná čárka) vytvoří DataFrame. Sloupec cena musí být číselný.

import io
import pandas as pd

def nacti_csv(text):
    # doplň
    pass
Výstup

Zarovnání podle indexu

Tady se pandas zásadně liší od NumPy. Pole sčítá podle pozice, Series podle jmenovek. Hodnoty se spárují podle indexu, i když jsou v jiném pořadí. Co protějšek nemá, dostane NaN, speciální hodnotu pro „chybí“.

import pandas as pd

leden = pd.Series({"káva": 100, "čaj": 40, "kakao": 10})
unor = pd.Series({"čaj": 50, "káva": 120, "džus": 30})

print(leden + unor)
print(leden.add(unor, fill_value=0))
Výstup
džus       NaN
kakao      NaN
káva     220.0
čaj       90.0
dtype: float64
džus      30.0
kakao     10.0
káva     220.0
čaj       90.0
dtype: float64

V prvním výpisu má káva 220 a čaj 90, ale kakao a džus jsou NaN, protože v jednom z měsíců chybí. add s fill_value=0 chybějící hodnotu nahradí nulou, takže kakao zůstane 10 a džus 30. Čísla se změní na desetinná, protože NaN je v NumPy typu float. O chybějících datech bude řeč v lekci o čištění dat.

Kvíz

Co udělá a + b, když jsou a a b dvě Series se stejnými jmenovkami v jiném pořadí?

Pod kapotou · pod kapotou: bloky, Copy-on-Write a textové sloupce

DataFrame ukládá sloupce po typech do bloků, v zásadě 2D polí NumPy (BlockManager). Operace po sloupcích jsou proto levné a iterace po řádcích drahá: iterrows staví pro každý řádek novou Series a smíchá v ní typy, takže int se může změnit na float. Když už řádky procházet musíš, použij itertuples. Přidávání stovek sloupců po jednom tabulku fragmentuje a vyvolá PerformanceWarning. Sestav je najednou a spoj přes pd.concat(axis=1).

Dlouho nebylo jasné, zda výběr vrací kopii, nebo pohled. Odtud SettingWithCopyWarning a tichá chyba u df[df.x > 0]["y"] = 1, kde se zápis ztratí v dočasném objektu. Copy-on-Write to řeší: každý výběr se chová jako kopie a data se skutečně zkopírují až při zápisu. V pandas 2.x se zapíná volbou, od pandas 3 je to jediné chování.

import pandas as pd

pd.options.mode.copy_on_write = True

df = pd.DataFrame({"a": [1, 2, 3]})
sloupec = df["a"]
sloupec.iloc[0] = 99

print(df["a"].tolist())
print(sloupec.tolist())
Výstup
[1, 2, 3]
[99, 2, 3]

Pro zápis používej jeden krok: df.loc[df["x"] > 0, "y"] = 1.

Text má v pandas 2.2 výchozí typ object, tedy pole ukazatelů na pythonní řetězce: pomalé a paměťově náročné, a navíc do něj projde cokoli. pandas 3 přešel na dedikovaný typ str. Sloupce s pár opakujícími se hodnotami převeď na category, ušetříš paměť i čas u groupby. to_numpy() je preferovaná cesta k poli před .values, ale u smíšených typů dá object a tiše zkopíruje data.