జెనరేటర్‌లు మరియు yield కీవర్డ్ ఏమిటి?

Question

Accepted Answer

**జెనరేటర్** అనేది `yield` కీవర్డ్‌ను `return` స్థానంలో ఉపయోగించి **నెమ్మదిగా, ఒక సమయంలో ఒకటి** విలువలను ఉత్పత్తి చేసే ఫంక్షన్. ఇది మొత్తం ఫలితాన్ని మెమరీలో నిర్మించకుండా ప్రతిটి విలువను డిమాండ్ ఆధారంగా లెక్కిస్తుంది — పెద్ద లేదా అనంత సీక్వెన్సుల కోసం ఆదర్శ.

## 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` ఫంక్షన్‌ను **పాజ్ చేస్తుంది**, విలువను రిటర్న్ చేస్తుంది, మరియు తదుపరి ఇటరేషన్‌లో ఆ సరిగ్గా ఉన్న బిందువు నుండి **మళ్లీ ప్రారంభిస్తుంది** — విలువల మధ్య స్థానిక స్థితిని సংరక్షిస్తుంది. అభ్యర్థన వచ్చే వరకు ఏదీ లెక్కించబడదు.

## మెమరీ ప్రయోజనం

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

పెద్ద డేటా కోసం, జెనరేటర్‌లు మెమరీని ఫ్లాట్‌గా ఉంచుతాయి; లిస్ట్ కాంప్రిహెన్షన్ ఎవరిదూ ఒక సారి నిర్మిస్తుంది.

## అనంత సీక్వెన్సులు (లిస్ట్‌తో అసాధ్యం)

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

విలువలు డిమాండ్ ఆధారంగా ఉత్పత్తి చేయబడినందున, జెనరేటర్ *అనంత* స్ట్రీమ్‌ను సూచించగలదు — మీరు కోసిన చీజ్‌ను తీసుకోండి.

## హుడ్ కింద ఇటరేషన్ ఎలా పనిచేస్తుంది

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

## జెనరేటర్ వ్యక్తీకరణలు

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

## ఇది ఎందుకు ముఖ్యమైనది

జెనరేటర్‌లు పెద్ద లేదా స్ట్రీమింగ్ డేటా యొక్క **మెమరీ-సమర్థ** ప్రసంస్కరణ కోసం అవసరం — భారీ ఫైల్‌లను లైన్ బై లైన్‌గా చదవడం, పెద్ద డేటాసెట్‌లను ప్రసంస్కరించడం, పైప్‌లైన్‌లు లేదా అనంత సీక్వెన్సులు — పూర్ణ జాబితాను నిర్మించడం మెమరీని రీసెట్ చేస్తుంది.

`yield` (పాజ్/రిజ్యూమ్ సంరక్షిత స్థితితో) మరియు నిర్ణీత మూల్యాంకనాన్ని అర్థం చేసుకోవడం మీరు స్కేలేబుల్ డేటా-ప్రసంస్కరణ కోడ్‌ను వ్రాయడానికి అనుమతిస్తుంది, మరియు జెనరేటర్ వ్యక్తీకరణలు సంక్షిప్తంగా ఒకే ప్రయోజనాన్ని అందిస్తాయి.

డేటా మెమరీలో ఫిట్ చేయడానికి చాలా పెద్దదిగా ఉన్నప్పుడు లేదా అభ్యర్థించిన వెంటనే అన్నీ ప్రసంస్కరించకుండా ఐటెమ్‌లను ప్రసంస్కరించాలనుకున్నప్పుడు అవి ఒక కీ టూల్.