Što su generatori i ključna reč yield?

Question

Accepted Answer

**Generator** je funkcija koja proizvodi vrijednosti **lenivo, jednu po jednu**, koristeći ključnu reč `yield` umjesto `return`. On izračunava svaku vrijednost na zahtjev umjesto da gradi cijeli rezultat u memoriji — idealno za velike ili beskonač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` **pauzira** funkciju, vraća vrijednost, i **nastavlja** od te točno iste točke pri sljedećoj iteraciji — čuvajući lokalno stanje između vrijednosti. Ništa se ne izračunava dok se ne traži.

## Korist za memoriju

```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, generatori drže memoriju ravnom; list comprehension materiјalizira sve odjednom.

## Beskonačne sekvence (nemoguće sa listom)

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

Budući da se vrijednosti proizvode na zahtjev, generator može predstavljati *beskonačni* tok — trebate samo ono što trebate.

## Kako iteracija radi ispod haube

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

## Generatorske izraze

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

## Zašto je to važno

Generatori su neophodni za **memoriјski učinkovito** procesiranje velikih ili strujnih podataka — čitanje ogromanh datoteka red po red, obrada velikih skupova podataka, cjevovodi, ili beskonačne sekvence — gdje bi gradnja kompletne liste potrošila memoriju.

Razumijevanje `yield` (pauza/nastavak sa čuvanim stanjem) i ljenive evaluacije omogućava vam pisanje skalabilnog koda za obradu podataka, a generatorski izrazi pružaju istu korist ukupno.

Oni su ključni alat kad god su podaci preveliki za memoriju ili trebate obraditi stavke kako se proizvode umjesto svih unaprijed.