Was sind Generatoren und das yield-Schlüsselwort?

Question

Accepted Answer

Ein **Generator** ist eine Funktion, die Werte **faul, einzeln nacheinander** mithilfe des `yield`-Schlüsselworts statt `return` erzeugt. Sie berechnet jeden Wert bei Bedarf, statt das gesamte Ergebnis im Speicher zu konstruieren — ideal für große oder unendliche Sequenzen.

## 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` **unterbricht** die Funktion, gibt einen Wert zurück und **setzt** bei der nächsten Iteration an der gleichen Stelle fort — behält lokalen Zustand zwischen Werten bei. Nichts wird berechnet, bis es angefordert wird.

## Der Speichervorteil

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

Bei großen Daten halten Generatoren den Speicherverbrauch niedrig; ein List Comprehension materialisiert alles auf einmal.

## Unendliche Sequenzen (mit einer Liste unmöglich)

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

Da Werte bei Bedarf erzeugt werden, kann ein Generator einen *unendlichen* Stream darstellen — Sie nehmen einfach nur das, was Sie benötigen.

## Wie Iteration unter der Haube funktioniert

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

## Generator-Ausdrücke

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

## Warum es wichtig ist

Generatoren sind unverzichtbar für **speichereffiziente** Verarbeitung großer oder gestreamer Daten — Auslesen großer Dateien Zeile für Zeile, Verarbeitung großer Datenmengen, Pipelines oder unendlicher Sequenzen — wo die Konstruktion einer kompletten Liste den Speicher erschöpfen würde.

Das Verständnis von `yield` (Unterbrechen/Fortsetzen mit erhaltenstem Zustand) und Lazy Evaluation ermöglicht es Ihnen, skalierbaren Datenverarbeitungscode zu schreiben, und Generator-Ausdrücke bieten den gleichen Vorteil prägnant.

Sie sind ein wichtiges Werkzeug, wann immer Daten zu groß für den Speicher sind oder Sie Elemente verarbeiten möchten, während sie erzeugt werden, statt alles im Voraus.