पायथन: उत्पादन में मेटाप्रोग्रामिंग। भाग दो

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

अब देखते हैं कि आप विधि कॉल कैसे बदल सकते हैं। आप उन्नत पायथन पाठ्यक्रम में मेटाप्रोग्रामिंग विकल्पों के बारे में अधिक जान सकते हैं।

डिबगिंग और अनुरेखण कॉल

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

निम्नलिखित मेटाक्लास कक्षा और उसके उदाहरणों में प्रत्येक विधि के निष्पादन समय को मापता है, साथ ही उदाहरण का निर्माण समय:

from contextlib import contextmanager import logging import time import wrapt @contextmanager def timing_context(operation_name): """       """ start_time = time.time() try: yield finally: logging.info('Operation "%s" completed in %0.2f seconds', operation_name, time.time() - start_time) @wrapt.decorator def timing(func, instance, args, kwargs): """       .     https://wrapt.readthedocs.io/en/latest/         """ with timing_context(func.__name__): return func(*args, **kwargs) class DebugMeta(type): def __new__(mcs, name, bases, attrs): for attr, method in attrs.items(): if not attr.startswith('_'): #     attrs[attr] = timing(method) return super().__new__(mcs, name, bases, attrs) def __call__(cls, *args, **kwargs): with timing_context(f'{cls.__name__} instance creation'): #      return super().__call__(*args, **kwargs) 

आइए कार्रवाई में डिबगिंग को देखें:

 class User(metaclass=DebugMeta): def __init__(self, name): self.name = name time.sleep(.7) def login(self): time.sleep(1) def logout(self): time.sleep(2) @classmethod def create(cls): time.sleep(.5) user = User('Michael') user.login() user.logout() user.create() #   INFO:__main__:Operation "User instance creation" completed in 0.70 seconds INFO:__main__:Operation "login" completed in 1.00 seconds INFO:__main__:Operation "logout" completed in 2.00 seconds INFO:__main__:Operation "create" completed in 0.50 seconds 

DebugMeta विस्तार करने की कोशिश DebugMeta और विधियों और उनके स्टैक-ट्रेस के हस्ताक्षर को लॉग करें।

एकाकी पैटर्न और वंशानुक्रम का निषेध

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

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

 class Singleton(type): instance = None def __call__(cls, *args, **kwargs): if cls.instance is None: cls.instance = super().__call__(*args, **kwargs) return cls.instance class User(metaclass=Singleton): def __init__(self, name): self.name = name def __repr__(self): return f'<User: {self.name}>' u1 = User('Pavel') #         u2 = User('Stepan') >>> id(u1) == id(u2) True >>> u2 <User: Pavel> >>> User.instance <User: Pavel> #   , ? >>> u1.instance.instance.instance.instance <User: Pavel> 

इस कार्यान्वयन में एक दिलचस्प बारीकियों है - चूंकि क्लास कंस्ट्रक्टर को दूसरी बार नहीं बुलाया जाता है, आप एक गलती कर सकते हैं और वहां आवश्यक पैरामीटर नहीं पास कर सकते हैं, और रनटाइम पर कुछ भी नहीं होगा यदि उदाहरण पहले ही बनाया गया है। उदाहरण के लिए:

 >>> User('Roman') <User: Roman> >>> User('Alexey', 'Petrovich', 66) #     ! <User: Roman> #     User       #    TypeError! 

अब एक और भी अधिक विदेशी विकल्प पर एक नज़र डालते हैं: एक विशेष वर्ग से विरासत पर प्रतिबंध।

 class FinalMeta(type): def __new__(mcs, name, bases, attrs): for cls in bases: if isinstance(cls, FinalMeta): raise TypeError(f"Can't inherit {name} class from final {cls.__name__}") return super().__new__(mcs, name, bases, attrs) class A(metaclass=FinalMeta): """   !""" pass class B(A): pass # TypeError: Can't inherit B class from final A #    ! 

मेटाक्लास पैरामीटर

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

उदाहरण के लिए, आप क्लास को घोषित करते समय मेटाक्लास पैरामीटर के लिए एक फंक्शन पास कर सकते हैं और कुछ शर्तों के आधार पर मेटाक्लासेस के विभिन्न उदाहरणों को वापस कर सकते हैं, उदाहरण के लिए:

 def get_meta(name, bases, attrs): if SOME_SETTING: return MetaClass1(name, bases, attrs) else: return MetaClass2(name, bases, attrs) class A(metaclass=get_meta): pass 

लेकिन अधिक दिलचस्प उदाहरण कक्षाओं की घोषणा करते समय extra_kwargs मापदंडों का उपयोग है। मान लीजिए कि आप किसी कक्षा में कुछ विधियों के व्यवहार को बदलने के लिए मेटाक्लास का उपयोग करना चाहते हैं, और प्रत्येक वर्ग के पास इन विधियों के अलग-अलग नाम हो सकते हैं। क्या करें? और यहाँ क्या है

 #   `DebugMeta`     class DebugMetaParametrized(type): def __new__(mcs, name, bases, attrs, **extra_kwargs): debug_methods = extra_kwargs.get('debug_methods', ()) for attr, value in attrs.items(): #      ,   #    `debug_methods`: if attr in debug_methods: attrs[attr] = timing(value) return super().__new__(mcs, name, bases, attrs) class User(metaclass=DebugMetaParametrized, debug_methods=('login', 'create')): ... user = User('Oleg') user.login() #  "logout"   . user.logout() user.create() 

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

__prepare__ विधि __prepare__

अंत में, मैं __prepare__ विधि के संभावित उपयोग के बारे में बात __prepare__ । जैसा कि ऊपर उल्लेख किया गया है, इस विधि को एक डिक्शनरी ऑब्जेक्ट वापस करना चाहिए, जो दुभाषिया वर्ग शरीर को पार्स करने के क्षण में भरता है, उदाहरण के लिए, यदि __prepare__ ऑब्जेक्ट d = dict() __prepare__ d = dict() लौटाता है, तो निम्न वर्ग को पढ़ते समय:

 class A: x = 12 y = 'abc' z = {1: 2} 

दुभाषिया निम्नलिखित कार्य करेगा:

 d['x'] = 12 d['y'] = 'abc' d['z'] = {1: 2} 

इस सुविधा के लिए कई संभावित उपयोग हैं। वे उपयोगिता की डिग्री बदलती के सभी हैं, इसलिए:

1. पाइथन = <3.5 के संस्करणों में, यदि हमें कक्षा में विधियों की घोषणा के क्रम को बनाए रखने की आवश्यकता है, तो हम collections.OrderedDict वापस कर सकते हैं। पुराने संस्करण में __prepare__ विधि से __prepare__ , अंतर्निहित शब्दकोश पहले से ही कुंजियों को जोड़ने के क्रम को बनाए रखते हैं, इसलिए OrderedDict अब आवश्यकता नहीं है।
2. enum मानक लाइब्रेरी मॉड्यूल यह निर्धारित करने के लिए कस्टम तानाशाह जैसी वस्तु का उपयोग करता है जब घोषणा पर एक वर्ग विशेषता को दोहराया जाता है। यहां कोड पाया जा सकता है ।
3. उत्पादन-तैयार कोड बिल्कुल नहीं, लेकिन एक बहुत अच्छा उदाहरण पैरामीट्रिक बहुरूपता के लिए समर्थन है ।

उदाहरण के लिए, एकल पॉलीमॉर्फिक पद्धति के तीन कार्यान्वयनों के साथ निम्न वर्ग पर विचार करें:

 class Terminator: def terminate(self, x: int): print(f'Terminating INTEGER {x}') def terminate(self, x: str): print(f'Terminating STRING {x}') def terminate(self, x: dict): print(f'Terminating DICTIONARY {x}') t1000 = Terminator() t1000.terminate(10) t1000.terminate('Hello, world!') t1000.terminate({'hello': 'world'}) #  Terminating DICTIONARY 10 Terminating DICTIONARY Hello, world! Terminating DICTIONARY {'hello': 'world'} 

जाहिर है, अंतिम घोषित terminate विधि पहले दो के कार्यान्वयन को अधिलेखित करती है, और हमें तर्क के प्रकार के आधार पर विधि का चयन करने की आवश्यकता है। इसे प्राप्त करने के लिए, हम कुछ अतिरिक्त आवरण वस्तुओं का कार्यक्रम करते हैं:

 class PolyDict(dict): """ ,               PolyMethod. """ def __setitem__(self, key: str, func): if not key.startswith('_'): if key not in self: super().__setitem__(key, PolyMethod()) self[key].add_implementation(func) return None return super().__setitem__(key, func) class PolyMethod: """    ,            .       ,       : instance method, staticmethod, classmethod. """ def __init__(self): self.implementations = {} self.instance = None self.cls = None def __get__(self, instance, cls): self.instance = instance self.cls = cls return self def _get_callable_func(self, impl): # ""  classmethod/staticmethod return getattr(impl, '__func__', impl) def __call__(self, arg): impl = self.implementations[type(arg)] callable_func = self._get_callable_func(impl) if isinstance(impl, staticmethod): return callable_func(arg) elif self.cls and isinstance(impl, classmethod): return callable_func(self.cls, arg) else: return callable_func(self.instance, arg) def add_implementation(self, func): callable_func = self._get_callable_func(func) #   ,     1  arg_name, arg_type = list(callable_func.__annotations__.items())[0] self.implementations[arg_type] = func 

ऊपर दिए गए कोड में सबसे दिलचस्प बात PolyMethod ऑब्जेक्ट है, जो इस पद्धति को पारित किए गए तर्क के प्रकार के आधार पर एक ही विधि के कार्यान्वयन के साथ एक रजिस्ट्री संग्रहीत करता है। हम __prepare__ विधि से PolyDict ऑब्जेक्ट वापस करेंगे और इस तरह एक ही नाम terminate साथ तरीकों के विभिन्न कार्यान्वयन को बचाएंगे। एक महत्वपूर्ण बिंदु - कक्षा के शरीर को पढ़ते समय और attrs ऑब्जेक्ट बनाते समय, दुभाषिया तथाकथित unbound फ़ंक्शन को वहां रखता है, ये फ़ंक्शन अभी तक नहीं जानते हैं कि उन्हें किस क्लास या उदाहरण पर बुलाया जाएगा। हमें फंक्शन कॉल के दौरान संदर्भ को परिभाषित करने के लिए डिस्क्रिप्टर प्रोटोकॉल लागू करना था और या तो self या staticmethod पहले पैरामीटर के रूप में पास करना चाहिए, या कुछ भी नहीं पास करना होगा, अगर staticmethod कहा जाता है।

परिणामस्वरूप, हम निम्नलिखित जादू देखेंगे:

 class PolyMeta(type): @classmethod def __prepare__(mcs, name, bases): return PolyDict() class Terminator(metaclass=PolyMeta): ... t1000 = Terminator() t1000.terminate(10) t1000.terminate('Hello, world!') t1000.terminate({'hello': 'world'}) #  Terminating INTEGER 10 Terminating STRING Hello, world! Terminating DICTIONARY {'hello': 'world'} >>> t1000.terminate <__main__.PolyMethod object at 0xdeadcafe> 

यदि आप __prepare__ विधि के किसी अन्य दिलचस्प उपयोग के बारे में __prepare__ , तो कृपया टिप्पणियों में लिखें।

निष्कर्ष

Metaprogramming उन कई विषयों में से एक है, जिनके बारे में मैंने उन्नत पायथन में बात की है। पाठ्यक्रम के हिस्से के रूप में, मैं आपको यह भी बताऊंगा कि बड़े पायथन प्रोजेक्ट्स के विकास में SOLID और GRASP के सिद्धांतों का प्रभावी ढंग से उपयोग कैसे करें, एप्लिकेशन आर्किटेक्चर को डिज़ाइन करें और उच्च-प्रदर्शन और उच्च-गुणवत्ता वाला कोड लिखें। मुझे आपको बाइनरी जिले की दीवारों में देखकर खुशी होगी!