0 dní v řadě · 0 bodů

Práce s daty · 25 min

NumPy: pole a vektorizace

Naučíš se počítat s celými poli čísel bez cyklů, vybírat data podmínkou a poznáš pasti, které NumPy nikdy nenahlásí.

Hloubka
Úkoly
Lidsky řečeno

Seznam v Pythonu je taška: vejde se do ní cokoli a každou věc musíš vytáhnout zvlášť. Pole z NumPy je plato na vejce: všechny kusy jsou stejné, leží těsně vedle sebe a přeneseš je jedním pohybem. Když chceš zdražit celý ceník o desetinu, taky nepřepisuješ řádek po řádku. Napíšeš jeden vzorec na celý sloupec.

Proč nestačí seznam

NumPy je knihovna pro práci s velkým množstvím čísel. Stojí na ní pandas, scikit-learn i velká část strojového učení. Její základ je pole (anglicky array), tedy řada čísel stejného typu.

Seznam a pole vypadají podobně, ale chovají se jinak. Zkus stejnou operaci na obou.

import numpy as np

ceny_seznam = [100, 250, 40]
ceny_pole = np.array([100, 250, 40])

print(ceny_seznam * 2)
print(ceny_pole * 2)
print(ceny_pole * 1.21)
print(ceny_pole + np.array([1, 2, 3]))
Výstup
[100, 250, 40, 100, 250, 40]
[200 500  80]
[121.  302.5  48.4]
[101 252  43]

Řádek import numpy as np načte knihovnu pod zkratkou np. Tu používá prakticky každý, takže ji uvidíš i v cizím kódu.

Seznam vynásobený dvěma se zopakuje. Pole vynásobí každý prvek. Tomu se říká vektorizace: napíšeš operaci jednou a platí pro všechny prvky, žádný cyklus psát nemusíš. Kód je kratší a navíc rychlejší.

import time
import numpy as np

n = 1_000_000
seznam = list(range(n))
pole = np.arange(n)

start = time.perf_counter()
vysledek_seznam = [x * 2 for x in seznam]
cas_seznam = time.perf_counter() - start

start = time.perf_counter()
vysledek_pole = pole * 2
cas_pole = time.perf_counter() - start

print(f"seznam: {cas_seznam * 1000:.2f} ms")
print(f"pole:   {cas_pole * 1000:.2f} ms")
print(f"pole je asi {cas_seznam / cas_pole:.0f}x rychlejší")
Výstup

Přesné číslo závisí na počítači, poměr bývá výrazný. Ve vlastním projektu NumPy nainstaluješ příkazem python -m pip install numpy, tady se načte samo.

Pod kapotou · proč je pole rychlé a kdy není

ndarray je malá hlavička (ukazatel na data, dtype, shape, strides) nad souvislým blokem paměti. Seznam drží ukazatele na samostatné objekty int, každý s vlastní hlavičkou a počítadlem referencí. Univerzální funkce (ufunc) vyřeší typy jednou a pak běží ve smyčce v C, často se SIMD instrukcemi a s daty hezky v cache.

Výhoda mizí, jakmile se vrátíš do Pythonu. for x in pole bývá pomalejší než průchod seznamem, protože každý prvek se musí zabalit do nového skalárního objektu. np.vectorize je pohodlná obálka, ne zrychlení: dokumentace sama říká, že jde v zásadě o cyklus for. Pokud kód nejde vyjádřit přes ufunc, změř ho a teprve pak uvažuj o Cythonu nebo Numba.

a[::2] nic nekopíruje, jen zdvojnásobí strides, tedy skok v bajtech mezi prvky. Proto je řez konstantní operace bez ohledu na délku pole. Daň je, že výsledek už není souvislý blok a některé operace budou pomalejší.

Tvar a typ

Pole může mít víc rozměrů. Dvourozměrné pole je tabulka čísel. Tři vlastnosti řeknou skoro všechno:

  • shape je tvar: kolik prvků je v každém rozměru. U tabulky nejdřív řádky, potom sloupce.
  • ndim je počet rozměrů.
  • dtype je typ prvků. V jednom poli je typ pro všechny stejný.
import numpy as np

# dva dny, tři měření za den
teploty = np.array([
    [3.5, 7.0, 5.5],
    [2.0, 9.5, 6.0],
])

print(teploty)
print(teploty.shape)
print(teploty.ndim)
print(teploty.size)
print(teploty.dtype)

# různé typy se sjednotí
print(np.array([1, 2.5, True]))
print(np.array([1, 2.5, True]).dtype)
print(np.array([1, "dva", 3.0]))
Výstup
[[3.5 7.  5.5]
 [2.  9.5 6. ]]
(2, 3)
2
6
float64
[1.  2.5 1. ]
float64
['1' 'dva' '3.0']

Konec ukázky předvádí, co se stane, když do pole dáš různé typy. NumPy je převede na jeden společný. Čísla s desetinnou čárkou „vyhrají“ nad celými a text nad vším. Hodnoty z posledního řádku výpisu jsou pak jen písmena a počítat s nimi nejde.

Pole se málokdy píší ručně. Obvykle je vyrobí některá z těchto funkcí.

import numpy as np

print(np.zeros((2, 3)))          # samé nuly, tvar 2 × 3
print(np.ones(3))                # samé jedničky
print(np.full((2, 2), 7.5))      # samá stejná hodnota
print(np.arange(0, 10, 2))       # jako range: od, do (bez), krok
print(np.linspace(0, 1, 5))      # 5 rovnoměrných bodů včetně konce
Výstup
[[0. 0. 0.]
 [0. 0. 0.]]
[1. 1. 1.]
[[7.5 7.5]
 [7.5 7.5]]
[0 2 4 6 8]
[0.   0.25 0.5  0.75 1.  ]
Kvíz

Jaký shape má np.array([[1, 2, 3], [4, 5, 6]])?

Pod kapotou · výchozí int závisí na platformě

V NumPy 2 je výchozí celé číslo np.intp, tedy velikost ukazatele. Na 64bitovém Linuxu, macOS i Windows to je int64, ale v 32bitovém prostředí, včetně Pyodide v tomhle prohlížeči, int32. Zkus si print(np.array([1]).dtype). Ve starším NumPy 1.x měl int32 i 64bitový Windows, takže kód počítající s velkými součty fungoval na serveru a na vývojářově notebooku tiše přetékal. Kde záleží na rozsahu, piš dtype explicitně.

NEP 50 v NumPy 2 navíc změnil povyšování typů. Pythonní čísla jsou „slabá“ a přizpůsobí se poli: np.float32(3) + 3.0 zůstane float32, np.array([1], dtype=np.int8) + 200 skončí OverflowError, protože 200 se do int8 nevejde. Starší kód se mohl spoléhat na to, že se typ rozšíří podle hodnoty.

Indexy a řezy

V jednom rozměru funguje indexování stejně jako u seznamu. U tabulky píšeš do jedněch hranatých závorek řádek, čárku a sloupec. Dvojtečka znamená „všechno“.

import numpy as np

m = np.array([
    [1, 2, 3, 4],
    [5, 6, 7, 8],
    [9, 10, 11, 12],
])

print(m[0, 2])       # řádek 0, sloupec 2
print(m[1])          # celý řádek 1
print(m[:, 0])       # celý sloupec 0
print(m[0:2, 1:3])   # první dva řádky, prostřední dva sloupce
print(m[-1, -1])     # poslední řádek, poslední sloupec
Výstup
3
[5 6 7 8]
[1 5 9]
[[2 3]
 [6 7]]
12

Teď rozdíl, který stojí lidi hodiny ladění. Řez seznamu vyrobí kopii. Řez pole je jen pohled (view): jiné okno do stejných dat. Změníš-li něco přes pohled, změní se i původní pole.

import numpy as np

a = np.array([1, 2, 3, 4, 5])

pohled = a[1:4]
pohled[0] = 99
print(a)
print(pohled.base is a)

kopie = a[1:4].copy()
kopie[0] = -1
print(a)
print(kopie)
Výstup
[ 1 99  3  4  5]
True
[ 1 99  3  4  5]
[-1  3  4]
Kvíz

Co vypíše tento kód? a = np.array([1, 2, 3]), b = a[:2], b[0] = 9, print(a)

Úkol

Ceník s DPH

Napiš funkci s_dph(ceny, sazba). Dostane pole cen a sazbu jako desetinné číslo (například 0.21) a vrátí nové pole cen včetně daně. Obejdi se bez cyklu.

import numpy as np

def s_dph(ceny, sazba):
    # doplň
    pass
Výstup

Výběr podmínkou

Porovnání pole s číslem dá pole hodnot True a False. Říká se mu maska. Když masku dáš do hranatých závorek, zůstanou jen prvky, kde je True.

import numpy as np

teploty = np.array([-3.0, 2.5, 18.0, 31.0, 7.5, -1.0])

maska = teploty < 0
print(maska)
print(teploty[maska])
print(maska.sum())                                # True se počítá jako 1
print(teploty[(teploty > 0) & (teploty < 20)])    # a zároveň
print(teploty[[0, 3]])                            # seznam indexů
print(np.where(teploty < 0, 0.0, teploty))        # kde platí 0, jinde původní
Výstup
[ True False False False False  True]
[-3. -1.]
2
[ 2.5 18.   7.5]
[-3. 31.]
[ 0.   2.5 18.  31.   7.5  0. ]

Maska a seznam indexů vracejí kopii, na rozdíl od řezu. Přiřazení přes masku ale původní pole změní: teploty[teploty < 0] = 0 vynuluje záporné hodnoty přímo v něm.

Úkol

Nadprůměrné hodnoty

Napiš funkci nad_prumerem(a), která vrátí pole prvků větších než průměr pole a, v původním pořadí.

import numpy as np

def nad_prumerem(a):
    # doplň
    pass
Výstup

Souhrny a osa

Funkce jako sum, mean, min, max a std (směrodatná odchylka, říká, jak moc jsou hodnoty rozptýlené kolem průměru) umí počítat přes celé pole, nebo jen podél jedné osy. Osa je číslo rozměru: u tabulky je 0 směr řádků a 1 směr sloupců.

Pomůcka: osa, kterou zadáš, zmizí. Tabulka 3 × 4 po axis=0 zkolabuje na 4 čísla (jedno za sloupec), po axis=1 na 3 čísla (jedno za řádek).

import numpy as np

# řádky = prodejny, sloupce = dny
trzby = np.array([
    [120, 90, 150, 80],
    [200, 170, 160, 210],
    [60, 75, 40, 95],
])

print(trzby.sum())            # všechno dohromady
print(trzby.sum(axis=0))      # součet za každý den
print(trzby.sum(axis=1))      # součet za každou prodejnu
print(trzby.mean(axis=1))     # průměr za prodejnu
print(trzby.argmax(axis=1))   # index nejlepšího dne v každé prodejně
Výstup
1450
[380 335 350 385]
[440 740 270]
[110.  185.   67.5]
[2 3 3]

argmax nevrací největší hodnotu, ale její pozici. Hodí se, když chceš vědět, který řádek nebo sloupec vyhrál.

Kvíz

Pole m má tvar (5, 3). Jaký tvar má m.mean(axis=0)?

Úkol

Nejlepší prodejna

Pole trzby má v řádcích prodejny a ve sloupcích dny. Napiš funkci nejlepsi_prodejna(trzby), která vrátí index řádku s nejvyšším celkovým součtem.

import numpy as np

def nejlepsi_prodejna(trzby):
    # doplň
    pass
Výstup