StackOverflow अक्सर प्रलेखन में विस्तृत प्रश्न पूछे जाते हैं। उनका मूल्य यह है कि कोई उनमें से कुछ को जवाब देता है, जिसमें प्रलेखन की तुलना में स्पष्टता और दृश्यता की बहुत अधिक डिग्री है। यह उनमें से एक है।

यहाँ मूल प्रश्न है:

पाइथन में उपज कीवर्ड का उपयोग कैसे किया जाता है? यह क्या करता है?

उदाहरण के लिए, मैं इस कोड (**) को समझने की कोशिश कर रहा हूं:

def _get_child_candidates(self, distance, min_dist, max_dist): if self._leftchild and distance - max_dist < self._median: yield self._leftchild if self._rightchild and distance + max_dist >= self._median: yield self._rightchild 

इसे इस तरह कहा जाता है:

 result, candidates = list(), [self] while candidates: node = candidates.pop() distance = node._get_dist(obj) if distance <= max_dist and distance >= min_dist: result.extend(node._values) candidates.extend(node._get_child_candidates(distance, min_dist, max_dist)) return result 

क्या होता है जब _get_child_candidates विधि कहा जाता है? सूची वापस, कुछ तत्व? क्या उसे फिर से बुलाया जाता है? बाद के कॉल कब समाप्त होते हैं?

** कोड जोहान शुल्ज (jrschulz) का है, जिन्होंने मीट्रिक रिक्त स्थान के लिए एक उत्कृष्ट पायथन लाइब्रेरी लिखी। यहाँ स्रोत का लिंक दिया गया है: http://well-adjusted.de/~jrschulz/mspace/

और यहाँ जवाब है:

iterators

यह समझने के लिए कि उपज क्या होती है, आपको यह समझने की जरूरत है कि जनरेटर क्या हैं। जनरेटर पुनरावृत्तियों से पहले होते हैं। जब आप एक सूची बनाते हैं, तो आप इसके तत्वों को एक-एक करके पढ़ सकते हैं - इसे एक पुनरावृत्ति कहा जाता है:

 >>> mylist = [1, 2, 3] >>> for i in mylist : ... print(i) 1 2 3 

Mylist एक चलने योग्य वस्तु है। जब आप एक जनरेटर अभिव्यक्ति का उपयोग करके एक सूची बनाते हैं, तो आप एक इट्रेटर भी बनाते हैं:

 >>> mylist = [x*x for x in range(3)] >>> for i in mylist : ... print(i) 0 1 4 

सब कुछ है कि "के लिए ... में ..." निर्माण लागू किया जा सकता है एक iterable वस्तु है: सूचियों, लाइनों, फ़ाइलों ... यह सुविधाजनक है क्योंकि आप जरूरत से उन मूल्यों को पढ़ सकते हैं - हालांकि, सभी मान स्मृति में संग्रहीत होते हैं, और यह हमेशा नहीं होता है अधिमानतः यदि आपके पास बहुत सारे अर्थ हैं।

जनरेटर

जेनरेटर भी चलने योग्य वस्तुएं हैं, लेकिन आप उन्हें केवल एक बार पढ़ सकते हैं। यह इस तथ्य के कारण है कि वे स्मृति में मूल्यों को संग्रहीत नहीं करते हैं, लेकिन उन्हें मक्खी पर उत्पन्न करते हैं:

 >>> mygenerator = (x*x for x in range(3)) >>> for i in mygenerator : ... print(i) 0 1 4 

सब कुछ समान है, सिवाय इसके कि कोष्ठक वर्ग के बजाय कोष्ठक का उपयोग किया जाता है। लेकिन: आप के लिए आवेदन नहीं कर सकते मैं mygenerator में एक दूसरी बार निर्माण, क्योंकि जनरेटर केवल एक बार इस्तेमाल किया जा सकता है: यह 0 की गणना करता है, फिर इसके बारे में भूल जाता है और 1 की गणना करता है, गणना 4 के साथ समाप्त होता है - एक के बाद एक।

उपज

यील्ड एक ऐसा कीवर्ड है जिसका उपयोग मोटे तौर पर रिटर्न के रूप में किया जाता है - अंतर यह है कि फ़ंक्शन जनरेटर को वापस कर देगा।

 >>> def createGenerator() : ... mylist = range(3) ... for i in mylist : ... yield i*i ... >>> mygenerator = createGenerator() #   >>> print(mygenerator) # mygenerator  ! <generator object createGenerator at 0xb7555c34> >>> for i in mygenerator: ... print(i) 0 1 4 

इस मामले में, उदाहरण बेकार है, लेकिन यह सुविधाजनक है यदि आप जानते हैं कि फ़ंक्शन मानों का एक बड़ा सेट लौटाएगा जिसे केवल एक बार पढ़ने की आवश्यकता है।

उपज प्राप्त करने के लिए, आपको यह समझना चाहिए कि जब आप किसी फ़ंक्शन को कॉल करते हैं, तो फ़ंक्शन बॉडी के अंदर कोड निष्पादित नहीं होता है। फ़ंक्शन केवल एक जनरेटर ऑब्जेक्ट लौटाता है - थोड़ा मुश्किल :-)

जनरेटर को कॉल करने के लिए आपका कोड हर बार कॉल किया जाएगा।

अब मुश्किल हिस्सा:

पहली बार जब आप अपना फ़ंक्शन चलाते हैं, तो इसे शुरुआत से उस क्षण तक निष्पादित किया जाएगा जब यह उपज पर ठोकर खाएगा - फिर यह लूप से पहला मूल्य लौटाएगा। प्रत्येक अगले कॉल के लिए, आपके द्वारा लिखे गए चक्र का एक और पुनरावृत्ति घटित होगा, अगला मान वापस आ जाएगा - और इसी तरह जब तक मान बाहर नहीं निकलते।

फ़ंक्शन कोड निष्पादित करते समय उपज का सामना नहीं करने के साथ ही जनरेटर को खाली माना जाता है। यह लूप के अंत के कारण हो सकता है, या यदि कुछ / अन्य शर्तों को पूरा नहीं किया जाता है।

स्रोत प्रश्न से कोड स्पष्टीकरण

जनरेटर:

 #   ,     def _get_child_candidates(self, distance, min_dist, max_dist): #         -: #       #      ,    if self._leftchild and distance - max_dist < self._median: yield self._leftchild #       #      ,    if self._rightchild and distance + max_dist >= self._median: yield self._rightchild #      ,    

कॉल करें:

 #           result, candidates = list(), [self] #      (     ) while candidates: #         node = candidates.pop() #       distance = node._get_dist(obj) #      ,    if distance <= max_dist and distance >= min_dist: result.extend(node._values) #      , #       , #       <...>  candidates.extend(node._get_child_candidates(distance, min_dist, max_dist)) return result 

इस कोड में कई छोटे भाग हैं:

• लूप सूची के माध्यम से पुनरावृत्ति करता है, लेकिन सूची पुनरावृत्ति के दौरान फैलती है :-) यह सभी समूहीकृत डेटा को बायपास करने का एक संक्षिप्त तरीका है, और यह थोड़ा खतरनाक है, क्योंकि यह एक अनंत लूप में बदल सकता है। इस स्थिति में, Candid.extend (node._get_child_candidates (दूरी, min_dist, max_dist)) सभी जनरेटर मानों को समाप्त कर देंगे, लेकिन नए जनरेटर ऑब्जेक्ट्स बनाना जारी रखेंगे जो पिछले वाले से भिन्न मान देंगे (क्योंकि वे अन्य नोड्स पर लागू होते हैं)।
• विस्तार () विधि एक सूची ऑब्जेक्ट विधि है जो चलने योग्य इनपुट की अपेक्षा करती है और सूची में इसके मूल्यों को जोड़ती है।

आमतौर पर हम उसे एक सूची देते हैं:

 >>> a = [1, 2] >>> b = [3, 4] >>> a.extend(b) >>> print(a) [1, 2, 3, 4] 

लेकिन हमारे कोड में, यह एक जनरेटर को स्वीकार करता है, जो निम्नलिखित कारणों से अच्छा है:

• मूल्यों को दो बार पढ़ने की आवश्यकता नहीं है।
• ऐसा हो सकता है कि कई वंशज हैं और आप उन सभी को स्मृति में संग्रहीत नहीं करना चाहते हैं।

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

पाठक यहां रुक सकते हैं, या जनरेटर के उन्नत उपयोग के बारे में थोड़ा और पढ़ सकते हैं:

जनरेटर थकावट नियंत्रण

 >>> class Bank(): #  ,    (ATM — Automatic Teller Machine) ... crisis = False ... def create_atm(self) : ... while not self.crisis : ... yield "$100" >>> hsbc = Bank() #   ,         >>> corner_street_atm = hsbc.create_atm() >>> print(corner_street_atm.next()) $100 >>> print(corner_street_atm.next()) $100 >>> print([corner_street_atm.next() for cash in range(5)]) ['$100', '$100', '$100', '$100', '$100'] >>> hsbc.crisis = True #  ,   ! >>> print(corner_street_atm.next()) <type 'exceptions.StopIteration'> >>> wall_street_atm = hsbc.create_atm() #       >>> print(wall_street_atm.next()) <type 'exceptions.StopIteration'> >>> hsbc.crisis = False #   ,    ,  - ... >>> print(corner_street_atm.next()) <type 'exceptions.StopIteration'> >>> brand_new_atm = hsbc.create_atm() #     ,    ! >>> for cash in brand_new_atm : ... print cash $100 $100 $100 $100 $100 $100 $100 $100 $100 ... 

यह विभिन्न उद्देश्यों के लिए उपयोगी हो सकता है, जैसे कि संसाधन तक पहुंच को नियंत्रित करना।

आपका सबसे अच्छा दोस्त Itertools

Itertools मॉड्यूल में पुनरावृत्त वस्तुओं के साथ काम करने के लिए विशेष कार्य शामिल हैं। क्या आप जनरेटर की नकल करना चाहेंगे? श्रृंखला में दो जनरेटर कनेक्ट करें? एक पंक्ति में नेस्टेड सूचियों के समूह मूल्य? दूसरी सूची बनाए बिना नक्शा या ज़िप लागू करें?

बस आयात itertools जोड़ें।

एक उदाहरण चाहते हैं? आइए दौड़ (4 घोड़ों) के संभावित फिनिश ऑर्डर पर एक नज़र डालें:

 >>> horses = [1, 2, 3, 4] >>> races = itertools.permutations(horses) >>> print(races) <itertools.permutations object at 0xb754f1dc> >>> print(list(itertools.permutations(horses))) [(1, 2, 3, 4), (1, 2, 4, 3), (1, 3, 2, 4), (1, 3, 4, 2), (1, 4, 2, 3), (1, 4, 3, 2), (2, 1, 3, 4), (2, 1, 4, 3), (2, 3, 1, 4), (2, 3, 4, 1), (2, 4, 1, 3), (2, 4, 3, 1), (3, 1, 2, 4), (3, 1, 4, 2), (3, 2, 1, 4), (3, 2, 4, 1), (3, 4, 1, 2), (3, 4, 2, 1), (4, 1, 2, 3), (4, 1, 3, 2), (4, 2, 1, 3), (4, 2, 3, 1), (4, 3, 1, 2), (4, 3, 2, 1)] 

पुनरावृति के आंतरिक तंत्र को समझना

एक पुनरावृति चलने योग्य वस्तुओं (__iter __ () विधि) और पुनरावृत्तियों (__next __ () विधि को लागू करने) को शामिल करने वाली एक प्रक्रिया है। इरिटेबल ऑब्जेक्ट्स ऐसी कोई भी ऑब्जेक्ट हैं जिनसे एक इटरेटर प्राप्त किया जा सकता है। Iterators ऑब्जेक्ट्स हैं जो आपको पुनरावृत्त वस्तुओं पर पुनरावृत्त करने की अनुमति देते हैं।

इस विषय पर अधिक जानकारी लेख में उपलब्ध है कि लूप कैसे काम करता है ।