पायथन v3.x: पंजीकरण और एसएमएस के बिना डेकोरेटर गति कैसे बढ़ाएं

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

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

तो चलिए शुरू करते हैं। आइए अटकलें लगाते हैं कि सामान्य रूप से क्या अड़चनें थीं।

लगातार अगर:

if isinstance(self.custom_handlers, property): if self.custom_handlers and e.__class__ in self.custom_handlers: if e.__class__ not in self.exclude: 

और यह सीमा नहीं है। इसलिए, मैंने ifs का हिस्सा हटा दिया, __in__ को कुछ स्थानांतरित कर दिया, अर्थात्। जहां यह एक बार बुलाया जाएगा। विशेष रूप से, कोड में संपत्ति के लिए जाँच को एक बार बुलाया जाना चाहिए, क्योंकि डेकोरेटर विधि के लिए लागू किया जाता है और इसे सौंपा जाता है। और क्रमशः वर्ग की संपत्ति अपरिवर्तित रहेगी। इसलिए, संपत्ति की लगातार जांच करने की आवश्यकता नहीं है।

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

 self.handlers.get(e.__class__, Exception)(e) 

इसलिए सेल्फहैंडलर्स में हमारे पास एक तानाशाही है, जो कि डिफ़ॉल्ट के रूप में एक फ़ंक्शन है जो अन्य अपवादों को उठाता है।

बेशक, आवरण विशेष ध्यान देने योग्य है। यह वही फ़ंक्शन है जिसे हर बार डेकोरेटर कहा जाता है। यानी यहां अनावश्यक जांचों और सभी प्रकार के वर्कलोड से जितना संभव हो उतना बेहतर है, यदि संभव हो तो उन्हें __init__ या __call__ में डाल दें। यहाँ क्या आवरण पहले था:

 def wrapper(self, *args, **kwargs): if self.custom_handlers: if isinstance(self.custom_handlers, property): self.custom_handlers = self.custom_handlers.__get__(self, self.__class__) if asyncio.iscoroutinefunction(self.func): return self._coroutine_exception_handler(*args, **kwargs) else: return self._sync_exception_handler(*args, **kwargs) 

चेकों की संख्या छत से होकर जाती है। यह सभी डेकोरेटर को हर कॉल पर बुलाया जाएगा। इसलिए रैपर इस तरह बने:

  def __call__(self, func): self.func = func if iscoroutinefunction(self.func): def wrapper(*args, **kwargs): return self._coroutine_exception_handler(*args, **kwargs) else: def wrapper(*args, **kwargs): return self._sync_exception_handler(*args, **kwargs) return wrapper 

याद रखें, __call__ को एक बार बुलाया जाएगा। __Call__ के अंदर, फ़ंक्शन की अतुल्यकालिकता की डिग्री के आधार पर, हम फ़ंक्शन को स्वयं या कोरटाइन वापस करते हैं। और मैं यह भी नोट करना चाहता हूं कि asyncio.iscoroutinefunction एक अतिरिक्त कॉल करता है, इसलिए मैंने स्विच किया। निरीक्षण करने के लिए। वास्तव में, asyncio और निरीक्षण के लिए बेंच (cProfile):

  ncalls tottime percall cumtime percall filename:lineno(function) 1 0.000 0.000 0.000 0.000 <string>:1(<module>) 1 0.000 0.000 0.000 0.000 coroutines.py:160(iscoroutinefunction) 1 0.000 0.000 0.000 0.000 inspect.py:158(isfunction) 1 0.000 0.000 0.000 0.000 inspect.py:179(iscoroutinefunction) 1 0.000 0.000 0.000 0.000 {built-in method builtins.exec} 1 0.000 0.000 0.000 0.000 {built-in method builtins.isinstance} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} 

  ncalls tottime percall cumtime percall filename:lineno(function) 1 0.000 0.000 0.000 0.000 <string>:1(<module>) 1 0.000 0.000 0.000 0.000 inspect.py:158(isfunction) 1 0.000 0.000 0.000 0.000 inspect.py:179(iscoroutinefunction) 1 0.000 0.000 0.000 0.000 {built-in method builtins.exec} 1 0.000 0.000 0.000 0.000 {built-in method builtins.isinstance} 1 0.000 0.000 0.000 0.000 {method 'disable' of '_lsprof.Profiler' objects} 

पूर्ण कोड:

 from inspect import iscoroutinefunction from asyncio import QueueEmpty, QueueFull from concurrent.futures import TimeoutError class ProcessException(object): __slots__ = ('func', 'handlers') def __init__(self, custom_handlers=None): self.func = None if isinstance(custom_handlers, property): custom_handlers = custom_handlers.__get__(self, self.__class__) def raise_exception(e: Exception): raise e exclude = { QueueEmpty: lambda e: None, QueueFull: lambda e: None, TimeoutError: lambda e: None } self.handlers = { **exclude, **(custom_handlers or {}), Exception: raise_exception } def __call__(self, func): self.func = func if iscoroutinefunction(self.func): def wrapper(*args, **kwargs): return self._coroutine_exception_handler(*args, **kwargs) else: def wrapper(*args, **kwargs): return self._sync_exception_handler(*args, **kwargs) return wrapper async def _coroutine_exception_handler(self, *args, **kwargs): try: return await self.func(*args, **kwargs) except Exception as e: return self.handlers.get(e.__class__, Exception)(e) def _sync_exception_handler(self, *args, **kwargs): try: return self.func(*args, **kwargs) except Exception as e: return self.handlers.get(e.__class__, Exception)(e) 

और शायद उदाहरण समय के बिना अधूरा होगा। इसलिए, उपरोक्त टिप्पणी से उदाहरण का उपयोग करते हुए:

 class MathWithTry(object): def divide(self, a, b): try: return a // b except ZeroDivisionError: return '   ,   ' 

और पिछले लेख के पाठ से एक उदाहरण ( ध्यान! हम लैम्ब्डा में पाठ से उदाहरण के लिए ई पास करते हैं। पिछले लेख में यह नहीं था और केवल नवाचारों में जोड़ा गया था)।

 class Math(object): @property def exception_handlers(self): return { ZeroDivisionError: lambda e: '   ,   ' } @ProcessException(exception_handlers) def divide(self, a, b): return a // b 

यहाँ आप के लिए परिणाम हैं:

 timeit.timeit('math_with_try.divide(1, 0)', number=100000, setup='from __main__ import math_with_try') 0.05079065300014918 timeit.timeit('math_with_decorator.divide(1, 0)', number=100000, setup='from __main__ import math_with_decorator') 0.16211646200099494 

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

आपकी टिप्पणी के लिए धन्यवाद। मैं इस लेख पर भी टिप्पणियों के लिए तत्पर हूं :)

PS हैबर के उपयोगकर्ताओं की टिप्पणियों के लिए धन्यवाद और भी तेजी लाने के लिए संभव था, यही हुआ है:

 from inspect import iscoroutinefunction from asyncio import QueueEmpty, QueueFull from concurrent.futures import TimeoutError class ProcessException(object): __slots__ = ('handlers',) def __init__(self, custom_handlers=None): if isinstance(custom_handlers, property): custom_handlers = custom_handlers.__get__(self, self.__class__) raise_exception = ProcessException.raise_exception exclude = { QueueEmpty: lambda e: None, QueueFull: lambda e: None, TimeoutError: lambda e: None } self.handlers = { **exclude, **(custom_handlers or {}), Exception: raise_exception } def __call__(self, func): handlers = self.handlers if iscoroutinefunction(func): async def wrapper(*args, **kwargs): try: return await func(*args, **kwargs) except Exception as e: return handlers.get(e.__class__, handlers[Exception])(e) else: def wrapper(*args, **kwargs): try: return func(*args, **kwargs) except Exception as e: return handlers.get(e.__class__, handlers[Exception])(e) return wrapper @staticmethod def raise_exception(e: Exception): raise e 

 timeit.timeit('divide(1, 0)', number=100000, setup='from __main__ import divide') 0.13714907199755544 

औसतन 0.03 द्वारा त्वरित। Kostiantyn और Yngvie को धन्यवाद।

पुनश्च अद्यतन! मैंने आगे भी onegreyonewhite और resetme की टिप्पणियों के आधार पर कोड को अनुकूलित किया है। बस कवक के साथ स्वयं को बदल दिया और एक चर में स्व.हैंडलर बना दिया। निष्पादन में और तेजी लाई गई, विशेष रूप से ध्यान देने योग्य है अगर प्रति शून्य अधिक पुनरावृत्ति हो। मैं बोली समय:

 timeit.timeit('t.divide_with_decorator(1, 0)', number=1000000, setup='from __main__ import t') 1.1116105649998644 

इस अनुकूलन से पहले, समान संख्या मान के साथ निष्पादन ने औसतन 1.24 लिया।

PS मैंने @staticmethod में __init__ से raise_exception फ़ंक्शन की शुरुआत करके और भी अधिक अनुकूलित किया है और मैं एक चर के माध्यम से पहुंच को हटाने के लिए इसे चर के माध्यम से एक्सेस कर रहा हूं। दरअसल, औसत निष्पादन समय बन गया है:

 timeit.timeit('t.divide_with_decorator(1, 0)', number=1000000, setup='from __main__ import t') 1.0691639049982768 

यह विधि के लिए है। और कार्यों को और भी तेज कहा जाता है (औसतन):

 timeit.timeit('div(1, 0)', number=1000000, setup='from __main__ import div') 1.0463485610016505