"उपज" शब्द के दो अर्थ हैं: कुछ उत्पन्न करना (जैसे, मकई उपजाना), और किसी को / दूसरी चीज़ को जारी रखने के लिए रोकना (जैसे, कार पैदल चलने वालों को)। दोनों परिभाषाएं पायथन के yieldकीवर्ड पर लागू होती हैं ; जेनरेटर फ़ंक्शंस को क्या खास बनाता है कि नियमित फ़ंक्शंस के विपरीत, मूल्यों को कॉल करने वाले को "वापस" किया जा सकता है, जबकि केवल रुकने का नहीं, एक जनरेटर फ़ंक्शन।
"बाएं" छोर और "दाएं" छोर के साथ एक द्विदिश पाइप के एक छोर के रूप में एक जनरेटर की कल्पना करना सबसे आसान है; यह पाइप वह माध्यम है जिस पर जनरेटर और जनरेटर फ़ंक्शन के बीच मूल्यों को भेजा जाता है। पाइप के प्रत्येक छोर में दो ऑपरेशन होते हैं: pushजो एक मूल्य भेजता है और तब तक ब्लॉक करता है जब तक पाइप के दूसरे छोर से मूल्य खींच नहीं लेता, और कुछ भी नहीं लौटाता; तथाpull, जो पाइप के दूसरे छोर तक एक मूल्य को धक्का देता है, और धक्का दिए गए मान को लौटाता है। रनटाइम के दौरान, निष्पादन पाइप के दोनों ओर संदर्भों के बीच आगे और पीछे उछलता है - प्रत्येक पक्ष तब तक चलता है जब तक कि यह दूसरी तरफ एक मूल्य नहीं भेजता है, जिस बिंदु पर यह रुकता है, दूसरे पक्ष को चलाने देता है, और मूल्य का इंतजार करता है वापसी, जिस तरफ दूसरी तरफ रुकती है और फिर से शुरू होती है। दूसरे शब्दों में, पाइप का प्रत्येक छोर उस क्षण से चलता है जब वह उस मूल्य को प्राप्त करता है जिस क्षण वह मूल्य भेजता है।
पाइप कार्यात्मक सममित है, लेकिन - सम्मेलन मैं इस सवाल का जवाब में परिभाषित करने कर रहा हूँ से - बाईं अंत जनरेटर समारोह के शरीर के अंदर ही उपलब्ध है और के माध्यम से पहुँचा जा सकता है yield, जबकि सही अंत, कीवर्ड है जनरेटर और के माध्यम से पहुँचा जा सकता है जनरेटर का sendकार्य। के रूप में एकवचन पाइप के अपने संबंधित छोरों के लिए इंटरफेस, yieldऔर sendडबल ड्यूटी करते हैं: वे प्रत्येक दोनों को धक्का देते हैं और पाइप के अपने सिरों से / के लिए मान को yieldधक्का देते हैं , दाएं को धक्का देते हैं और sendइसके विपरीत बाईं ओर खींचते हैं । यह दोहरा कर्तव्य बयानों के शब्दार्थ को लेकर भ्रम की स्थिति है x = yield y। दो स्पष्ट पुश / पुल चरणों में टूटने yieldऔर sendनीचे आने से उनके शब्दार्थ अधिक स्पष्ट होंगे:
- मान लीजिए
gजनरेटर है। g.sendपाइप के दाईं ओर के माध्यम से बाईं ओर एक मूल्य को धक्का देता है।
gठहराव के संदर्भ में निष्पादन , जनरेटर फ़ंक्शन को चलाने की अनुमति देता है।- द्वारा धक्का दिया मूल्य पाइप के बाईं
g.sendओर से yieldप्राप्त किया और छोड़ दिया है। में x = yield y, xखींचे गए मान को सौंपा गया है।
- जनरेटर फ़ंक्शन के शरीर के भीतर निष्पादन तब तक जारी रहता है जब तक कि अगली पंक्ति युक्त नहीं हो
yieldजाता है।
yieldपाइप के बाएं छोर के माध्यम से एक मूल्य को दाईं ओर धकेलता है, बैक अप लेता है g.send। में x = yield y, yपाइप के माध्यम से दाईं ओर धकेल दिया जाता है।- जनरेटर फ़ंक्शन के शरीर के भीतर निष्पादन रुक जाता है, जिससे बाहरी गुंजाइश बनी रहती है, जहां इसे छोड़ दिया जाता है।
g.send फिर से शुरू और मान खींचता है और इसे उपयोगकर्ता को लौटाता है।- जब
g.sendअगला कहा जाता है, तो चरण 1 पर वापस जाएं।
चक्रीय होते समय, इस प्रक्रिया की एक शुरुआत होती है: जब g.send(None)- जो है उसके next(g)लिए कम है - पहले कहा जाता है ( Noneपहली sendकॉल के अलावा कुछ और पास करना अवैध है )। और इसका एक अंत हो सकता है: जब yieldजनरेटर फ़ंक्शन के शरीर में पहुंचने के लिए अधिक विवरण नहीं होते हैं ।
क्या आप देखते हैं कि क्या yieldबयान (या अधिक सटीक, जनरेटर) इतना खास बनाता है ? औसत दर्जे के returnकीवर्ड के विपरीत , yieldइसके कॉलर को मान देने में सक्षम है और इसके कॉलर से उन सभी मूल्यों को प्राप्त कर सकता है, जो इस फ़ंक्शन को समाप्त किए बिना! (बेशक, यदि आप किसी फ़ंक्शन को समाप्त करना चाहते हैं - या एक जनरेटर - यह returnकीवर्ड के रूप में अच्छी तरह से काम करने के लिए आसान है ।) जब एक yieldबयान का सामना किया जाता है, तो जनरेटर फ़ंक्शन केवल रुकता है, और फिर वापस ऊपर उठाता है जहां यह छोड़ दिया है एक और मूल्य भेजा जा रहा है। और sendयह बाहर से एक जनरेटर फ़ंक्शन के अंदर के साथ संवाद करने के लिए सिर्फ इंटरफ़ेस है।
अगर हम वास्तव में इस पुश / पुल / पाइप सादृश्य को तोड़ना चाहते हैं, तो हम निम्नलिखित pseudocode के साथ समाप्त होते हैं, जो वास्तव में घर को ड्राइव करता है, जो 1-5 कदम से अलग है, yieldऔर sendएक ही सिक्के के पाइप के दो पहलू हैं :
right_end.push(None) # the first half of g.send; sending None is what starts a generatorright_end.pause()left_end.start()initial_value = left_end.pull()if initial_value is not None: raise TypeError("can't send non-None value to a just-started generator")left_end.do_stuff()left_end.push(y) # the first half of yieldleft_end.pause()right_end.resume()value1 = right_end.pull() # the second half of g.sendright_end.do_stuff()right_end.push(value2) # the first half of g.send (again, but with a different value)right_end.pause()left_end.resume()x = left_end.pull() # the second half of yieldgoto 6
मुख्य परिवर्तन यह है कि हम विभाजित हैं x = yield yऔर value1 = g.send(value2)प्रत्येक दो बयानों में: left_end.push(y)और x = left_end.pull(); और value1 = right_end.pull()और right_end.push(value2)। yieldकीवर्ड के दो विशेष मामले हैं : x = yieldऔर yield y। ये सिंटैक्टिक शुगर हैं, क्रमशः, के लिए x = yield Noneऔर _ = yield y # discarding value।
सटीक क्रम के संबंध में विशिष्ट विवरण के लिए जिसमें मान पाइप के माध्यम से भेजे जाते हैं, नीचे देखें।
इसके बाद के संस्करण के एक लंबे समय तक ठोस मॉडल है। सबसे पहले, यह पहले ध्यान दिया जाना चाहिए कि किसी भी जनरेटर के लिए g, next(g)इसके बिल्कुल बराबर है g.send(None)। इसे ध्यान में रखते हुए हम sendकेवल इस बात पर ध्यान केंद्रित कर सकते हैं कि कैसे काम करता है और केवल जनरेटर को आगे बढ़ाने के बारे में बात करता है send।
मान लीजिए हमारे पास है
def f(y): # This is the "generator function" referenced above
while True:
x = yield y
y = x
g = f(1)
g.send(None) # yields 1
g.send(2) # yields 2
अब, fनिम्नलिखित साधारण (गैर-जनरेटर) फ़ंक्शन के मोटे तौर पर desugars की परिभाषा :
def f(y):
bidirectional_pipe = BidirectionalPipe()
left_end = bidirectional_pipe.left_end
right_end = bidirectional_pipe.right_end
def impl():
initial_value = left_end.pull()
if initial_value is not None:
raise TypeError(
"can't send non-None value to a just-started generator"
)
while True:
left_end.push(y)
x = left_end.pull()
y = x
def send(value):
right_end.push(value)
return right_end.pull()
right_end.send = send
# This isn't real Python; normally, returning exits the function. But
# pretend that it's possible to return a value from a function and then
# continue execution -- this is exactly the problem that generators were
# designed to solve!
return right_end
impl()
निम्नलिखित इस परिवर्तन में हुआ है f:
- हमने कार्यान्वयन को एक नेस्टेड फ़ंक्शन में स्थानांतरित कर दिया है।
- हमने एक द्विदिश पाइप बनाया
left_endहै जिसे नेस्टेड फ़ंक्शन द्वारा एक्सेस किया right_endजाएगा और जिसे वापस लौटाया जाएगा और बाहरी दायरे द्वारा एक्सेस किया जाएगा - right_endजिसे हम जेनरेटर ऑब्जेक्ट के रूप में जानते हैं।
- नेस्टेड फ़ंक्शन के भीतर, हम जो सबसे पहला काम करते हैं, वह यह
left_end.pull()है कि Noneइस प्रक्रिया में एक धक्का मूल्य का उपभोग करना है।
- नेस्टेड फ़ंक्शन के भीतर, स्टेटमेंट
x = yield yको दो लाइनों द्वारा प्रतिस्थापित किया गया है: left_end.push(y)और x = left_end.pull()।
- हमने
sendफ़ंक्शन को परिभाषित किया है right_end, जो दो पंक्तियों का प्रतिरूप है जिसे हमने x = yield yपिछले चरण में बयान से बदल दिया था ।
इस फंतासी दुनिया में जहां लौटने के बाद कार्य जारी रह सकते हैं, gसौंपा जाता है right_endऔर फिर impl()कहा जाता है तो ऊपर हमारे उदाहरण में, क्या हम लाइन द्वारा निष्पादन लाइन का पालन करते हैं, क्या होगा यह मोटे तौर पर निम्नलिखित है:
left_end = bidirectional_pipe.left_end
right_end = bidirectional_pipe.right_end
y = 1 # from g = f(1)
# None pushed by first half of g.send(None)
right_end.push(None)
# The above push blocks, so the outer scope halts and lets `f` run until
# *it* blocks
# Receive the pushed value, None
initial_value = left_end.pull()
if initial_value is not None: # ok, `g` sent None
raise TypeError(
"can't send non-None value to a just-started generator"
)
left_end.push(y)
# The above line blocks, so `f` pauses and g.send picks up where it left off
# y, aka 1, is pulled by right_end and returned by `g.send(None)`
right_end.pull()
# Rinse and repeat
# 2 pushed by first half of g.send(2)
right_end.push(2)
# Once again the above blocks, so g.send (the outer scope) halts and `f` resumes
# Receive the pushed value, 2
x = left_end.pull()
y = x # y == x == 2
left_end.push(y)
# The above line blocks, so `f` pauses and g.send(2) picks up where it left off
# y, aka 2, is pulled by right_end and returned to the outer scope
right_end.pull()
x = left_end.pull()
# blocks until the next call to g.send
यह ऊपर दिए गए 16-चरण वाले स्यूडोकोड के समान है।
कुछ अन्य विवरण हैं, जैसे कि त्रुटियों का प्रचार कैसे किया जाता है और जनरेटर के अंत तक पहुंचने पर क्या होता है (पाइप बंद है), लेकिन यह स्पष्ट करना चाहिए कि मूल नियंत्रण प्रवाह कैसे काम करता है जब sendइसका उपयोग किया जाता है।
इन समान नियमों का उपयोग करते हुए, आइए दो विशेष मामलों को देखें:
def f1(x):
while True:
x = yield x
def f2(): # No parameter
while True:
x = yield x
अधिकांश भाग के लिए वे उसी तरह से उतरते हैं जैसे कि f, केवल अंतर यह है कि yieldबयान कैसे रूपांतरित होते हैं:
def f1(x):
# ... set up pipe
def impl():
# ... check that initial sent value is None
while True:
left_end.push(x)
x = left_end.pull()
# ... set up right_end
def f2():
# ... set up pipe
def impl():
# ... check that initial sent value is None
while True:
left_end.push(x)
x = left_end.pull()
# ... set up right_end
पहले में, पास किया गया मान f1शुरू में धकेल दिया जाता है (उपज दिया जाता है), और फिर खींचे गए (भेजे गए) सभी मानों को पीछे धकेल दिया जाता है। दूसरे में, xइसका कोई मूल्य (अभी तक) नहीं है जब यह पहली बार आता है push, तो एक UnboundLocalErrorउठाया जाता है।