Kas yra generatoriai ir yield raktažodis?

Question

Accepted Answer

A **generator** yra funkcija, kuri gamina reikšmes **lėtai, po vieną**, naudodama `yield` raktažodį vietoj `return`. Kiekviena reikšmė skaičiuojama pagal poreikį, o ne visa rezultatą pasiimamas atminty — idealu dideliems arba begaliniams sekoms.

## 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` **sustabdo** funkciją, grąžina reikšmę ir **tęsia** iš to paties taško kitoje iteracijoje — išsaugoma lokali būsena tarp reikšmių. Nieko neskaičiuojama, kol nėra prašoma.

## Atminties nauda

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

Dideliems duomenims generatorius išlaiko atmintį plokščią; sąrašo supratimas materijalizuoja viską iš karto.

## Begalinės sekos (neįmanoma su sąrašu)

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

Nes reikšmės gaminamos pagal poreikį, generatorius gali pavaizduoti *begalinį* srautą — jūs tiesiog paimate tai, ko jums reikia.

## Kaip iteracija veikia po gaubtu

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

## Generatoriaus išraiškos

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

## Kodėl tai svarbu

Generatoriai yra svarbūs **atminties efektyviam** didelių arba srauto duomenų apdorojimui — didelių failų skaitymas eilutėmis, didelių duomenų rinkinių apdorojimas, vamzdynai arba begalinės sekos — kai visos listo kūrimas išeikvojus atmintį.

Supratimas `yield` (sustabdymas/tęsinys su išsaugota būsena) ir lazaus vertinimo leidžia rašyti mastelio duomenų apdorojimo kodą, o generatoriaus išraiškos suteikia tokią patį privalumą glaustai.

Jie yra pagrindinė priemonė, kai duomenys yra per dideli atmintyje arba norėtumėte apdoroti elementus jų gamybos metu, o ne iš anksto.