Vad är generatorer och yield-nyckelordet?

Question

Accepted Answer

En **generator** är en funktion som producerar värden **långsamt, ett i taget**, genom att använda `yield`-nyckelordet istället för `return`. Den beräknar varje värde på begäran snarare än att bygga hela resultatet i minnet — perfekt för stora eller oändliga 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` **pausar** funktionen, returnerar ett värde och **återupptar** från exakt den punkten på nästa iteration — och bevarar lokal state mellan värden. Ingenting beräknas förrän det efterfrågas.

## Minnesfördelarna

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

För stora datamängder håller generatorer minnet platt; en listomfattning materialiserar allt på en gång.

## Oändliga sekvenser (omöjliga med en lista)

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

Eftersom värden produceras på begäran kan en generator representera en *oändlig* ström — du tar bara det du behöver.

## Hur iteration fungerar under huven

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

## Generatoruttryck

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

## Varför det spelar roll

Generatorer är väsentliga för **minneseffektiv** bearbetning av stora eller strömmande data — läsa enorma filer rad för rad, bearbeta stora datamängder, pipelines eller oändliga sekvenser — där att bygga en full lista skulle slösa minne.

Att förstå `yield` (pausera/återuppta med bevarad state) och lat evaluering låter dig skriva skalbar datarbearbetningskod, och generatoruttryck ger samma fördelar kortfattat.

De är ett nyckelverktyg när data är för stor för att få plats i minnet eller när du vill bearbeta objekt allt eftersom de produceras snarare än allt på förhand.