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

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

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


यदि किसी वर्ग के उदाहरण में दिए गए नाम के साथ कोई विशेषता नहीं है, तो वह उसी नाम के साथ वर्ग विशेषता तक पहुंचने का प्रयास करता है।

>>> class A: ... x = 2 ... >>> Ax 2 >>> A().x 2 

उदाहरण के लिए यह विशेषता काफी सरल है कि किसी वर्ग के पास अलग-अलग मूल्य के साथ विशेषता है या नहीं:

 >>> class A: ... x = 2 ... def __init__(self): ... self.x = 3 ... self.y = 4 ... >>> A().x 3 >>> Ax 2 >>> A().y 4 >>> Ay AttributeError: type object 'A' has no attribute 'y' 

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

 class ClassOnlyDescriptor: def __init__(self, value): self._value = value self._name = None # see __set_name__ def __get__(self, instance, owner): if instance is not None: raise AttributeError( f'{instance} has no attribute {self._name}' ) return self._value def __set_name__(self, owner, name): self._name = name class_only = ClassOnlyDescriptor class A: x = class_only(2) print(Ax) # 2 A().x # raises AttributeError 

यह भी देखें कि Django classonlymethod डेकोरेटर कैसे काम करता है: https://github.com/django/django/blob/b709d701303b3877387020c1558a590713b9853/django/decorators.py#L6


एक वर्ग निकाय में घोषित कार्य वर्ग गुंजाइश नहीं देख सकते हैं। यह समझ में आता है क्योंकि वर्ग का दायरा केवल कक्षा निर्माण के दौरान ही मौजूद है।

 >>> class A: ... x = 2 ... def f(): ... print(x) ... f() ... [...] NameError: name 'x' is not defined 

यह आमतौर पर एक समस्या नहीं है: विधियों को एक वर्ग के अंदर घोषित किया जाता है केवल विधियाँ बनने के लिए और बाद में कहा जाता है:

 >>> class A: ... x = 2 ... def f(self): ... print(self.x) ... >>> >>> >>> A().f() 2 

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

 >>> class A: ... x = 2 ... y = [x for _ in range(5)] ... [...] NameError: name 'x' is not defined 

हालांकि, समझ में self कोई पहुंच नहीं है। इसका काम करने का एकमात्र तरीका एक और गुंजाइश जोड़ना है (हां, यह बदसूरत है):

 >>> class A: ... x = 2 ... y = (lambda x=x: [x for _ in range(5)])() ... >>> Ay [2, 2, 2, 2, 2] 

पायथन में, None किसी के बराबर None है, इसलिए ऐसा लगता है कि आप None साथ None जांच None कर सकते == :

 ES_TAILS = ('s', 'x', 'z', 'ch', 'sh') def make_plural(word, exceptions=None): if exceptions == None: # ← ← ← exceptions = {} if word in exceptions: return exceptions[word] elif any(word.endswith(t) for t in ES_TAILS): return word + 'es' elif word.endswith('y'): return word[0:-1] + 'ies' else: return word + 's' exceptions = dict( mouse='mice', ) print(make_plural('python')) print(make_plural('bash')) print(make_plural('ruby')) print(make_plural('mouse', exceptions=exceptions)) 

हालांकि यह एक गलत बात है। None भी वास्तव में None बराबर है, लेकिन यह केवल एक चीज नहीं है। कस्टम ऑब्जेक्ट किसी के भी बराबर हो सकते हैं:

 >>> class A: ... def __eq__(self, other): ... return True ... >>> A() == None True >>> A() is None False 

None साथ तुलना करने का एकमात्र उचित तरीका None is None ।


पायथन फ्लोट में NaN मान हो सकते हैं। आप math.nan साथ एक प्राप्त कर सकते हैं। nan स्वयं सहित किसी भी चीज़ के बराबर नहीं है:

 >>> math.nan == math.nan False 

इसके अलावा, NaN ऑब्जेक्ट अद्वितीय नहीं है, आपके पास विभिन्न स्रोतों से कई अलग-अलग NaN ऑब्जेक्ट हो सकते हैं:

 >>> float('nan') nan >>> float('nan') is float('nan') False 

इसका मतलब है कि आप आम तौर पर NaN को एक शब्दकोश कुंजी के रूप में उपयोग नहीं कर सकते हैं:

 >>> d = {} >>> d[float('nan')] = 1 >>> d[float('nan')] = 2 >>> d {nan: 1, nan: 2} 

typing आपको जनरेटर के लिए प्रकार को परिभाषित करने की अनुमति देता है। आप अतिरिक्त रूप से निर्दिष्ट कर सकते हैं कि किस प्रकार की उपज है, किस प्रकार को एक जनरेटर में भेजा जा सकता है और क्या लौटाया जाता है। Generator[int, None, bool] g.send() Generator[int, None, bool] एक जनरेटर है जो पूर्णांक देता है, बूलियन मान देता है और g.send() समर्थन नहीं करता है।

यहाँ थोड़ा और अधिक जटिल उदाहरण है। chain_while जनरेटर अन्य जनरेटर से उपज देता है, जब तक कि उनमें से कोई एक ऐसी चीज नहीं लौटाता है जो condition फ़ंक्शन के अनुसार रुकने का संकेत है:

 from typing import Generator, Callable, Iterable, TypeVar Y = TypeVar('Y') S = TypeVar('S') R = TypeVar('R') def chain_while( iterables: Iterable[Generator[Y, S, R]], condition: Callable[[R], bool], ) -> Generator[Y, S, None]: for it in iterables: result = yield from it if not condition(result): break def r(x: int) -> Generator[int, None, bool]: yield from range(x) return x % 2 == 1 print(list(chain_while( [ r(5), r(4), r(3), ], lambda x: x is True, ))) 

फैक्टरी विधि की व्याख्या करना उतना सरल नहीं है जितना यह लग सकता है। तत्काल आग्रह कुछ इस तरह का उपयोग करने के लिए है:

 class A: @classmethod def create(cls) -> 'A': return cls() 

हालाँकि, यह सही बात नहीं है। कैच है, A वापस नहीं create है, यह एक उदाहरण है कि A या इसके वंशजों में से कोई है। इस कोड को देखें:

 class A: @classmethod def create(cls) -> 'A': return cls() class B(A): @classmethod def create(cls) -> 'B': return super().create() 

मैपी चेक परिणाम error: Incompatible return value type (got "A", expected "B") । फिर से, समस्या super().create() को A वापस करने के लिए एनोटेट किया गया है जबकि यह इस मामले में स्पष्ट रूप से B लौटाता है।

आप TypeVar के साथ cls एनोटेट करके इसे ठीक कर सकते हैं:

 AType = TypeVar('AType') BType = TypeVar('BType') class A: @classmethod def create(cls: Type[AType]) -> AType: return cls() class B(A): @classmethod def create(cls: Type[BType]) -> BType: return super().create() 

अब cls वर्ग का उदाहरण रिटर्न create । हालाँकि, यह एनोटेशन बहुत ढीला है, हमने यह जानकारी खो दी है कि cls A उपप्रकार है:

 AType = TypeVar('AType') class A: DATA = 42 @classmethod def create(cls: Type[AType]) -> AType: print(cls.DATA) return cls() 

त्रुटि "Type[AType]" has no attribute "DATA" ।

यह तय करने के लिए कि आपको AType के bound तर्क के साथ A उपप्रकार के रूप में AType को स्पष्ट रूप से परिभाषित TypeVar :

 AType = TypeVar('AType', bound='A') BType = TypeVar('BType', bound='B') class A: DATA = 42 @classmethod def create(cls: Type[AType]) -> AType: print(cls.DATA) return cls() class B(A): @classmethod def create(cls: Type[BType]) -> BType: return super().create()