Mik azok a generátorok és a yield kulcsszó?

Question

IT Interview Practice · Accepted Answer

A **generátor** egy olyan függvény, amely **lusta módon, egyszerre egy értéket** állít elő a `yield` kulcsszó segítségével a `return` helyett. Az egyes értékeket igény szerint számítja ki, ahelyett hogy az egész eredményt a memóriában tárolná — ideális nagy vagy végtelen sorozatokhoz.

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

A `yield` **szünetelteti** a függvényt, visszaad egy értéket, és **folytatódik** ugyanonnan a következő iteráción — megőrizve a helyi állapotot az értékek között. Semmi sem kerül kiszámításra, amíg nem kérik.

## A memória előnye

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

Nagy adatok esetén a generátorok a memóriát laposnak tartják; egy listaértelmezés mindent egyszerre materializál.

## Végtelen sorozatok (lista esetén lehetetlen)

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

Mert az értékek igény szerint jönnek létre, egy generátor egy *végtelen* folyamot reprezentálhat — csak azt veszed el, amire szükséged van.

## Hogyan működik az iteráció a háttérben

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

## Generátor kifejezések

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

## Miért fontos

A generátorok **memóriahatékonysággal** dolgozik nagy vagy folyamatos adatfeldolgozáshoz — nagy fájlok soronkénti olvasása, nagy adathalmazok feldolgozása, adatcsatornák vagy végtelen sorozatok — ahol egy teljes lista építése kimerítené a memóriát.

A `yield` (szüneteltetés/folytatás megőrzött állapottal) és a lusta értékelés megértése lehetővé teszi skálázható adatfeldolgozási kód írását, és a generátor kifejezések ugyanezt az előnyt tömören biztosítják.

Ezek egy kulcsfontosságú eszköz, ha az adatok túl nagyok ahhoz, hogy a memóriába férjenek, vagy ha az elemeket azok előállítása során szeretnéd feldolgozni ahelyett, hogy mindet előre feldolgoznád.

yield vs return

A memória előnye

Végtelen sorozatok (lista esetén lehetetlen)

Hogyan működik az iteráció a háttérben

Generátor kifejezések

Miért fontos

Kapcsolódó kérdések