Co jsou generátory a klíčové slovo yield?

Question

Accepted Answer

**Generátor** je funkce, která produkuje hodnoty **líně, jednu po druhé**, pomocí klíčového slova `yield` místo `return`. Počítá každou hodnotu na vyžádání spíše než vytváření celého výsledku v paměti — ideální pro velké nebo nekonečné sekvence.

## yield vs return

```python
# a regular function builds the WHOLE list in memory
def get_squares(n):
    return [i ** 2 for i in range(n)]   # all n values created at once

# a generator yields values ONE AT A TIME, on demand
def gen_squares(n):
    for i in range(n):
        yield i ** 2                     # pause here, return one value, resume on next()

for sq in gen_squares(1_000_000):        # uses almost NO memory
    print(sq)
```

`yield` **pozastaví** funkci, vrátí hodnotu a **obnoví** z přesného místa při další iteraci — zachovává lokální stav mezi hodnotami. Nic se nepočítá, dokud není požadováno.

## Výhoda paměti

```python
sum(i ** 2 for i in range(10_000_000))   # generator expression — constant memory
sum([i ** 2 for i in range(10_000_000)]) # list — builds a huge list first (wasteful)
```

Pro velká data udržují generátory paměť nízkou; list comprehension materializuje vše najednou.

## Nekonečné sekvence (nemožné se seznamem)

```python
def count_up():
    n = 0
    while True:        # infinite — but lazy, so it's fine
        yield n
        n += 1

gen = count_up()
next(gen)   # 0
next(gen)   # 1  — only computes when asked
```

Protože se hodnoty produkují na vyžádání, generátor může reprezentovat *nekonečný* stream — beretes jen to, co potřebujete.

## Jak iterace funguje pod pokličkou

```python
gen = gen_squares(3)
next(gen)   # 0  — runs until the first yield
next(gen)   # 1  — resumes, runs to the next yield
next(gen)   # 4
next(gen)   # StopIteration — generator exhausted
```

## Výrazy generátoru

```python
(x ** 2 for x in range(10))   # like a list comprehension but lazy (parentheses)
```

## Proč je důležité

Generátory jsou nezbytné pro **paměťově efektivní** zpracování velkých nebo streamovaných dat — čtení obřích souborů řádek po řádku, zpracování velkých datových sad, potrubí nebo nekonečných sekvencí — kde vytvoření úplného seznamu by vyčerpalo paměť.

Rozdílení `yield` (zastavení/obnovení se zachovaným stavem) a líného vyhodnocování vám umožňuje psát škálovatelný kód pro zpracování dat a výrazy generátoru poskytují stejnou výhodu stručně.

Jde o klíčový nástroj vždy, když jsou data příliš velká na to, aby se vešla do paměti, nebo když chcete zpracovávat položky tak, jak se produkují, spíše než všechno předem.