@Pythonetc संकलन, मई 2019

यह मेरी @pythonetc फीड से पायथन टिप्स और प्रोग्रामिंग का ग्यारहवां चयन है।

← पिछला संग्रह


break एक अपवाद को ब्लॉक करता है यदि finally ब्लॉक में लागू किया जाता है, भले ही ब्लॉक except कोई भी हो:

 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 पर आधारित सभी छह विधियाँ बनाता है और इनमें से एक: __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 डेकोरेटर @saving_orig नहीं @saving_orig जो हम चाहते हैं कि फंक्शन में कई डेकोरेटर @saving_orig । फिर उनमें से प्रत्येक के लिए आपको 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 को तर्क के रूप में सज्जाकार की एक संख्या का समर्थन करके saving_orig किया जा सकता 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 पास 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 

सभी कोड यहाँ उपलब्ध है।