मेरे टेलीग्राम-चैनल @pythonetc, मई 2019 से टिप्स और ट्रिक्स

यह मेरे टेलीग्राम-चैनल @pythonetc से पायथन और प्रोग्रामिंग के बारे में सुझावों और ट्रिक्स का एक नया चयन है।

Ations पिछला प्रकाशन


break स्टेटमेंट अपवाद को दबा break , जब finally में ब्लॉक को प्रस्तुत नहीं किए जाने पर भी finally में उपयोग किया जाता है:

 for i in range(10): try: 1 / i finally: print('finally') break print('after try') print('after while') 

आउटपुट:

 finally after while 

continue लिए भी यही सच है, हालाँकि इसे finally पायथन 3.8 तक उपयोग नहीं किया जा सकता है:

 SyntaxError: 'continue' not supported inside 'finally' clause 

आप एक स्ट्रिंग शाब्दिक में यूनिकोड वर्णों को न केवल इसकी संख्या से जोड़ सकते हैं, बल्कि इसके नाम से भी जोड़ सकते हैं।

 >>> '\N{EM DASH}' '—' >>> '\u2014' '—' 

यह एफ-स्ट्रिंग्स के साथ भी संगत है:

 >>> width = 800 >>> f'Width \N{EM DASH} {width}' 'Width — 800' 

पायथन ऑब्जेक्ट्स के लिए छह जादू के तरीके हैं जो तुलना नियमों को परिभाषित करते हैं:

• __lt__ लिए <
  
• __gt__ लिए >
  
• __le__ लिए <=
  
• __ge__ लिए >=
  
• __eq__ लिए ==
  
• __ne__ लिए !=
  

यदि इनमें से कुछ विधियाँ परिभाषित नहीं हैं या NotImplemented , तो निम्नलिखित नियम लागू होते हैं:

• a.__lt__(b) b.__gt__(a)
• a.__le__(b) b.__ge__(a)
• a.__eq__(b) एक ही not a.__ne__(b) (इस मामले में a और b को स्वैप नहीं किया जाता है)

हालांकि, a >= b और a != b स्वचालित रूप से a > b । functools.total_ordering । functools.total_ordering डेकोरेटर __eq__ और निम्न में से एक पर आधारित सभी छह विधियाँ बनाते हैं: __lt__ , __gt__ , __le__ , या __ge__ ।

 from functools import total_ordering @total_ordering class User: def __init__(self, pk, name): self.pk = pk self.name = name def __le__(self, other): return self.pk <= other.pk def __eq__(self, other): return self.pk == other.pk assert User(2, 'Vadim') < User(13, 'Catherine') 

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

 import json def ensure_list(f): def decorated(*args, **kwargs): result = f(*args, **kwargs) if isinstance(result, list): return result else: return [result] return decorated def load_data_orig(string): return json.loads(string) load_data = ensure_list(load_data_orig) print(load_data('3')) # [3] print(load_data_orig('4')) 4 

वैकल्पिक रूप से, आप एक अन्य डेकोरेटर लिख सकते हैं, जो नए के orig गुण में इसके मूल संस्करण को संरक्षित करते हुए एक फ़ंक्शन को सजाते हैं:

 import json def saving_orig(another_decorator): def decorator(f): decorated = another_decorator(f) decorated.orig = f return decorated return decorator def ensure_list(f): ... @saving_orig(ensure_list) def load_data(string): return json.loads(string) print(load_data('3')) # [3] print(load_data.orig('4')) # 4 

यदि सभी सज्जाकार आपके साथ काम कर रहे हैं, तो आप functools.wraps के माध्यम से functools.wraps तो आप __wrapped__ फ़ंक्शन तक पहुंचने के लिए __wrapped__ विशेषता का उपयोग कर सकते हैं:

 import json from functools import wraps def ensure_list(f): @wraps(f) def decorated(*args, **kwargs): result = f(*args, **kwargs) if isinstance(result, list): return result else: return [result] return decorated @ensure_list def load_data(string): return json.loads(string) print(load_data('3')) # [3] print(load_data.__wrapped__('4')) # 4 

मन, हालांकि, यह उन कार्यों के लिए काम नहीं करता है जो एक से अधिक डेकोरेटर द्वारा सजाए गए हैं: आपको लागू किए गए प्रत्येक डेकोरेटर के लिए __wrapped__ का उपयोग __wrapped__ :

 def ensure_list(f): ... def ensure_ints(f): @wraps(f) def decorated(*args, **kwargs): result = f(*args, **kwargs) return [int(x) for x in result] return decorated @ensure_ints @ensure_list def load_data(string): return json.loads(string) for f in ( load_data, load_data.__wrapped__, load_data.__wrapped__.__wrapped__, ): print(repr(f('"4"'))) 

आउटपुट:

 [4] ['4'] '4' 

ऊपर उल्लिखित @saving_orig एक अन्य सज्जाकार को एक तर्क के रूप में स्वीकार करता है। क्या होगा अगर उस डेकोरेटर को पैराट्राइज्ड किया जा सकता है? खैर, चूंकि पैरामीटराइज़र डेकोरेटर एक फ़ंक्शन है जो एक वास्तविक डेकोरेटर लौटाता है, यह मामला स्वचालित रूप से नियंत्रित किया जाता है:

 import json from functools import wraps def saving_orig(another_decorator): def decorator(f): decorated = another_decorator(f) decorated.orig = f return decorated return decorator def ensure_ints(*, default=None): def decorator(f): @wraps(f) def decorated(*args, **kwargs): result = f(*args, **kwargs) ints = [] for x in result: try: x_int = int(x) except ValueError: if default is None: raise else: x_int = default ints.append(x_int) return ints return decorated return decorator @saving_orig(ensure_ints(default=0)) def load_data(string): return json.loads(string) print(repr(load_data('["2", "3", "A"]'))) print(repr(load_data.orig('["2", "3", "A"]'))) 

@saving_orig डेकोरेटर वास्तव में वह नहीं करता है जो हम चाहते हैं कि एक फ़ंक्शन पर एक से अधिक डेकोरेटर लागू हों। हमें प्रत्येक ऐसे डेकोरेटर के लिए कॉल करना होगा:

 import json from functools import wraps def saving_orig(another_decorator): def decorator(f): decorated = another_decorator(f) decorated.orig = f return decorated return decorator def ensure_list(f): ... def ensure_ints(*, default=None): ... @saving_orig(ensure_ints(default=42)) @saving_orig(ensure_list) def load_data(string): return json.loads(string) for f in ( load_data, load_data.orig, load_data.orig.orig, ): print(repr(f('"X"'))) 

आउटपुट:

 [42] ['X'] 'X' 

हम saving_orig तर्कों के रूप में सज्जाकारों की मनमानी संख्या का समर्थन करके इसे ठीक कर सकते हैं:

 def saving_orig(*decorators): def decorator(f): decorated = f for d in reversed(decorators): decorated = d(decorated) decorated.orig = f return decorated return decorator ... @saving_orig( ensure_ints(default=42), ensure_list, ) def load_data(string): return json.loads(string) for f in ( load_data, load_data.orig, ): print(repr(f('"X"'))) 

आउटपुट:

 [42] 'X' 

एक और उपाय है saving_orig स्मार्ट बनाना saving_orig एक सजाया फंक्शन से दूसरे में पास हो सके:

 def saving_orig(another_decorator): def decorator(f): decorated = another_decorator(f) if hasattr(f, 'orig'): decorated.orig = f.orig else: decorated.orig = f return decorated return decorator @saving_orig(ensure_ints(default=42)) @saving_orig(ensure_list) def load_data(string): return json.loads(string) 

यदि आप जो डेकोरेटर लिख रहे हैं वह बहुत जटिल हो जाता है, तो इसे __call__ विधि के साथ एक फंक्शन से क्लास में बदलना उचित हो सकता है

 class SavingOrig: def __init__(self, another_decorator): self._another = another_decorator def __call__(self, f): decorated = self._another(f) if hasattr(f, 'orig'): decorated.orig = f.orig else: decorated.orig = f return decorated saving_orig = SavingOrig 

अंतिम पंक्ति आपको ऊंट मामले के साथ वर्ग का नाम और डेकोरेटर का नाम साँप के मामले में रखने की अनुमति देती है।

सजाए गए फ़ंक्शन को संशोधित करने के बजाय आप एक फ़ंक्शन के बजाय अपने इंस्टेंस को वापस करने के लिए एक और कॉल करने योग्य वर्ग बना सकते हैं:

 class CallableWithOrig: def __init__(self, to_call, orig): self._to_call = to_call self._orig = orig def __call__(self, *args, **kwargs): return self._to_call(*args, **kwargs) @property def orig(self): if isinstance(self._orig, type(self)): return self._orig.orig else: return self._orig class SavingOrig: def __init__(self, another_decorator): self._another = another_decorator def __call__(self, f): return CallableWithOrig(self._another(f), f) saving_orig = SavingOrig 

पूरा कोड यहां देखें