0 dní v řadě · 0 bodů

Užitečné knihovny · 22 min

random, math a statistics

Losování a simulace, zaokrouhlování, kombinatorika a průměr, medián i odchylka. Tři knihovny, které máš v Pythonu rovnou k dispozici.

Hloubka
Úkoly
Lidsky řečeno

Představ si tlustou knihu, ve které jsou jen čísla bez jakéhokoli řádu. Kdo ji čte, má dojem, že jde o náhodu. Kdo ale otevře stejnou stranu, přečte přesně stejná čísla. Tak funguje náhoda v počítači. Kniha je generátor a číslo strany se jmenuje seed, česky semínko.

Náhodná čísla

Modul random umí vyrobit číslo několika způsoby. Řádek random.seed(42) nastaví semínko, takže ukázka dá pokaždé stejný výsledek. Ve hře bys ho vynechal a Python by si semínko vybral sám.

import random

random.seed(42)

print(random.random())          # desetinné číslo od 0 do 1, bez jedničky
print(random.randint(1, 6))     # celé číslo od 1 do 6, včetně šestky
print(random.randrange(0, 10))  # jako range: desítka nepadne
print(round(random.uniform(10, 20), 2))  # desetinné číslo mezi 10 a 20
Výstup
0.6394267984578837
1
4
12.45

Dávej pozor na meze. randint(1, 6) zahrnuje obě krajní hodnoty, zatímco randrange(1, 6) se chová jako range a šestku nikdy nevrátí.

Semínko se hodí pro testy a pro opakovatelné pokusy. Pokud potřebuješ několik nezávislých proudů náhody, vytvoř si vlastní generátory přes random.Random.

import random

random.seed(2026)
prvni = [random.randint(1, 100) for _ in range(5)]
random.seed(2026)
druhy = [random.randint(1, 100) for _ in range(5)]
print(prvni)
print(prvni == druhy)

kostka = random.Random(1)
pocasi = random.Random(2)
print(kostka.randint(1, 6), pocasi.randint(1, 6))
print(kostka.randint(1, 6), pocasi.randint(1, 6))
Výstup
[16, 41, 65, 66, 83]
True
2 1
5 1

Losování ze seznamu

Na výběr ze seznamu jsou čtyři funkce. Liší se tím, jestli se prvek může opakovat a jestli se mění původní seznam.

FunkceCo děláOpakování
choice(seznam)vybere jeden prveknemá smysl
choices(seznam, k=3)vybere víc prvků, jako by se losy vracely do kloboukuano
sample(seznam, k=3)vybere víc různých pozic, los se nevracíne
shuffle(seznam)zamíchá přímo daný seznamne
import random

random.seed(5)
menu = ["svíčková", "guláš", "řízek", "smažák"]

print(random.choice(menu))
print(random.choices(menu, k=6))
print(random.sample(menu, k=2))

print(random.choices(["výhra", "nic"], weights=[1, 9], k=10))

balicek = [1, 2, 3, 4, 5, 6, 7, 8]
vysledek = random.shuffle(balicek)
print(balicek)
print(vysledek)
Výstup
řízek
['řízek', 'smažák', 'smažák', 'řízek', 'smažák', 'svíčková']
['smažák', 'svíčková']
['nic', 'nic', 'nic', 'nic', 'nic', 'nic', 'nic', 'výhra', 'nic', 'nic']
[5, 3, 6, 4, 8, 1, 2, 7]
None

Náhoda je skvělá na otázky, u kterých se nechce počítat. Jak často padne na dvou kostkách který součet? Prostě to deset tisíckrát vyzkoušíš. Takovému postupu se říká simulace.

import random
from collections import Counter

rng = random.Random(7)
soucty = Counter(rng.randint(1, 6) + rng.randint(1, 6) for _ in range(10_000))

for soucet in range(2, 13):
    pocet = soucty[soucet]
    print(f"{soucet:>2} {pocet:>5} {'#' * (pocet // 50)}")
Výstup
 2   278 #####
 3   565 ###########
 4   855 #################
 5  1119 ######################
 6  1382 ###########################
 7  1700 ##################################
 8  1391 ###########################
 9  1061 #####################
10   826 ################
11   517 ##########
12   306 ######

Sedmička vyhrává, protože jde složit nejvíc způsoby: 1+6, 2+5, 3+4 a obráceně.

Úkol

Tisíc hodů

Vytvoř seznam hody s tisícem hodů šestistěnnou kostkou. Do sestky ulož, kolikrát padla šestka. Nejdřív nastav semínko 7.

import random

random.seed(7)
hody = []
sestky = 0
Výstup
Kvíz

Vybíráš tři výherce z deseti lidí a nikdo nesmí vyhrát dvakrát. Kterou funkci použiješ?

math: čísla do detailu

Modul math přidává funkce, které běžné operátory neumí. Začni zaokrouhlováním, protože tady se chybuje nejvíc.

import math

print(math.floor(2.7), math.ceil(2.1), math.trunc(2.7))
print(math.floor(-2.7), math.ceil(-2.1), math.trunc(-2.7))
print(round(2.5), round(3.5), round(2.567, 1))
Výstup
2 3 2
-3 -2 -2
2 4 2.6
  • floor zaokrouhluje vždy dolů, tedy k menšímu číslu. Z -2.7 proto udělá -3.
  • ceil zaokrouhluje vždy nahoru.
  • trunc jen uřízne desetinnou část.
  • Vestavěné round jde k nejbližšímu číslu, a když je přesně uprostřed, vybere sudé. Proto round(2.5) dá 2. Říká se tomu bankéřské zaokrouhlování.

Desetinná čísla jsou v počítači uložená jen přibližně, takže je neporovnávej přes ==. K tomu slouží isclose.

import math

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)
print(math.isclose(0.1 + 0.2, 0.3))

print(math.isclose(1e-12, 0))
print(math.isclose(1e-12, 0, abs_tol=1e-9))

soucet = 0.0
for cislo in [0.1] * 10:
    soucet += cislo
print(soucet)
print(sum([0.1] * 10))
print(math.fsum([0.1] * 10))
Výstup
0.30000000000000004
False
True
False
True
0.9999999999999999
1.0
1.0

Porovnání s nulou potřebuje abs_tol. Výchozí tolerance je totiž poměrná, a poměr vůči nule je nula.

Dál tu najdeš geometrii, mocniny a kombinatoriku. Hodnoty z logaritmů a goniometrie v ukázce zaokrouhlujeme, poslední číslice se může na různých systémech lišit.

import math

print(math.sqrt(2))
print(math.hypot(3, 4))
print(math.dist((1, 1), (4, 5)))
print(f"{math.sin(math.radians(30)):.4f}")
print(f"{math.log10(1000):.4f}  {math.log2(1024):.4f}")

print(math.factorial(5))
print(math.gcd(84, 36), math.lcm(4, 6))

print(math.comb(49, 6))
print(math.perm(10, 3))

velke = (10**20 + 1) ** 2
print(math.isqrt(velke))
print(int(math.sqrt(velke)))
Výstup
1.4142135623730951
5.0
5.0
0.5000
3.0000  10.0000
120
12 12
13983816
720
100000000000000000001
100000000000000000000

comb(49, 6) říká, kolika způsoby lze vybrat 6 čísel ze 49, když nezáleží na pořadí. Přesně tolik je možných tipů v loterii tohoto typu. Poslední dva řádky ukazují, proč u obřích celých čísel patří isqrt: běžná sqrt přejde na desetinné číslo a poslední jednička se ztratí.

Některé výpočty nemají výsledek. Python pak nevrátí nesmysl, ale ozve se.

import math

print(math.sqrt(16))
print(math.sqrt(-1))
Výstup
4.0
Úkol

Kolik balení koupit

Napiš funkci pocet_baleni(kusu, v_baleni), která vrátí, kolik celých balení musíš koupit, abys měl aspoň kusu kusů. Na 25 vajec po desíti potřebuješ 3 balení.

import math

def pocet_baleni(kusu, v_baleni):
    return 0
Výstup
Kvíz

Co vrátí math.floor(-1.5)?

statistics: co čísla říkají

Průměr je nejznámější údaj a zároveň nejsnáz oklame. Stačí jedna extrémní hodnota. Podívej se na platy v malé firmě, kde poslední řádek patří majiteli.

import statistics as st

platy = [32000, 35000, 36000, 38000, 41000, 250000]

print(st.mean(platy))
print(st.median(platy))
print(st.median(platy[:-1]))
print(st.mean(platy[:-1]))
Výstup
72000
37000.0
36000
36400

Průměr (mean) je součet dělený počtem. Medián (median) je prostřední hodnota po seřazení. Plat majitele zvedl průměr z 36 400 na 72 000, medián se posunul jen z 36 000 na 37 000. Když čteš „průměrnou mzdu“, ptej se i na medián.

Dalšími užitečnými údaji jsou nejčastější hodnota a rozptýlenost dat.

import statistics as st

znamky = [1, 2, 2, 3, 3, 4]
print(st.mode(znamky))
print(st.multimode(znamky))

trida_a = [70, 72, 74, 76, 78]
trida_b = [40, 60, 74, 88, 108]
print(st.mean(trida_a), st.mean(trida_b))
print(f"{st.stdev(trida_a):.2f}  {st.stdev(trida_b):.2f}")
print(f"{st.pstdev(trida_a):.2f}  {st.pstdev(trida_b):.2f}")

doba_odezvy = [12, 15, 14, 13, 90, 16, 15, 14, 13, 200]
print(st.quantiles(doba_odezvy, n=4))
Výstup
2
[2, 3]
74 74
3.16  26.00
2.83  23.26
[13.0, 14.5, 34.5]
  • Obě třídy mají stejný průměr, ale úplně jiné výsledky. To odhalí směrodatná odchylka: říká, jak daleko od průměru hodnoty typicky leží.
  • stdev použij, když máš jen vzorek z větší skupiny. pstdev, když máš všechna data.
  • quantiles(data, n=4) rozdělí seřazená data na čtvrtiny a vrátí tři hranice. Prostřední je medián.

Prázdná data nemají průměr a knihovna to řekne nahlas.

import statistics as st

print(st.mean([1, 2, 3]))
print(st.mean([]))
Výstup
2
Úkol

Rychlé shrnutí dat

Napiš funkci shrnuti(cisla), která vrátí slovník s klíči "prumer", "median" a "rozpeti". Rozpětí je rozdíl největšího a nejmenšího čísla.

import statistics as st

def shrnuti(cisla):
    return {}
Výstup

Všechny tři dohromady

Číslo pí jde odhadnout házením šipek. Ve čtverci o straně 1 leží čtvrtkruh s poloměrem 1 a jeho plocha je pi / 4. Podíl šipek, které do něj padnou, je tedy přibližně pi / 4. Pokus zopakujeme pětkrát a podíváme se, jak moc se odhady liší.

import math
import random
import statistics as st

def odhad_pi(seed, sipek=20_000):
    rng = random.Random(seed)
    uvnitr = 0
    for _ in range(sipek):
        x, y = rng.random(), rng.random()
        if x * x + y * y <= 1:
            uvnitr += 1
    return 4 * uvnitr / sipek

odhady = [odhad_pi(seed) for seed in range(5)]

print([round(o, 4) for o in odhady])
print(f"průměr  {st.mean(odhady):.4f}")
print(f"odchylka {st.stdev(odhady):.4f}")
print(f"pi      {math.pi:.4f}")
Výstup
[3.148, 3.1382, 3.1394, 3.138, 3.1452]
průměr  3.1418
odchylka 0.0046
pi      3.1416

Této metodě se říká Monte Carlo a používá se všude tam, kde je přesný výpočet moc složitý. Přesnost roste pomalu: na desetkrát menší chybu potřebuješ zhruba stokrát víc pokusů.

Pod kapotou · random: Mersenne Twister a co se o něm neví

random používá MT19937 se stavem 624 slov po 32 bitech a periodou 2**19937 - 1. Není kryptograficky bezpečný: z 624 po sobě jdoucích výstupů getrandbits(32) jde stav spočítat a předpovědět vše další. Na tokeny patří secrets, viz další lekce.

Záruka reprodukovatelnosti je užší, než se čeká. Dokumentace slibuje stabilní sekvenci hlavně pro random(). Algoritmy nad ním, například randrange, shuffle nebo sample, se mezi verzemi Pythonu měnit mohou, takže snapshot test postavený na shuffle může po upgradu spadnout. U ML pokusů si proto zaznamenávej i verzi interpreteru.

Perioda neznamená dostatek permutací. 2081! je větší než 2**19937, takže u delších seznamů shuffle většinu pořadí nikdy nevyrobí. Prakticky to obvykle nevadí, ale je to dobrý důvod nepovažovat výstup za rovnoměrný nad celým prostorem.

Funkce na úrovni modulu jsou metody jedné skryté instance Random, sdílené celým procesem i knihovnami. Pokus s vlastní instancí je proto izolovaný, zatímco random.seed ovlivní cizí kód. Po os.fork se skrytá instance v potomkovi sama znovu nasévá díky os.register_at_fork. Vlastní instance ne, a forknutí workeři pak generují stejná čísla. seed s řetězcem používá SHA-512, takže nezávisí na PYTHONHASHSEED. Od 3.11 musí být semínko None, int, float, str, bytes nebo bytearray, a sample už nepřijímá množinu.

Pod kapotou · přesnost a výkon v math a statistics

Python 3.12 změnil sum. Pro floaty používá kompenzované sčítání Neumaierova typu, proto sum([0.1] * 10) dává 1.0, zatímco ruční smyčka ne. Kód testovaný na 3.11 se tak může v posledních bitech chovat jinak. math.fsum jde dál a vrací přesně zaokrouhlený součet, za cenu pomocné paměti.

Hranice libm. math obaluje céčkovou knihovnu. sqrt je podle IEEE 754 správně zaokrouhlená, ale sin, exp nebo log se mezi platformami mohou lišit o poslední bit, takže do testů patří isclose. math.log(x, 10) je podíl dvou logaritmů, přesnější je log10. Novější přírůstky: math.cbrt a math.exp2 (3.11), math.sumprod (3.12).

statistics počítá přesně. mean převádí hodnoty na zlomky, takže funguje s Fraction a Decimal a nezaokrouhluje průběžně, ale je výrazně pomalejší než fmean, které pracuje rovnou s floaty. Na velká data sáhni po fmean nebo NumPy.

NaN rozbije řazení. median a quantiles řadí data a porovnání s NaN je vždy nepravdivé, takže výsledek závisí na pořadí vstupu a chyba nepřijde. Před výpočtem NaN odfiltruj. quantiles má navíc method="exclusive" jako výchozí; pro data, která obsahují i krajní hodnoty celé populace, je vhodnější "inclusive". Různé nástroje používají různé definice, proto se percentily z Excelu, NumPy a statistics nemusí shodovat.