हवाई जहाज़ के टिकट

एक generator एक फंक्शन या एक्सप्रेशन है जो एक खास तरह का इटरेटर लौटाता है, जिसे generator iterator कहते हैं। Generator-iterator आलसी होते हैं: वे अपनी values मेमोरी में संग्रहीत नहीं करते, बल्कि ज़रूरत पड़ने पर उन्हें बनाते हैं।

एक जेनरेटर फंक्शन दिखने में किसी भी आम फंक्शन जैसा होता है, लेकिन उसमें एक या उससे अधिक yield एक्सप्रेशन होते हैं। हर yield कोड का निष्पादन रोक देता है और मौजूदा निष्पादन स्थिति को सहेज लेता है (जिसमें सारे लोकल वेरिएबल और try स्टेटमेंट शामिल हैं)। जब जेनरेटर दोबारा चलना शुरू करता है, तो वह उसी रुकी हुई स्थिति से आगे बढ़ता है। आम फंक्शन ऐसा नहीं करते, वे हर कॉल पर शुरू से शुरू हो जाते हैं।

जेनरेटर बनाना

जेनरेटर भी दूसरे लूप वाले या रिकर्सिव फंक्शन की तरह ही बनाए जाते हैं, लेकिन इनमें एक yield एक्सप्रेशन ज़रूरी होता है, जिसे हम थोड़ी देर बाद विस्तार से देखेंगे।

एक उदाहरण देखिए: एक फंक्शन जो संख्याओं के दिए गए ऐरे से उनके वर्ग लौटाता है। जैसा यह अभी लिखा है, इसमें पहले पूरा इनपुट प्रोसेस करना पड़ता है, तभी कोई वैल्यू लौटाई जा सकती है:

>>> def squares(list_of_numbers):
...     squares = []
...     for number in list_of_numbers:
...         squares.append(number ** 2)
...     return squares

आप उस फंक्शन को इस तरह जेनरेटर में बदल सकते हैं:

>>> def squares_generator(list_of_numbers):
...     for number in list_of_numbers:
...         yield number ** 2

इसके पीछे वजह यह है कि जेनरेटर तब काम आता है जब आपको सारी वैल्यू एक साथ नहीं चाहिए। इससे मेमोरी और प्रोसेसिंग पावर बचती है, क्योंकि सिर्फ उसी वैल्यू की गणना होती है जिस पर आप उसी समय काम कर रहे हैं।

जेनरेटर का उपयोग

Python में ज़्यादातर iterables की जगह जेनरेटर का इस्तेमाल किया जा सकता है। इसमें वे फंक्शन या ऑब्जेक्ट भी शामिल हैं जिन्हें आर्गुमेंट के तौर पर एक iterable/iterator चाहिए।

squares_generator() जेनरेटर का उपयोग करने के लिए:

>>> squared_numbers = squares_generator([1, 2, 3, 4])

>>> for square in squared_numbers:
...     print(square)
...
1
4
9
16

generator के अंदर की वैल्यू भी next() फंक्शन से बनाई या पढ़ी जा सकती हैं। next() जेनरेटर-इटरेटर ऑब्जेक्ट का __next__() मेथड कॉल करता है, जो कोड को उसके yield एक्सप्रेशन तक "आगे बढ़ाता" है यानी चलाता है, और फिर वह एक वैल्यू "देता" है यानी लौटाता है:

>>> squared_numbers = squares_generator([1, 2])

>>> next(squared_numbers)
1
>>> next(squared_numbers)
4

जब किसी generator-iterator की सारी वैल्यू खत्म हो जाती हैं और लौटाने के लिए कुछ बचता नहीं, तो वह StopIteration एरर फेंकता है।

>>> next(squared_numbers)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration

yield एक्सप्रेशन

yield एक्सप्रेशन yield expression बहुत कुछ return एक्सप्रेशन जैसा होता है। return एक्सप्रेशन से अलग, yield कॉलर को वैल्यू एक खास बिंदु पर सौंप देता है, और तब तक कोई अतिरिक्त वैल्यू नहीं लौटाता जब तक उनकी माँग न की जाए। जब yield का मूल्यांकन होता है, तो यह अपने फंक्शन का निष्पादन रोक देता है और उस समय फंक्शन की जो भी वैल्यू हैं, उन्हें लौटा देता है। इसके बाद फंक्शन स्कोप में बना रहता है, और जब __next__() कॉल होता है, तो निष्पादन तब तक आगे बढ़ता है जब तक yield दोबारा न मिल जाए।

>>> def infinite_sequence():
...     current_number = 0
...     while True:
...         yield current_number
...         current_number += 1

>>> lets_try = infinite_sequence()
>>> lets_try.__next__()
0
>>> lets_try.__next__()
1

जेनरेटर क्यों बनाना चाहिए?

जेनरेटर कई जगहों पर काम आते हैं।

जब बहुत बड़ी संख्या में वैल्यू के साथ काम करना हो, तो आप शायद उन सबको मेमोरी में न रखना चाहें। ऐसे में जेनरेटर की मदद से बड़े डेटा पर टुकड़े-टुकड़े करके काम किया जा सकता है, जिससे मेमोरी बचती है और परफॉर्मेंस सुधरती है।

जेनरेटर तब भी बहुत काम आते हैं जब कोई प्रक्रिया या गणना जटिल, खर्चीली, या असीमित हो:

>>> def infinite_sequence():
...     current_number = 0
...     while True:
...         yield current_number
...         current_number += 1

अब जब भी infinite_sequence ऑब्जेक्ट पर __next__() कॉल होता है, यह पिछली संख्या + 1 लौटाता है।