__iter __() एक जनरेटर

Question

मैंने किसी चीज़ उपवर्ग जो एक गतिशील प्रेषण __ iter __ लागू करता है एक कैशिंग जनरेटर का उपयोग किया है के रूप में कार्यान्वित तो की तरह (मैं भी आईटीईआर कैश अमान्य के लिए एक विधि है):

def __iter__(self): 
    print("iter called") 
    if self.__iter_cache is None: 
     iter_seen = {} 
     iter_cache = [] 
     for name in self.__slots: 
      value = self.__slots[name] 
      iter_seen[name] = True 
      item = (name, value) 
      iter_cache.append(item) 
      yield item   
     for d in self.__dc_list: 
      for name, value in iter(d): 
       if name not in iter_seen: 
        iter_seen[name] = True 
        item = (name, value) 
        iter_cache.append(item) 
        yield item 
     self.__iter_cache = iter_cache 
    else: 
     print("iter cache hit") 
     for item in self.__iter_cache: 
      yield item 

यह लगता है काम कर रहे हैं ... क्या कोई गठिया है जिसके बारे में मुझे पता नहीं हो सकता है? क्या मैं कुछ हास्यास्पद कर रहा हूँ?

Answer 1

यह एक बहुत नाजुक दृष्टिकोण की तरह लगता है। ऑब्जेक्ट को असंगत स्थिति में रखने के लिए सक्रिय पुनरावृत्ति के दौरान __slots, __dc_list, __iter_cache को बदलने के लिए पर्याप्त है।

आपको या तो पुनरावृत्ति के दौरान वस्तु को बदलने या सभी कैश वस्तुओं को एक बार में उत्पन्न करने और सूची की एक प्रति वापस करने की आवश्यकता है।

Answer 2

container.__iter__() एक पुनरावर्तक वस्तु देता है। इटरेटर वस्तुओं खुद को निम्नलिखित दो विधियों, जो एक साथ इटरेटर प्रोटोकॉल के रूप में समर्थन करने के लिए आवश्यक हैं:

iterator.__iter__() 

रिटर्न इटरेटर वस्तु ही।

iterator.next() 

कंटेनर से अगला आइटम लौटें।

यह बिल्कुल जेनरेटर के समान है। तो किसी भी दुष्प्रभाव से डरो मत।

Answer 3

ऑब्जेक्ट के पुनरावृत्ति को अलग-अलग मानों के कैशिंग से अलग करना बेहतर हो सकता है। यह पुनरावृत्ति प्रक्रिया को सरल बना देगा और आपको आसानी से नियंत्रित करने की अनुमति देगा कि कैसे कैशिंग को पूरा किया जाता है और साथ ही यह सक्षम है या नहीं, उदाहरण के लिए।

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

Answer 4

आप जो भी कर रहे हैं वह अजीब है हालांकि वैध है। __slots या __dc_list क्या है ?? आम तौर पर अपने ऑब्जेक्ट की सामग्री को इसके प्रकार के बजाय विशेषता नाम में वर्णित करना बेहतर होता है (उदाहरण: self.u_list के बजाय self.users)।

आप इसे मेरे सरल बनाने के लिए अपने LazyProperty सजावट का उपयोग कर सकते हैं।

बस अपनी विधि @LazyProperty के साथ सजाने के लिए। इसे पहली बार बुलाया जाएगा, और सजावटी तब परिणामों के साथ विशेषता को प्रतिस्थापित करेगा। एकमात्र आवश्यकता यह है कि मूल्य दोहराया जा सकता है; यह परिवर्तनीय स्थिति पर निर्भर नहीं है। आपके पास अपने वर्तमान कोड में यह आवश्यकता भी है, अपने स्वयं के .__ iter_cache के साथ।

def __iter__(self) 
    return self.__iter 

@LazyProperty 
def __iter(self) 
    def my_generator(): 
     yield whatever 
    return tuple(my_generator())