अजगर में धाराप्रवाह इंटरफेस का आयोजन

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

पहला तरीका - माथे में

ऑपरेटरों की एक श्रृंखला बनाने के लिए, हमें कक्षा की एक आवृत्ति वापस करने के लिए फ़ंक्शन की आवश्यकता होती है। यह मैन्युअल रूप से सेट किया जा सकता है।

def add(self,x): self.val += x return self 

जाहिर है, यह दृष्टिकोण पूरी तरह से काम करता है, लेकिन हम थोड़ा और तलाश कर रहे हैं।

दूसरा तरीका - सज्जाकार

यह पहला विचार है जो मन में आया। कक्षा में विधियों के लिए डेकोरेटर को परिभाषित करें। हम बहुत खुश हैं कि उदाहरण को पहले तर्क के रूप में पारित किया गया है।

 def chained(fn): def new(*args,**kwargs): fn(*args,**kwargs) return args[0] return new class UsefulClass1(): def __init__(self,val): self.val = val @chained def add(self,val): self.val += val @chained def mul(self,val): self.val *= val 

हम बस सज्जाकार के साथ उन कार्यों को चिह्नित करते हैं जिन्हें श्रृंखला में उपयोग करने की आवश्यकता होती है। वापसी मान को नजरअंदाज कर दिया जाता है और इसके बजाय एक वर्ग उदाहरण दिया जाता है।

 >>> print UsefulClass1(10).add(5).mul(10).add(1).val 151 

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

तीसरा तरीका - स्वचालित

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

 from types import MethodType class Chain(object): def __getattribute__(self,item): fn = object.__getattribute__(self,item) if fn and type(fn)==MethodType: def chained(*args,**kwargs): ans = fn(*args,**kwargs) return ans if ans!=None else self return chained return fn class UsefulClass2(Chain): val = 1 def add(self,val): self.val += val def mul(self,val): self.val *= val def third(self): return 386 

यदि विधि एक मान लौटाती है, तो इसे पारित किया जाता है। यदि नहीं, तो इसके बजाय कक्षा का उदाहरण खुद ही हो जाता है।

 >>> print UsefulClass2().add(15).mul(16).add(-5).val 251 >>> print UsefulClass2().third() 386 

अब हमें किसी भी तरह से श्रमिक वर्ग को संशोधित करने की आवश्यकता नहीं है सिवाय इसके कि जंजीर वर्ग को माता-पिता में से एक के रूप में निर्दिष्ट करें। स्पष्ट दोष यह है कि हम अपने उद्देश्यों के लिए __getattribute__ का उपयोग नहीं कर सकते हैं।

चौथा तरीका - Im So Meta ...

श्रमिक वर्ग के आवश्यक आवरण को व्यवस्थित करने के लिए हम मेटाक्लस का उपयोग कर सकते हैं। बाद को शुरू करते समय, हम मक्खी पर __getattribute__ लपेटेंगे (और इसकी अनुपस्थिति हमें या तो परेशान नहीं करती है)।

 from types import MethodType class MetaChain(type): def __new__(cls,name,bases,dict): old = dict.get('__getattribute__',object.__getattribute__) def new_getattribute(inst,val): attr = old(inst,val) if attr==None: return inst if attr and type(attr)==MethodType: def new(*args,**kwargs): ans = attr(*args,**kwargs) return ans if ans!=None else inst return new return attr dict['__getattribute__'] = new_getattribute return type.__new__(cls,name,bases,dict) class UsefulClass3(): __metaclass__ = MetaChain def __getattribute__(self,item): if item=="dp": return 493 return object.__getattribute__(self,item) val = 1 def add(self,val): self.val += val def mul(self,val): self.val *= val 

यह व्यावहारिक रूप से पिछले एक से अलग नहीं है - हम केवल मेटाक्लेश का उपयोग करके __getattribute__ के निर्माण को नियंत्रित करते हैं। श्रमिक वर्ग को लपेटने के लिए, केवल __metaclass__ निर्दिष्ट करें।

 >>> print UsefulClass3().dp 493 >>> print UsefulClass3().add(4).mul(5).add(1).mul(25).add(-1).val 649 

जैसा कि आप देख सकते हैं, __getattribute__ मूल रूप से श्रमिक वर्ग के कार्यों में उपलब्ध है। जब श्रमिक वर्ग से विरासत में मिला, तो व्यवहार संरक्षित है - __getattribute__ भी विरासत में मिला है। यदि मूल __getattribute__ कुछ भी (यहां तक ​​कि एट्रीब्यूट) भी वापस नहीं करता है, तो हम ऑब्जेक्ट को भी वापस करते हैं।

एक निष्कर्ष के बजाय

यद्यपि द्रव इंटरफेस का सर्वव्यापी उपयोग संदिग्ध है, फिर भी ऐसे मामले हैं जहां ऐसी संरचनाएं उपयुक्त होंगी। कहो, छवि प्रसंस्करण या किसी भी संस्था जिसके ऊपर कई संचालन क्रमिक रूप से किए जाते हैं।

PS अंतिम विकल्प, मेरी राय में, इसमें स्पष्ट कमियाँ नहीं हैं। अगर कोई सबसे अच्छा विकल्प दे सकता है - तो मुझे खुशी होगी, साथ ही मेरी कमियों के संकेत भी मिलेंगे।

PPS श्रमिकों के अनुरोध पर, विकिपीडिया पर उल्लिखित लेख और विवरण के लिंक देता है

अद्यतन

पांचवीं विधि - भुट्टा और चूल्हा

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

 class NewMetaChain(type): def __new__(cls,name,bases,dict): old = dict.get('__setattr__',object.__setattr__) def wrap(fn,inst=None): def new(*args,**kwargs): ans = fn(*args,**kwargs) return ans if ans!=None else inst or args[0] return new special = dir(cls) for item, fn in dict.items(): if item not in special and isinstance(fn,FunctionType): dict[item] = wrap(fn) def new_setattr(inst,item,val): if isinstance(val,FunctionType): val = wrap(val,inst) return old(inst,item,val) dict['__setattr__'] = new_setattr return type.__new__(cls,name,bases,dict) class UsefulClass4(): __metaclass__ = NewMetaChain def __setattr__(self,item,val): if val == 172: val = "giza" object.__setattr__(self, item, val) val = 1 def add(self,val): self.val += val def mul(self,val): self.val *= val def nul(self): pass 

इस तथ्य के अलावा कि अब हम हर कॉल के साथ रैप विधियां नहीं करते हैं (जो कि गति में ~ 30% की वृद्धि हुई है), हम आवश्यक चेक को ऑब्जेक्ट के क्षेत्रों के प्रत्येक रीडिंग पर नहीं, बल्कि प्रत्येक रिकॉर्ड पर भी करते हैं (जो अक्सर कम होता है)। यदि कोई प्रविष्टि नहीं है, तो यह डेकोरेटर विधि के रूप में तेजी से काम करता है।