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
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))
[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.
| Funkce | Co dělá | Opakování |
|---|---|---|
choice(seznam) | vybere jeden prvek | nemá smysl |
choices(seznam, k=3) | vybere víc prvků, jako by se losy vracely do klobouku | ano |
sample(seznam, k=3) | vybere víc různých pozic, los se nevrací | ne |
shuffle(seznam) | zamíchá přímo daný seznam | ne |
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)
ří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)}")
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ě.
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
Vybíráš tři výherce z deseti lidí a nikdo nesmí vyhrát dvakrát. Kterou funkci použiješ?
sample losuje bez vracení. choices i opakované choice můžou stejného člověka vybrat víckrát.
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))
2 3 2 -3 -2 -2 2 4 2.6
floorzaokrouhluje vždy dolů, tedy k menšímu číslu. Z-2.7proto udělá-3.ceilzaokrouhluje vždy nahoru.truncjen uřízne desetinnou část.- Vestavěné
roundjde k nejbližšímu číslu, a když je přesně uprostřed, vybere sudé. Protoround(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))
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)))
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))
4.0
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
Co vrátí math.floor(-1.5)?
floor jde k menšímu číslu a na číselné ose je -2 vlevo od -1.5. Uříznutí desetinné části, které by dalo -1, dělá trunc.
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]))
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))
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ží.
stdevpouž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([]))
2
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š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}")
[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.