पायथन में कोराटाइन

मैं इस तरह के एक दिलचस्प, लेकिन कॉरटाइन के रूप में अजगर की कम इस्तेमाल की जाने वाली विशेषता पर चर्चा करने का प्रस्ताव करता हूं।
अजगर में कोराटाइन जनरेटर (वे, वे, वास्तव में, हैं) पर आधारित हैं।
इसलिए, मैं सामान्य अर्थ में जनरेटर के साथ शुरू करने का प्रस्ताव करता हूं। और फिर हम यह पता लगाएंगे कि आपका कोरटाइन कैसे लिखें।

जनरेटर

किसी भी अधिक या कम सभ्य पायथन प्रोग्रामर को पता है कि जनरेटर कार्यों के रूप में ऐसी अद्भुत चीज है। उनकी मुख्य विशेषता कॉल के बीच राज्य का संरक्षण है।

मेरा मतलब है, आप जानते हैं कि वे कैसे काम करते हैं, इसलिए मैं आपको यह याद दिलाता हूं कि यह कैसा दिखता है।
आइए इस समारोह को लेते हैं:

def read_file_line_by_line(file_name): with open(file_name, 'r') as f: while True: line = f.readline() if not line: break yield line 

यह फ़ंक्शन इनपुट के रूप में एक फ़ाइल का नाम लेता है और इसे पूरी तरह से मेमोरी में लोड किए बिना लाइन द्वारा लाइन देता है, जो बड़ी फ़ाइलों को पढ़ते समय आवश्यक हो सकता है।
इस तकनीक को आलसी पढ़ना कहा जाता है, जिसका अर्थ है कि हम अनावश्यक रूप से "काम" नहीं करते हैं।

सामान्य तौर पर, जनरेटर के साथ काम करना इस प्रकार है:

 In [78]: lines_generator = read_file_line_by_line("data.csv") In [79]: type(lines_generator) Out[79]: generator In [83]: lines_generator.next() Out[83]: 'time,host,event\n' In [84]: lines_generator.next() Out[84]: '1374039728,localhost,reboot\n' In [85]: lines_generator.next() Out[85]: '1374039730,localhost,start\n' In [86]: lines_generator.next() --------------------------------------------------------------------------- StopIteration Traceback (most recent call last) <ipython-input-86-65df1a2cb71b> in <module>() ----> 1 lines_generator.next() StopIteration: #       3  #     ,   StopIteration,      . 

स्वाभाविक रूप से, अधिक बार हम जनरेटर से मूल्यों को लूप में पढ़ते हैं, और लाइन से लाइन नहीं।
इस सरल तरीके से, हम सभी विशिष्ट लाइनों को एक मनमाने ढंग से बड़ी फ़ाइल से प्राप्त कर सकते हैं:

 uniq = [] for line in lines_generator: if line not in uniq: uniq.append(line) 

जनरेटर की एक छोटी रिकॉर्डिंग भी संभव है:

 In [92]: gen = (x for x in xrange(0, 100*10000)) In [93]: gen.next() Out[93]: 0 In [94]: gen.next() Out[94]: 1 In [95]: gen.next() Out[95]: 2 In [96]: gen.next() Out[96]: 3 In [97]: gen.next() Out[97]: 4 

सूची के भाव की तरह लगता है, है ना? यह सिर्फ मेमोरी में पूरी range(0, 100*10000) सूची बनाने की आवश्यकता नहीं है, हर बार इसे एक्सेस करने पर रिटर्न वैल्यू "गणना" की जाती है।

जनरेटर के एक विशेष मामले के रूप में कोराटाइन

और अब इस बारे में क्यों, वास्तव में, शुरू किया गया था। यह पता चला है कि जनरेटर न केवल मूल्यों को वापस कर सकता है, बल्कि इनपुट पर भी उन्हें स्वीकार कर सकता है।

आप यहाँ PEP 342 के मानक के बारे में पढ़ सकते हैं।

मैं तुरंत एक उदाहरण के साथ शुरू करने का सुझाव देता हूं। हम एक जनरेटर का सरल कार्यान्वयन लिखेंगे जो दो तर्क जोड़ सकता है, परिणामों के इतिहास को संग्रहीत कर सकता है और इतिहास प्रदर्शित कर सकता है।

 def calc(): history = [] while True: x, y = (yield) if x == 'h': print history continue result = x + y print result history.append(result) c = calc() print type(c) # <type 'generator'> c.next() #  .   c.send(None) c.send((1,2)) #  3 c.send((100, 30)) #  130 c.send((666, 0)) #  666 c.send(('h',0)) #  [3, 130, 666] c.close() #   

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

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

 def coroutine(f): def wrap(*args,**kwargs): gen = f(*args,**kwargs) gen.send(None) return gen return wrap @coroutine def calc(): history = [] while True: x, y = (yield) if x == 'h': print history continue result = x + y print result history.append(result) 

इस उदाहरण में, आप समझ सकते हैं कि अपने अधिक जटिल (और उपयोगी) कोराउटीन कैसे लिखें।

निष्कर्ष।

यद्यपि इस टूल से हल की जा सकने वाली समस्याएं कई क्षेत्रों (जैसे एसिंक्रोनस प्रोग्रामिंग) को कवर करती हैं, कई डेवलपर्स अधिक परिचित ओओपी टूल पसंद करते हैं। लेकिन एक ही समय में कोरटाइन आपके शस्त्रागार में एक बहुत ही उपयोगी उपकरण हो सकता है, क्योंकि वे काफी दृश्य हैं, और एक वर्ग के ऑब्जेक्ट बनाने की तुलना में फ़ंक्शन बनाना एक सस्ता ऑपरेशन है।

और वे एक निश्चित शैक्षणिक हित का प्रतिनिधित्व करते हैं, जैसा कि मुझे लगता है।

यहाँ इस तरह का पहला लेख है।

युपीडी:
xrange पर range जनरेटर के एक छोटे रिकॉर्ड के उदाहरण में सही किया गया।
दूसरे संस्करण में, अजगर range() एक साथ पूरी सूची बनाता है, जनरेटर को बनाने के लिए आपको xrange() का उपयोग करने की आवश्यकता है, 3 जी संस्करण range == xrange (यानी जनरेटर लौटाता है)।