Wat zijn generatoren en het yield-sleutelwoord?

Question

Accepted Answer

A **generator** is een functie die waarden **luikaardig, één per keer** produceert, met behulp van het `yield`-sleutelwoord in plaats van `return`. Het berekent elke waarde op aanvraag in plaats van het hele resultaat in het geheugen in te bouwen — ideaal voor grote of oneindige reeksen.

## 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` **pauzeert** de functie, retourneert een waarde en **herneemt** vanaf dat exacte punt bij de volgende iteratie — waarbij de lokale status tussen waarden behouden blijft. Niets wordt berekend totdat dit wordt gevraagd.

## Het geheugenvoordeel

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

Voor grote gegevens houdt een generator het geheugen vlak; een lijstbegrip materialiseert alles tegelijk.

## Oneindige reeksen (onmogelijk met een lijst)

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

Omdat waarden op aanvraag worden geproduceerd, kan een generator een *oneindige* stroom vertegenwoordigen — je neemt alleen wat je nodig hebt.

## Hoe iteratie onder de motorkap werkt

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

## Generatoruitdrukkingen

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

## Waarom het belangrijk is

Generatoren zijn essentieel voor **geheugenefficiënte** verwerking van grote of streaminggegevens — regel voor regel lezen van enorme bestanden, grote datasets verwerken, pijpleidingen of oneindige reeksen — waar het bouwen van een volledige lijst het geheugen zou uitputten.

Het begrijpen van `yield` (pauzeren/hervatten met behouden status) en lazy evaluatie stelt u in staat schaalbare gegevensverwerkingscode te schrijven, en generatoruitdrukkingen bieden hetzelfde voordeel beknopt.

Ze zijn een belangrijk hulpmiddel wanneer gegevens te groot zijn voor het geheugen of wanneer u items wilt verwerken naarmate zij worden geproduceerd in plaats van alles vooraf.