Hvad er generatorer og yield-nøgleordet?

Question

Accepted Answer

En **generator** er en funktion, der producerer værdier **dovent, én ad gangen**, ved hjælp af `yield`-nøgleordet i stedet for `return`. Den beregner hver værdi på forespørgsel snarere end at bygge hele resultatet i hukommelsen — ideelt til store eller uendelige sekvenser.

## 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` **pauserer** funktionen, returnerer en værdi og **genoptager** fra det nøjagtige punkt ved næste iteration — bevarer lokal tilstand mellem værdier. Intet beregnes, før det efterspørges.

## Hukommelsesfordelen

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

For store data holder generatorer hukommelsen flad; en list comprehension materialiserer alt på én gang.

## Uendelige sekvenser (umuligt med en liste)

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

Fordi værdier produceres på forespørgsel, kan en generator repræsentere en *uendelig* stream — du tager bare hvad du har brug for.

## Hvordan iteration fungerer bag kulisserne

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

## Generatorudtryk

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

## Hvorfor det betyder noget

Generatorer er vigtige for **hukommelseseffektiv** behandling af store eller streamede data — læsning af enorme filer linje for linje, behandling af store datasæt, pipelines eller uendelige sekvenser — hvor opbygning af en komplet liste ville opbruge hukommelsen.

At forstå `yield` (pause/genoptag med bevaret tilstand) og lazy evaluation lader dig skrive skalerbar datahåndteringskode, og generatorudtryk giver samme fordel kortfattet.

Det er et nøgleværktøj, hver gang data er for store til at passe i hukommelsen, eller du vil behandle elementer, som de produceres, snarere end alt på forhånd.