Generators और yield keyword क्या हैं?

Question

Accepted Answer

एक **generator** ऐसा function है जो `return` के बजाय `yield` keyword का उपयोग करके values को **lazily, एक-एक करके** उत्पन्न करता है। यह पूरे result को memory में बनाने के बजाय प्रत्येक value को मांग पर compute करता है — बड़े या अनंत sequences के लिए आदर्श।

## 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` function को **रोकता** है, एक value लौटाता है, और अगले iteration पर उसी सटीक बिंदु से **फिर शुरू** करता है — values के बीच local state को संरक्षित करते हुए। अनुरोध होने तक कुछ भी compute नहीं होता।

## memory का लाभ

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

बड़े data के लिए, generators memory को flat रखते हैं; एक list comprehension एक ही बार में सब कुछ materialize कर देता है।

## अनंत sequences (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
```

क्योंकि values मांग पर उत्पन्न होती हैं, एक generator एक *अनंत* stream का प्रतिनिधित्व कर सकता है — आप बस जितना चाहिए उतना लेते हैं।

## iteration अंदरूनी रूप से कैसे काम करता है

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

## Generator expressions

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

## यह क्यों महत्वपूर्ण है

Generators बड़े या streaming data के **memory-कुशल** processing के लिए आवश्यक हैं — विशाल files को line by line पढ़ना, बड़े datasets को process करना, pipelines, या अनंत sequences — जहाँ एक पूरी list बनाना memory को समाप्त कर देगा।

`yield` (संरक्षित state के साथ pause/resume) और lazy evaluation को समझना आपको scalable data-processing code लिखने देता है, और generator expressions समान लाभ संक्षिप्त रूप से प्रदान करते हैं।

जब भी data memory में फिट होने के लिए बहुत बड़ा हो या आप items को सब एक साथ के बजाय उनके उत्पन्न होते ही process करना चाहें, तो ये एक प्रमुख tool हैं।