Kaj so generatorji in ključna beseda yield?

Question

Accepted Answer

**Generator** je funkcija, ki proizvaja vrednosti **lenobno, po eno naenkrat**, z uporabo ključne besede `yield` namesto `return`. Izračuna vsako vrednost na zahtevo, namesto da bi zgradila celoten rezultat v pomnilniku — idealno za velike ali neskončne sekvence.

## 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` **prekine** funkcijo, vrne vrednost in **nadaljuje** iz točno tega mesta pri naslednji iteraciji — ohranjajoč lokalno stanje med vrednostmi. Nič ni izračunano, dokler ne bo zahtevano.

## Prednost pomnilnika

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

Za velike podatke generatorji držijo pomnilnik ploščat; razumevanje seznama materializira vse naenkrat.

## Neskončne sekvence (nemogoče s seznamom)

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

Ker se vrednosti producirajo na zahtevo, generator lahko predstavlja *neskončni* tok — vzamete samo tisto, kar potrebujete.

## Kako iteracija deluje pod pokrovom

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

## Generatorski izrazi

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

## Zakaj je to pomembno

Generatorji so bistveni za **varčno s pomnilnikom** obdelavo velikih ali pretočnih podatkov — branje ogromnih datotek vrstico za vrstico, obdelavo velikih nizov podatkov, cevovodov ali neskončnih sekvenc — kjer bi gradnja polnega seznama izčrpala pomnilnik.

Razumevanje `yield` (premor/nadaljevanje z ohranjenim stanjem) in lenobe vrednotenja vam omogoči pisati razširljivo kodo za obdelavo podatkov, generatorski izrazi pa zagotavljajo isto prednost jedrnato.

So ključno orodje, kadar so podatki preveliki, da bi se znašli v pomnilniku, ali želite obdelati postavke, ko se ustvarjajo, namesto da bi jih vse obdelali vnaprej.