જનરેટર્સ અને yield કીવર્ડ શું છે?

Question

Accepted Answer

એક **જનરેટર** એક ફંક્શન છે જે `yield` કીવર્ડનો ઉપયોગ કરીને `return` ની જગ્યાએ **આળસીપણે, એક સમયે એક** મૂલ્ય પેદા કરે છે। તે પૂર્ણ પરિણામને મેમરીમાં બનાવવાને બદલે દરેક મૂલ્ય માંગ પર ગણતરી કરે છે — મોટી અથવા અનંત શ્રેણીઓ માટે આદર્શ છે।

## yield વિ 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` (સ્થિતિ સાથે થોભાવો/ફરી શરૂ કરો) અને આળસીપણે મૂલ્યાંકન સમજવું તમને સ્કેલેબલ ડેટા-પ્રક્રિયાકરણ કોડ લખવા દે છે, અને જનરેટર અભિવ્યક્તિઓ સમાન લાભ સંક્ષિપ્તપણે આપે છે।

જ્યાં કોઈ પણ સમય ડેટા મેમરીમાં સમાયી શકતો નથી અથવા તમે પ્રતિક્રિયાશીલ રીતે વસ્તુઓ પ્રક્રિયા કરવા માંગો છો તે તે તૈયાર કરવાને બદલે તે મુખ્ય સાધન છે।