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())
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())
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())
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.000000V describe je count počet hodnot, mean průměr, std směrodatná odchylka a 50% medián, tedy prostřední hodnota.
Co je DataFrame?
Sloupce mohou mít různé typy, třeba text a čísla. V rámci jednoho sloupce je ale typ společný.
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())
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:
locvybírá podle jmenovek indexu a názvů sloupců,ilocvybí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])
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
80Index tabulky je a, b, c, d. Kolik řádků vrátí df.loc["a":"c"] a kolik df.iloc[0:2]?
loc bere konec včetně, takže a, b, c. iloc konec nezahrnuje, takže pozice 0 a 1.
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))
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").
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
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
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=","))
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".
Č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
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))
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.
Co udělá a + b, když jsou a a b dvě Series se stejnými jmenovkami v jiném pořadí?
pandas před výpočtem zarovná index. Je to užitečné, ale když čekáš chování NumPy, může tě to překvapit.
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())
[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.