Lidsky řečeno
Bufet může ráno usmažit tisíc řízků a doufat. Potřebuje na to obří sklad a část vyhodí. Nebo kuchař usmaží řízek, až když si ho někdo objedná, podá ho okénkem a počká na dalšího hosta. Generátor je ten druhý kuchař. Hodnotu připraví, až když o ni někdo požádá, a mezi objednávkami stojí a pamatuje si, kde skončil.
Funkce, která umí počkat
Stačí, aby se v těle funkce objevilo slovo yield, a z funkce se stane generátorová funkce. Její zavolání nic nespustí. Vrátí objekt zvaný generátor, což je iterátor z minulé lekce. Kód běží až po next() a na každém yield se zastaví. Hodnotu předá ven a všechny proměnné si drží pro příště.
def odpocet():
print("startuju")
yield 3
print("pokračuju")
yield 2
print("poslední kolo")
yield 1
print("konec")
g = odpocet()
print("Zatím neběžel ani řádek:", type(g).__name__)
print(next(g))
print(next(g))
for zbytek in g:
print(zbytek)
Zatím neběžel ani řádek: generator startuju 3 pokračuju 2 poslední kolo 1 konec
Rozdíl proti return: ten funkci ukončí a její proměnné zahodí. yield ji jen uspí. Když tělo dojede do konce, generátor sám vyhodí StopIteration a for skončí.
Proto generátor nahradí celou třídu s __iter__ a __next__. Stav, který jsi musel ukládat do self, teď drží obyčejné lokální proměnné.
def odpocet(start):
while start > 0:
yield start
start -= 1
class Playlist:
def __init__(self, skladby):
self.skladby = list(skladby)
def __iter__(self):
for skladba in self.skladby:
yield f"♪ {skladba}"
print(list(odpocet(3)))
playlist = Playlist(["Intro", "Refrén"])
print(list(playlist))
print(list(playlist))
[3, 2, 1] ['♪ Intro', '♪ Refrén'] ['♪ Intro', '♪ Refrén']
Všimni si Playlist. Metoda __iter__ je generátorová funkce, takže každé iter() vyrobí nový generátor. Objekt jde proto procházet opakovaně, a to bez druhé třídy.
Nekonečný Fibonacci
Napiš generátorovou funkci fibonacci(), která donekonečna vydává Fibonacciho čísla: 0, 1, 1, 2, 3, 5, 8, .... Každé další je součet dvou předchozích.
def fibonacci():
# doplň
pass
Líně znamená až když je potřeba
Seznam spočítá všechno hned. Generátor nedělá nic, dokud si někdo neřekne. Pro krátké věci existuje generátorový výraz: vypadá jako list comprehension, jen má kulaté závorky.
def drahy_vypocet(x):
print(" počítám", x)
return x * x
print("seznam:")
hned = [drahy_vypocet(x) for x in range(3)]
print("seznam hotov")
print("generátor:")
pozdeji = (drahy_vypocet(x) for x in range(3))
print("generátor hotov, nic se nepočítalo")
print(next(pozdeji))
seznam: počítám 0 počítám 1 počítám 2 seznam hotov generátor: generátor hotov, nic se nepočítalo počítám 0 0
Z toho plynou dvě výhody. První je paměť: generátor drží jen svůj aktuální stav, ať je dat kolik chce. Druhá je možnost skončit dřív. any se zastaví u první shody a zbytek se vůbec nespočítá.
import sys
seznam = [x for x in range(100_000)]
generator = (x for x in range(100_000))
print("seznam je víc než 100× větší:", sys.getsizeof(seznam) > 100 * sys.getsizeof(generator))
print(sum(x * x for x in range(1_000_000)))
zkontrolovano = []
def je_velke(x):
zkontrolovano.append(x)
return x > 2
print(any(je_velke(x) for x in range(1_000_000)))
print("zkontrolováno prvků:", len(zkontrolovano))
seznam je víc než 100× větší: True 333332833333500000 True zkontrolováno prvků: 4
Když je generátorový výraz jediným argumentem funkce, druhé závorky odpadají, proto sum(x * x for x in ...).
Protože se nic nepočítá dopředu, může být generátor i nekonečný. Jen si z něj musíš vzít omezené množství, třeba přes islice z modulu itertools.
from itertools import islice
def cisla_objednavek(start=1000):
cislo = start
while True:
yield f"OBJ-{cislo}"
cislo += 1
print(list(islice(cisla_objednavek(), 3)))
['OBJ-1000', 'OBJ-1001', 'OBJ-1002']
Co udělá řádek g = (print(x) for x in range(3))?
Generátorový výraz jen vznikne. print se zavolá, až si někdo vyžádá hodnotu přes next nebo cyklus.
Po dávkách
Napiš generátor po_davkach(data, velikost), který z libovolného iterable vydává seznamy o délce velikost. Poslední dávka může být kratší, prázdná dávka se nevydává. Musí pracovat průběžně: nesmí si předem načíst všechna data do paměti.
def po_davkach(data, velikost):
# doplň
yield list(data)
Potrubí: malé kroky za sebou
Tady se generátory vyplatí nejvíc. Každý krok čte z předchozího a vydává do dalšího, jako trubky spojené za sebou. Každý kus dat projde celým potrubím dřív, než se začne číst další.
log ──> precti ──> jen_chyby ──> zprava ──> ty
^ │
└───────── táhne po jednom ────────┘Tah vychází od konce. Ty požádáš poslední krok, ten si řekne předchozímu a tak dál.
def precti(radky):
for radek in radky:
print(" čtu:", radek)
yield radek
def jen_chyby(radky):
for radek in radky:
if radek.startswith("ERROR"):
yield radek
def zprava(radky):
for radek in radky:
yield radek.split(" ", 1)[1]
log = ["INFO start", "ERROR disk plný", "INFO ok", "ERROR síť spadla", "INFO konec"]
potrubi = zprava(jen_chyby(precti(log)))
print("první problém:", next(potrubi))
print("druhý problém:", next(potrubi))
čtu: INFO start čtu: ERROR disk plný první problém: disk plný čtu: INFO ok čtu: ERROR síť spadla druhý problém: síť spadla
Poslední řádek logu se nepřečetl, protože ho nikdo nepotřeboval. Stejný kód by tedy zvládl soubor o stovkách gigabajtů: otevřený soubor je iterátor přes řádky, takže místo seznamu log předáš jeho objekt a v paměti bude vždy jen pár řádků.
yield from: předej to dál
Když chce generátor vydat všechno z jiného iterable, nemusí psát cyklus. Stačí yield from. Nejvíc se to hodí u rekurze, tedy u dat, která jsou zanořená do sebe.
def soubory(slozka, cesta=""):
for nazev, obsah in slozka.items():
plna_cesta = f"{cesta}/{nazev}"
if isinstance(obsah, dict):
yield from soubory(obsah, plna_cesta)
else:
yield plna_cesta
disk = {
"readme.txt": 12,
"fotky": {"pes.jpg": 300, "2026": {"hory.jpg": 500}},
}
for cesta in soubory(disk):
print(cesta)
/readme.txt /fotky/pes.jpg /fotky/2026/hory.jpg
Rozbal zanořené seznamy
Napiš generátor rozbal(data), který projde libovolně zanořené seznamy a vydá všechny prvky, které samy seznamem nejsou. Řetězce se nerozkládají. list(rozbal([1, [2, [3]], "ab"])) dá [1, 2, 3, "ab"].
def rozbal(data):
for prvek in data:
yield prvek
Generátor, který poslouchá a uklízí
Generátor umí víc než vydávat hodnoty. Metoda send(hodnota) ho probudí a vloží hodnotu na místo, kde stojí yield. Poprvé ho ale musíš rozjet přes next(), aby k prvnímu yield vůbec došel.
def klouzavy_prumer():
soucet = 0
pocet = 0
prumer = None
while True:
hodnota = yield prumer
soucet += hodnota
pocet += 1
prumer = soucet / pocet
p = klouzavy_prumer()
next(p)
print(p.send(10))
print(p.send(20))
print(p.send(60))
10.0 15.0 30.0
Metoda close() generátor ukončí. Na místě, kde spí, v něm vznikne výjimka GeneratorExit, takže se provede finally. Díky tomu může generátor bezpečně držet otevřený zdroj.
def zaznamy():
print("otevírám spojení")
try:
yield "první"
yield "druhý"
finally:
print("zavírám spojení")
g = zaznamy()
print(next(g))
g.close()
print("po close")
otevírám spojení první zavírám spojení po close
Generátor uložený v proměnné g čeká na yield uvnitř try/finally. Cyklus for x in g: skončil přes break. Kdy se provede finally?
break jen opustí cyklus, generátor dál spí a klidně ho můžeš číst dál. finally proběhne při zavření nebo úklidu objektu. Na úklid se nespoléhej a použij close(), případně contextlib.closing.
Pod kapotou · kde generátor bydlí
Běžné volání má rámec na zásobníku interpretu a po návratu zmizí. Generátor má od Pythonu 3.11 interpretační rámec přímo ve vlastním objektu na haldě. yield si uloží pozici instrukce a vrátí se volajícímu, next rámec znovu napojí. Proto přepnutí nic nekopíruje a stav jde prohlížet za běhu.
import inspect
def g():
x = 1
yield x
x = 2
yield x
it = g()
print(inspect.getgeneratorstate(it))
next(it)
print(inspect.getgeneratorstate(it), it.gi_frame.f_locals)
list(it)
print(inspect.getgeneratorstate(it), it.gi_frame)
GEN_CREATED
GEN_SUSPENDED {'x': 1}
GEN_CLOSED NoneGenerátor není zadarmo. Každý krok je pozastavení a obnovení rámce, takže když se data do paměti pohodlně vejdou a procházíš je celá, bývá sum([... for ...]) rychlejší než varianta s generátorem. Od 3.12 se navíc comprehension vkládá přímo do volající funkce (PEP 709), generátorové výrazy ne. Měř, netipuj.
Pod kapotou · pasti z produkce
StopIteration uvnitř generátoru. Holé next() v těle generátoru dřív tiše ukončilo celý generátor a data mizela bez chyby. Od 3.7 (PEP 479) se taková výjimka změní na RuntimeError. Hodnota z return v generátoru cestuje v StopIteration.value a právě ji vrací výraz yield from (PEP 380).
Generátor není bezpečný pro vlákna. Když ho rozběhneš podruhé, zatímco běží, dostaneš ValueError. Stačí k tomu i rekurze.
Vazba v generátorovém výrazu. Iterable v prvním for se vyhodnotí hned, všechno ostatní až při čtení.
def vadny():
yield 1
yield next(iter([]))
try:
print(list(vadny()))
except RuntimeError as chyba:
print("RuntimeError:", chyba)
def vnitrni():
yield "a"
return "hotovo"
def vnejsi():
vysledek = yield from vnitrni()
yield vysledek
print(list(vnejsi()))
def sam_sebe():
yield next(it)
it = sam_sebe()
try:
next(it)
except ValueError as chyba:
print("ValueError:", chyba)
limit = 2
cisla = [1, 2, 3, 4]
vybrane = (x for x in cisla if x > limit)
limit = 3
cisla = [100]
print(list(vybrane))
RuntimeError: generator raised StopIteration ['a', 'hotovo'] ValueError: generator already executing [4]
Poslední výsledek je [4]: seznam se vzal ten původní, ale limit až ten aktuální. Generátor uvnitř finally při zavírání nesmí znovu udělat yield, jinak dostaneš RuntimeError: generator ignored GeneratorExit. Úklid přes finally také závisí na tom, kdy objekt zanikne: v CPythonu to díky počítání referencí bývá hned, v PyPy až při běhu garbage collectoru. Na dávkování máš od 3.12 hotové itertools.batched, které vydává n-tice. A itertools.tee si v paměti drží všechno, co jedna větev přečetla dřív než druhá, takže úspora paměti může potichu zmizet.
Vyzkoušej si: Generátor krok za krokem
Každé volání next probudí generátor do dalšího yield. Vidíš, kde je pozastavený a co vrátil.