0 dní v řadě · 0 bodů

Python pod kapotou · 26 min

Generátory a líné zpracování

Naučíš se yield, generátorové výrazy a skládání kroků do potrubí, které zpracuje i obrovská data bez zaplnění paměti.

Hloubka
Úkoly
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)
Výstup
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))
Výstup
[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.

Úkol

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
Výstup

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))
Výstup
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))
Výstup
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)))
Výstup
['OBJ-1000', 'OBJ-1001', 'OBJ-1002']
Kvíz

Co udělá řádek g = (print(x) for x in range(3))?

Úkol

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)
Výstup

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ší.

text
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))
Výstup
  č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)
Výstup
/readme.txt
/fotky/pes.jpg
/fotky/2026/hory.jpg
Úkol

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
Výstup

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))
Výstup
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")
Výstup
otevírám spojení
první
zavírám spojení
po close
Kvíz

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?

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)
Výstup
GEN_CREATED
GEN_SUSPENDED {'x': 1}
GEN_CLOSED None

Generá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))
Výstup
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.