@Pythonetc संकलन, अगस्त 2019

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

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


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

>>> 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 

यह भी देखें कि classonlymethod Django डेकोरेटर कैसे classonlymethod : https://github.com/django/django/blob/b709d701303b3877387020c1558a590713b9853/django/utecorators.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 तक पहुँच नहीं है। x तक पहुंच प्रदान करने का एकमात्र तरीका एक और गुंजाइश जोड़ना है (हाँ, बेवकूफ समाधान):

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

पायथन में, 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 , लेकिन केवल इतना ही नहीं। कस्टम ऑब्जेक्ट 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 आपको जनरेटर के लिए प्रकारों को परिभाषित करने की अनुमति देता है। इसके अतिरिक्त, आप निर्दिष्ट कर सकते हैं कि कौन सा प्रकार जेनरेट किया गया है, जो जनरेटर को पास किया गया है, और जो return का उपयोग करके return । उदाहरण के लिए, Generator[int, None, bool] g.send() Generator[int, None, bool] पूर्णांक उत्पन्न करता है, g.send() लौटाता है, और g.send() समर्थन नहीं करता है।

लेकिन उदाहरण अधिक जटिल है। chain_while अन्य जनरेटर के डेटा को तब तक 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 , यह रिटर्न cls , जो A या इसके वंशजों में से एक है। कोड पर एक नज़र डालें:

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

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

यह ठीक किया जा सकता है यदि TypeVar का उपयोग करते हुए TypeVar :

 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() 

अब create cls वर्ग का एक उदाहरण देता है। हालाँकि, ये एनोटेशन बहुत अस्पष्ट हैं, हमने यह जानकारी खो दी है कि 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" ।

इसे ठीक करने के लिए, आपको स्पष्ट रूप से A को A उपप्रकार के रूप में परिभाषित करना होगा A इसके लिए, bound तर्क के साथ 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()