Python जनरेटर (yield): कैसे काम करते हैं

Python में जनरेटर डेटा सीक्वेंस के साथ कुशलतापूर्वक काम करने का एक शक्तिशाली तरीका है। ये ऐसे इटरेटेबल ऑब्जेक्ट बनाते हैं जो ज़रूरत पड़ने पर ही वैल्यू कैलकुलेट करते हैं, जिससे सिस्टम की मेमोरी काफी बचती है। जनरेटर का आधार yield कीवर्ड है, जो पारंपरिक return से बिल्कुल अलग काम करता है।

Python जनरेटर की मूल बातें

जनरेटर खास फंक्शन होते हैं जो सीधा मान लौटाने के बजाय इटरेटर लौटाते हैं। इनकी सबसे बड़ी खासियत yield कीवर्ड है, जो फंक्शन की स्थिति (state) को हर कॉल के बाद सेव रखता है।

जब भी आप जनरेटर फंक्शन को कॉल करते हैं, तो यह वहीं से चलना शुरू होता है जहाँ पिछली बार yield ने रोका था। यही कारण है कि जनरेटर बड़े डेटा स्ट्रीम को बिना पूरी मेमोरी में लोड किए प्रोसेस करने के लिए आदर्श हैं।

def simple_generator():
    yield 1
    yield 2
    yield 3

gen = simple_generator()
for value in gen:
    print(value)

आउटपुट:

1
2
3

yield कीवर्ड कैसे काम करता है?

yield कीवर्ड "लैज़ी इवैल्यूएशन" (lazy evaluation) के सिद्धांत पर काम करता है:

1. पहली बार next() कॉल करने पर, फंक्शन शुरू से चलता है और पहले yield तक पहुँचता है
2. मान लौटाने के बाद फंक्शन अपनी स्थिति "फ्रीज़" कर देता है
3. अगली next() कॉल पर, फंक्शन वहीं से चलना शुरू करता है जहाँ रुका था
4. यह प्रक्रिया तब तक चलती है जब तक फंक्शन खत्म नहीं हो जाता

def counter():
    print("जनरेटर शुरू")
    yield 1
    print("पहले yield के बाद")
    yield 2
    print("दूसरे yield के बाद")

gen = counter()
next(gen)  # आउटपुट: जनरेटर शुरू
next(gen)  # आउटपुट: पहले yield के बाद

जनरेटर बनाम लिस्ट: क्या फायदा है?

बड़े डेटा के साथ काम करते समय जनरेटर लिस्ट की तुलना में कहीं बेहतर होते हैं:

मेमोरी बचत: जनरेटर सभी वैल्यू एक साथ स्टोर नहीं करते, बल्कि ज़रूरत पड़ने पर एक-एक करके बनाते हैं।

# लिस्ट - बहुत ज्यादा मेमोरी लेती है
squares_list = [x * x for x in range(1000000)]

# जनरेटर - बहुत कम मेमोरी लेता है
squares_gen = (x * x for x in range(1000000))

परफॉरमेंस: जनरेटर तुरंत वैल्यू लौटाना शुरू कर देते हैं, पूरी सीक्वेंस बनने का इंतज़ार नहीं करना पड़ता।

अनंत सीक्वेंस बनाना

जनरेटर की मदद से आप बिना मेमोरी भरे अनंत सीक्वेंस भी बना सकते हैं:

def infinite_counter(start=0):
    while True:
        yield start
        start += 1

counter = infinite_counter()
print(next(counter))  # 0
print(next(counter))  # 1
print(next(counter))  # 2

जनरेटर के साथ काम करने के तरीके

जनरेटर कुछ खास मेथड्स सपोर्ट करते हैं:

next() — जनरेटर से अगली वैल्यू लेना send(value) — जनरेटर के अंदर वैल्यू भेजना throw() — जनरेटर के अंदर एक्सेप्शन जनरेट करना close() — जनरेटर को फोर्सफुली रोकना

def interactive_generator():
    value = yield "शुरुआत"
    while True:
        value = yield f"प्राप्त हुआ: {value}"

gen = interactive_generator()
print(next(gen))           # शुरुआत
print(gen.send(42))        # प्राप्त हुआ: 42
print(gen.send("नमस्ते"))  # प्राप्त हुआ: नमस्ते

जनरेटर में एक्सेप्शन हैंडलिंग

जनरेटर एक्सेप्शन हैंडलिंग को भी सपोर्ट करते हैं, जिसमें खास GeneratorExit एक्सेप्शन शामिल है:

def example_generator():
    try:
        yield 1
        yield 2
    except GeneratorExit:
        print("जनरेटर बंद हो गया!")

gen = example_generator()
print(ne