पायथन यील्ड कीवर्ड: एक गाइड

पायथन यील्ड कीवर्ड का उपयोग कैसे करें

जेनरेटर्स पायथन में सबसे सहज अवधारणा नहीं हैं। मामले को बदतर बनाने के लिए, वे "यील्ड" नामक एक विशेष कीवर्ड का उपयोग करते हैं, भले ही जेनरेटर्स स्वयं फ़ंक्शन्स हैं। यील्ड कीवर्ड क्या है? यह रिटर्न स्टेटमेंट से कैसे तुलना करता है?

वे अच्छे सवाल हैं। इस गाइड में, हम बात करते हैं कि यील्ड स्टेटमेंट क्या है और आप इसे अपने कोड में कैसे उपयोग कर सकते हैं। हम यील्ड कीवर्ड के एक्शन में एक उदाहरण देखते हैं। शुरू करते हैं!

हम पायथन इटरेरेटर्स और जेनरेटर्स पर हमारे आर्टिकल्स पढ़ने की सलाह देते हैं इससे पहले कि आप जारी रखें। यह आपको कुछ उपयोगी संदर्भ देता है जिसका उपयोग आप यील्ड कीवर्ड की अपनी समझ को आगे बढ़ाने के लिए कर सकते हैं।

बुनियादी बातों पर वापस: इटरेरेटर्स और जेनरेटर्स

सूचियों को इटरेबल ऑब्जेक्ट्स के रूप में वर्णित किया जाता है। ऐसा इसलिए है क्योंकि आप "for" लूप का उपयोग करके उनकी सामग्री देख सकते हैं। हर बार लूप निष्पादित होता है, पायथन द्वारा सूची में एक आइटम एक्सेस किया जाता है। डिक्शनरी, टपल्स, और स्ट्रिंग्स भी इटरेबल ऑब्जेक्ट्स हैं।

एक फ़ंक्शन जो एक इटरेबल ऑब्जेक्ट से एक आइटम एक्सेस करता है उसे इटरेरेटर कहा जाता है। आइए एक सूची बनाते हैं और for लूप का उपयोग करके उस पर इटरेट करते हैं:

peppers = ["Scotch Bonnet", "Piri Piri", "Cayenne"]
for p in peppers:
    print(p)
for p in peppers:
    print(p)

यह कोड "peppers" सूची में सभी मिर्च को कंसोल पर प्रिंट करता है:

Scotch Bonnet
Piri Piri
Cayenne
Scotch Bonnet
Piri Piri
Cayenne

हम अपने इटरेरेटर का उपयोग जितनी बार चाहें कर सकते हैं। पिछले उदाहरण में, हमने "peppers" ऑब्जेक्ट पर दो बार इटरेट किया।

पायथन जेनरेटर्स एक ऑब्जेक्ट को दोहराने के लिए उपयोग किए जाने वाले इटरेरेटर की तरह हैं। एक बड़ा अंतर है: आप केवल एक बार जेनरेटर पर इटरेट कर सकते हैं। जबकि हम "peppers" पर जितनी बार चाहें इटरेट कर सकते हैं, एक जेनरेटर केवल एक बार एक्सेस किया जाता है।

आइए अपनी मिर्च की सूची के लिए एक जेनरेटर परिभाषित करते हैं:

def print_peppers(peppers):
    for p in peppers:
        yield p

peppers = ["Scotch Bonnet", "Piri Piri", "Cayenne"]
pepper_generator = print_peppers(peppers)
for p in pepper_generator:
    print(p)

हम print_peppers() नामक एक फ़ंक्शन परिभाषित करते हैं। यह हमारा जेनरेटर फ़ंक्शन है। यह एक आर्गुमेंट स्वीकार करता है: मिर्च की एक सूची जिसे हम कंसोल पर प्रिंट करना चाहते हैं।

हमारे मेन प्रोग्राम में, हम print_peppers() फ़ंक्शन को कॉल करते हैं और इसे pepper_generator वेरिएबल को असाइन करते हैं। अगला, हम "for" लूप का उपयोग करके जेनरेटर पर इटरेट करते हैं। हमारा for लूप जेनरेटर ऑब्जेक्ट को कॉल करता है और उस पर इटरेट करता है।

आइए अपना कोड चलाते हैं:

Scotch Bonnet
Piri Piri
Cayenne

आउटपुट हमारे पहले उदाहरण के समान है। अंतर यह है कि हम अपनी सूची पर केवल एक बार इटरेट कर सकते हैं। आइए अपने जेनरेटर पर फिर से इटरेट करने का प्रयास करते हैं:

...
for p in pepper_generator:
    print(p)
for p in pepper_generator:
    print(p)

हमारा कोड लौटाता है:

Scotch Bonnet
Piri Piri
Cayenne

हमने अपने जेनरेटर पर एक बार इटरेट किया है। हम इसे फिर से नहीं कर सकते। इसलिए हमारा दूसरा for लूप कोई मान नहीं लौटाता।

पायथन यील्ड कीवर्ड

पिछले उदाहरण में "यील्ड" शब्द पर ध्यान दें। यहां एक रिमाइंडर है:

def print_peppers(peppers):
    for p in peppers:
        yield p

"यील्ड" कीवर्ड हमारे फ़ंक्शन के अंदर दिखाई देता है। यह एक जेनरेटर फ़ंक्शन में एक मान लौटाता है। यह "रिटर्न" कीवर्ड के समान है।

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

यील्ड वाला कोई भी फ़ंक्शन एक जेनरेटर लौटाएगा। हम type() मेथड का उपयोग करके pepper_generator वेरिएबल के प्रकार की जांच करके इसे देखते हैं:

<class 'generator'>

यह हमें बताता है कि pepper_generator, जिसे print_peppers फ़ंक्शन असाइन किया गया है, एक जेनरेटर है।

निष्कर्ष

यील्ड कीवर्ड एक जेनरेटर के अंदर एक मान लौटाता है। एक जेनरेटर एक विशेष प्रकार का इटरेरेटर है जिसके मान केवल एक बार इटरेट किए जा सकते हैं। यील्ड कीवर्ड एक रिटर्न स्टेटमेंट के समान है सिवाय इसके कि रिटर्न स्टेटमेंट्स का उपयोग जेनरेटर्स में नहीं किया जा सकता।

अब आप एक पायथनिस्टा की तरह यील्ड कीवर्ड का उपयोग करने के लिए तैयार हैं!