जनरेटर आणि yield कीवर्ड काय आहेत?

Question

Accepted Answer

A **generator** हा एक फंक्शन आहे जो `return` च्या जागी `yield` कीवर्ड वापरून **आळस, एक वेळी एक** मूल्य उत्पन्न करतो. हा प्रत्येक मूल्य मागणीवर गणना करतो पूर्ण परिणाम मेमोरीमध्ये तयार करण्याऐवजी — मोठ्या किंवा अनंत क्रमासाठी आदर्श.

## 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` (संरक्षित स्थितीसह थांबवणे/पुनः सुरू करणे) आणि आळसी मूल्यांकन समजणे आपल्याला स्केलेबल डेटा-प्रक्रिया कोड लिहिण्यास अनुमती देते, आणि जनरेटर एक्सप्रेशन संक्षिप्तपणे समान फायदा प्रदान करतात.

ते मुख्य साधन आहेत जेव्हा डेटा मेमोरीमध्ये फिट करण्यासाठी खूप मोठा असतो किंवा आपण आयटम प्रक्रिया करू इच्छित असता जेव्हा ते उत्पन्न होतात पर्याय सर्व आगामीपणे.