Ce sunt generatoarele și cuvântul cheie yield?

Question

Accepted Answer

Un **generator** este o funcție care produce valori **leneș, una câte una**, folosind cuvântul cheie `yield` în locul `return`. Calculează fiecare valoare la cerere, mai degrabă decât să construiască întregul rezultat în memorie — ideal pentru secvențe mari sau infinite.

## 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` **întrerupe** funcția, returnează o valoare și **reia** din exact acel punct la următoarea iterație — păstrând starea locală între valori. Nimic nu se calculează până nu este cerut.

## Avantajul memoriei

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

Pentru date mari, generatoarele păstrează memoria plană; o înțelegere de listă materializează totul deodată.

## Secvențe infinite (imposibil cu o listă)

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

Pentru că valorile sunt produse la cerere, un generator poate reprezenta un flux *infinit* — luați doar ceea ce aveți nevoie.

## Cum funcționează iterația sub capotă

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

## Expresii generator

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

## De ce contează

Generatoarele sunt esențiale pentru procesarea **eficientă din punctul de vedere al memoriei** a datelor mari sau în flux — citirea de fișiere imens linie cu linie, procesarea de seturi mari de date, conducte sau secvențe infinite — unde construirea unei liste complete ar epuiza memoria.

Înțelegerea `yield` (pauză/reluare cu stare păstrată) și evaluarea leneșă vă permite să scrieți cod scalabil de procesare a datelor, iar expresiile generator oferă același avantaj concis.

Sunt un instrument esențial ori de câte ori datele sunt prea mari pentru a încăpea în memorie sau doriți să procesați articolele pe măsură ce sunt produse, mai degrabă decât toate dinainte.