Hva er generatorer og yield-nøkkelordet?

Question

Accepted Answer

En **generator** er en funksjon som produserer verdier **lat, en av gangen**, ved å bruke `yield`-nøkkelordet i stedet for `return`. Den beregner hver verdi on demand i stedet for å bygge hele resultatet i minnet — ideelt for 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** funksjonen, returnerer en verdi, og **gjenopptar** fra akkurat det punktet på neste iterasjon — og bevarer lokal tilstand mellom verdier. Ingenting beregnes før det blir forespurt.

## Minnefordelen

```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 minnet flatt; en listeforståelse materialiserer alt på en gang.

## Uendelige sekvenser (umulig 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 verdier produseres on demand, kan en generator representere en *uendelig* strøm — du tar bare det du trenger.

## Hvordan iterasjon fungerer under panseret

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

## Generatoruttrykk

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

## Hvorfor det betyr noe

Generatorer er essensielle for **minneeffektiv** prosessering av store eller strømmende data — lesing av enorme filer linje for linje, prosessering av store datasett, rørledninger, eller uendelige sekvenser — der bygging av en fullstendig liste ville uttømme minnet.

Å forstå `yield` (pause/gjenoppta med bevart tilstand) og lat evaluering lar deg skrive skalerbar dataprosesseringskode, og generatoruttrykk gir samme fordel kortfattet.

De er et nøkkelverktøy når data er for stor til å passe i minnet eller du vil prosessere elementer etter hvert som de produseres i stedet for alt på forhånd.