कैश्ड_प्रोसेसर डेकोरेटर

आप कितनी बार इस तरह के निर्माण लिखते हैं?

class SomeClass(object): @property def param(self): if not hasattr(self, '_param'): self._param = computing() return self._param @param.setter def param(self, value): self._param = value @param.deleter def param(self): del self._param 

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

इस कोड के अपने minuses हैं: ऑब्जेक्ट में _param नामक एक अतिरिक्त विशेषता है; हर बार विशेषता को बुलाया जाता है, परम () पद्धति को कहा जाता है, जो हॅटट्रा करता है; परिणामी कोड काफी बड़ा है, खासकर अगर कक्षा में ऐसी कई विशेषताएं हैं।

आप वस्तु शब्दकोश के साथ सीधे काम करके _परम विशेषता से छुटकारा पा सकते हैं:

 class SomeClass(object): @property def param(self): if 'param' not in self.__dict__: self.__dict__['param'] = computing() return self.__dict__['param'] @param.setter def param(self, value): self.__dict__['param'] = value @param.deleter def param(self): del self.__dict__['param'] 

यहां, परिकलित मान उसी विवरण के साथ एक विशेषता में संग्रहीत किया जाता है, जो वर्णनकर्ता के समान नाम के साथ है। इस तथ्य के कारण कि @property डेकोरेटर एक डेटा डिस्क्रिप्टर बनाता है (घोषित विधि __set __ () कहे जाने वाले डिस्क्रिप्टर), हमारे गेटर्स और सेटर को निष्पादित किया जाता है, भले ही आवश्यक विशेषता ऑब्जेक्ट के डिक्शनरी __dict__ में हो। और इस तथ्य के कारण कि हम इस __dict__ के साथ सीधे काम करते हैं, ऑब्जेक्ट की विशेषताओं को दरकिनार करते हुए, कोई संघर्ष और अंतहीन पुनरावृत्ति नहीं होती है।

लेकिन ऊपर दिए गए कोड में अभी भी बहुत सारे सामान्य हिस्से हैं। एक ही विशेषता का दूसरा केवल कंप्यूटिंग () फ़ंक्शन में भिन्न होगा। आइए एक अलग डेकोरेटर बनाने की कोशिश करें जो सभी मोटे काम करेगा। और आप इस तरह के एक डेकोरेटर का उपयोग कर सकते हैं:

 class SomeClass(object): @cached_property def param(self): return computing() 

बाकी कोड डेकोरेटर डिस्क्रिप्टर को ही हस्तांतरित किया जाता है:

 class cached_property(object): def __init__(self, func): self.func = func self.name = func.__name__ def __get__(self, instance, cls=None): if self.name not in instance.__dict__: result = instance.__dict__[self.name] = self.func(instance) return result return instance.__dict__[self.name] def __set__(self, instance, value): instance.__dict__[self.name] = value def __delete__(self, instance): del instance.__dict__[self.name] 

कोई वहां रुक सकता था। लेकिन पायथन में, जैसे कि विशेष रूप से ऐसे मामलों के लिए, विवरणकर्ताओं को डेटा और गैर-डेटा विवरणकों में विभाजित किया जाता है। गैर-डेटा विवरणक में केवल __get __ () विधि होनी चाहिए, और विशेषता तक पहुंचने पर, इस विधि को नहीं बुलाया जाएगा यदि ऑब्जेक्ट के शब्दकोश में पहले से ही एक मूल्य है। यानी यदि हम __set __ () और __delete __ () विधियों को हटाते हैं, तो पायथन दुभाषिया स्वयं वस्तु के शब्दकोश में विशेषता के अस्तित्व की जांच करेगा। परिणामस्वरूप, कई बार @cached_property डेकोरेटर सरल हो जाता है:

 class cached_property(object): def __init__(self, func): self.func = func def __get__(self, instance, cls=None): result = instance.__dict__[self.func.__name__] = self.func(instance) return result 

इस तरह के डेकोरेटर का लंबे समय से पायथन में कई प्रोजेक्ट्स में इस्तेमाल किया गया है और इसे django.utils.functional से आयात किया जा सकता है, जो कि Django 1.4 के साथ शुरू होगा। इसका उपयोग इतना सरल और सस्ता है कि यह किसी भी स्थान पर इसका उपयोग करने के लायक है जहां आप कुछ विशेषताओं की गणना को स्थगित कर सकते हैं। उदाहरण के लिए:

 class SomeList(object): storage_pattern = 'some-list-by-pages-{}-{}' def __init__(self, page_num, per_page): self.page_num, self.per_page = page_num, per_page self.storage_key = self.storage_pattern.format(page_num, per_page) 

में परिवर्तित किया जा सकता है:

 class SomeList(object): storage_pattern = 'some-list-by-pages-{}-{}' def __init__(self, page_num, per_page): self.page_num, self.per_page = page_num, per_page @cached_property def storage_key(self): return self.storage_pattern.format(self.page_num, self.per_page)