Czym są generatory i słowo kluczowe yield?

Question

Accepted Answer

**Generator** to funkcja, która produkuje wartości **leniwą, jedną na raz**, używając słowa kluczowego `yield` zamiast `return`. Oblicza każdą wartość na żądanie, a nie buduje cały wynik w pamięci — idealne dla dużych lub nieskończonych sekwencji.

## 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` **wstrzymuje** funkcję, zwraca wartość i **wznawia** z dokładnie tego samego punktu w następnej iteracji — zachowując stan lokalny między wartościami. Nic nie jest obliczane, dopóki nie zostanie zażądane.

## Korzyść pamięciowa

```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)
```

Dla dużych danych generatory utrzymują pamięć płaską; wyrażenie listowe materializuje wszystko naraz.

## Sekwencje nieskończone (niemożliwe z listą)

```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
```

Ponieważ wartości są produkowane na żądanie, generator może reprezentować *nieskończony* strumień — bierzesz tylko to, czego potrzebujesz.

## Jak iteracja działa pod maską

```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
```

## Wyrażenia generatorowe

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

## Dlaczego to ważne

Generatory są niezbędne dla **efektywnego pamięciowo** przetwarzania dużych lub przesyłanych danych — czytania ogromnych plików linia po linii, przetwarzania dużych zbiorów danych, potoków lub nieskończonych sekwencji — gdzie budowanie pełnej listy wyczerpałoby pamięć.

Zrozumienie `yield` (wstrzymanie/wznowienie z zachowanym stanem) i leniwej ewaluacji pozwala napisać skalowalny kod przetwarzania danych, a wyrażenia generatorowe dają tę samą korzyść zwięźle.

Są to kluczowe narzędzie, gdy dane są zbyt duże, aby zmieściły się w pamięci, lub chcesz przetwarzać elementy w miarę ich produkcji, a nie wszystkie na początku.