Mitä ovat generaattorit ja yield-avainsana?

Question

Accepted Answer

**Generaattori** on funktio, joka tuottaa arvoja **laiskasti, yksi kerrallaan**, käyttäen `yield`-avainsanaa `return`-sijaan. Se laskee jokaisen arvon pyynnöstä sen sijaan, että rakentaisi koko tuloksen muistiin — ihanteellinen suurille tai äärettömille sarjoille.

## 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` **keskeyttää** funktion, palauttaa arvon ja **jatkaa** täsmälleen samasta pisteestä seuraavassa iteraatiossa — säilyttäen paikallisen tilan arvojen välillä. Mitään ei lasketa, ennen kuin sitä pyydetään.

## Muistin etu

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

Suurille tiedoille generaattorit pitävät muistin tasaisena; listan ymmärtäminen konkretisoituu kaiken kerran.

## Äärettömät sarjat (mahdotonta listan kanssa)

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

Koska arvot tuotetaan pyynnöstä, generaattori voi edustaa *ääretöntä* virtaa — otat vain mitä tarvitset.

## Kuinka iteraatio toimii taustalla

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

## Generaattorlausekkeet

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

## Miksi se on tärkeää

Generaattorit ovat välttämättömiä **muistin tehokkaan** käsittelyn kannalta suurten tai virtaviivaisten tietojen kanssa — valtavien tiedostojen lukeminen rivi kerrallaan, suurten tietojoukkojen käsittely, putkistot tai äärettömät sarjat — joissa täydellisen listan rakentaminen kuluttaisi muistin.

Ymmärtäminen `yield`-sanasta (pysäytys/jatkaminen säilytetyn tilan kanssa) ja laiskasta arvioinnista antaa sinulle mahdollisuuden kirjoittaa skaalautuvaa tietojenkäsittelykoodia, ja generaattorlausekkeet tarjoavat saman edun tiiviisti.

Se on keskeinen työkalu aina, kun tiedot ovat liian suuria muistiin tai haluat käsitellä kohteita niiden tuotantona sen sijaan, että kaikkea etukäteen.