@Pythonetc अगस्त 2018

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

पिछले चयन:

• जुलाई 2018
  
• जून 2018
  

फैक्टरी विधि

यदि आप __init__ अंदर नई ऑब्जेक्ट बनाते हैं, तो उन्हें तर्क के रूप में तैयार पारित करना अधिक समीचीन है, और ऑब्जेक्ट बनाने के लिए फ़ैक्टरी विधि का उपयोग करें। यह ऑब्जेक्ट बनाने की तकनीकी कार्यान्वयन से व्यापारिक तर्क को अलग करेगा।

इस उदाहरण में, __init__ host और port को डेटाबेस कनेक्शन बनाने के लिए तर्क के रूप में स्वीकार host :

 class Query: def __init__(self, host, port): self._connection = Connection(host, port) 

रिफैक्टरिंग विकल्प:

 class Query: def __init__(self, connection): self._connection = connection @classmethod def create(cls, host, port): return cls(Connection(host, port)) 

इस दृष्टिकोण के कम से कम निम्नलिखित लाभ हैं:

• परिनियोजन आसान है। परीक्षणों में, आप Query(FakeConnection()) कर सकते हैं।
• एक वर्ग में जितने चाहें उतने कारखाने के तरीके हो सकते हैं आप न केवल host और port का उपयोग करके एक कनेक्शन बना सकते हैं, बल्कि एक अन्य कनेक्शन को क्लोन कर सकते हैं, कॉन्फ़िगरेशन फ़ाइल को पढ़ सकते हैं, डिफ़ॉल्ट कनेक्शन का उपयोग कर सकते हैं, आदि।
• इसी तरह के कारखाने के तरीकों को अतुल्यकालिक कार्यों में बदल दिया जा सकता है, जो कि __init__ साथ करना बिल्कुल असंभव है।

सुपर या अगला

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

 class BaseTestCase(TestCase): def setUp(self): self._db = create_db() class UserTestCase(BaseTestCase): def setUp(self): super().setUp() self._user = create_user() 

सुपर नाम का मतलब कुछ भी नहीं है "सुपर"। इस संदर्भ में, इसका अर्थ है "उच्च श्रेणी में" (उदाहरण के लिए, शब्द "अधीक्षक")। उसी समय, super() हमेशा बेस क्लास को संदर्भित नहीं करता है, यह आसानी से एक चाइल्ड क्लास वापस कर सकता है। इसलिए next() नाम का उपयोग करना अधिक सही होगा next() , चूंकि अगली कक्षा को एमआरओ के अनुसार लौटा दिया गया है।

 class Top: def foo(self): return 'top' class Left(Top): def foo(self): return super().foo() class Right(Top): def foo(self): return 'right' class Bottom(Left, Right): pass # prints 'right' print(Bottom().foo()) 

याद रखें कि super() अलग-अलग परिणामों का उत्पादन कर सकता है, जहां इस पद्धति के आधार पर मूल रूप से कहा जाता था।

 >>> Bottom().foo() 'right' >>> Left().foo() 'top' 

एक वर्ग बनाने के लिए कस्टम नाम स्थान

एक क्लास दो बड़े चरणों में बनाई जाती है। सबसे पहले, वर्ग के शरीर को एक कार्य के शरीर की तरह निष्पादित किया जाता है। दूसरे चरण में, परिणामी नाम स्थान (जिसे locals() द्वारा वापस लौटाया जाता है locals() ) का उपयोग वर्ग की वस्तु बनाने के लिए मेटाक्लस (डिफ़ॉल्ट type ) द्वारा किया जाता है।

 class Meta(type): def __new__(meta, name, bases, ns): print(ns) return super().__new__( meta, name, bases, ns ) class Foo(metaclass=Meta): B = 2 

यह कोड {'__module__': '__main__', '__qualname__':'Foo', 'B': 3} ।

जाहिर है, अगर आप B = 2; B = 3 जैसा कुछ पेश करते हैं B = 2; B = 3 B = 2; B = 3 , फिर मेटाक्लेज़ केवल B = 3 को देखेगा, क्योंकि केवल यह मान ns । यह सीमा इस तथ्य से उपजी है कि मेटाक्लास शरीर के निष्पादन के बाद ही काम करना शुरू करता है।

हालांकि, आप अपने स्वयं के नाम स्थान को खिसकाकर निष्पादन प्रक्रिया में हस्तक्षेप कर सकते हैं। एक साधारण शब्दकोश का उपयोग डिफ़ॉल्ट रूप से किया जाता है, लेकिन आप अपनी खुद की वस्तु प्रदान कर सकते हैं, शब्दकोश के समान, यदि आप __prepare__ से __prepare__ विधि का उपयोग करते हैं।

 class CustomNamespace(dict): def __setitem__(self, key, value): print(f'{key} -> {value}') return super().__setitem__(key, value) class Meta(type): def __new__(meta, name, bases, ns): return super().__new__( meta, name, bases, ns ) @classmethod def __prepare__(metacls, cls, bases): return CustomNamespace() class Foo(metaclass=Meta): B = 2 B = 3 

कोड निष्पादन परिणाम:

 __module__ -> __main__ __qualname__ -> Foo B -> 2 B -> 3 

इस प्रकार enum.Enum नकल से सुरक्षित है।

matplotlib

matplotlib चार्टिंग के लिए एक जटिल और लचीला पाइथन लाइब्रेरी है। कई उत्पाद इसका समर्थन करते हैं, जिसमें जुपिटर और पीचार्म शामिल हैं। यहाँ matplotlib का उपयोग करके एक साधारण भग्न प्रदान करने का एक उदाहरण दिया गया है: https://repl.it/@VadimPushtaev/myplotlib (इस प्रकाशन की शीर्षक छवि देखें)।

समय क्षेत्र का समर्थन

अजगर तारीखों और समय के साथ काम करने के लिए एक शक्तिशाली datetime लाइब्रेरी प्रदान करता है। यह उत्सुक है कि datetime ऑब्जेक्ट्स में समय क्षेत्र (अर्थात, tzinfo विशेषता) का समर्थन करने के लिए एक विशेष इंटरफ़ेस है, लेकिन इस मॉड्यूल में उल्लेखित इंटरफ़ेस के लिए सीमित समर्थन है, इसलिए काम का हिस्सा अन्य मॉड्यूल को सौंपा गया है।

उनमें से सबसे लोकप्रिय pytz । लेकिन तथ्य यह है कि pytz पूरी तरह से tzinfo इंटरफ़ेस का अनुपालन नहीं करता है। यह pytz प्रलेखन के बहुत शुरुआत में कहा गया है: "यह पुस्तकालय tzinfo कार्यान्वयन के लिए प्रलेखित अजगर एपीआई से अलग है।"

आप tzinfo रूप में tzinfo pytz वस्तुओं का उपयोग नहीं कर सकते। यदि आप ऐसा करने की कोशिश करते हैं, तो आपको पूरी तरह से पागल परिणाम प्राप्त होने का खतरा है:

 In : paris = pytz.timezone('Europe/Paris') In : str(datetime(2017, 1, 1, tzinfo=paris)) Out: '2017-01-01 00:00:00+00:09' 

ऑफसेट +00: 09 पर ध्यान दें। Pytz इस तरह इस्तेमाल किया जाना चाहिए:

 In : str(paris.localize(datetime(2017, 1, 1))) Out: '2017-01-01 00:00:00+01:00' 

इसके अलावा, किसी भी अंकगणितीय संचालन के बाद, आपको बदलते डेट्स (उदाहरण के लिए, डीएसटी अवधि की सीमा पर) से बचने के लिए अपने datetime ऑब्जेक्ट्स के लिए normalize करने की आवश्यकता है।

 In : new_time = time + timedelta(days=2) In : str(new_time) Out: '2018-03-27 00:00:00+01:00' In : str(paris.normalize(new_time)) Out: '2018-03-27 01:00:00+02:00' 

यदि आपके पास पायथन 3.6 है, तो प्रलेखन dateutil.tz बजाय dateutil.tz का उपयोग करने की pytz । यह लाइब्रेरी पूरी तरह से tzinfo के साथ संगत है, इसे एक विशेषता के रूप में पारित किया जा सकता है और आपको normalize उपयोग करने की आवश्यकता नहीं है। सच है, यह अधिक धीरे-धीरे काम करता है।

यदि आप जानना चाहते हैं कि pytz API का समर्थन क्यों नहीं करता है, या अधिक उदाहरण देखना चाहते हैं, तो इस लेख को पढ़ें।

जादू की रोक

next(x) बार next(x) कहा जाता है, जब तक कि कोई अपवाद नहीं फेंका जाता है, तब तक वह पुनरावृत्ति x से एक नया मान लौटाता है। यदि यह StopIteration , तो StopIteration समाप्त हो गई है और अब मान प्रदान नहीं कर सकता है। यदि जनरेटर को पुनरावृत्त किया जाता है, तो शरीर के अंत में यह स्वचालित रूप से StopIteration फेंक देगा:

 >>> def one_two(): ... yield 1 ... yield 2 ... >>> i = one_two() >>> next(i) 1 >>> next(i) 2 >>> next(i) Traceback (most recent call last): File "<stdin>", line 1, in <module> StopIteration 

StopIteration को स्वचालित रूप से उन टूल द्वारा नियंत्रित किया जा सकता है जो next कॉल करते हैं:

 >>> list(one_two()) [1, 2] 

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

 def one_two(): yield 1 yield 2 def one_two_repeat(n): for _ in range(n): i = one_two() yield next(i) yield next(i) yield next(i) print(list(one_two_repeat(3))) 

यहां, अंतिम yield एक त्रुटि है: एक फेंक StopIteration अपवाद list(...) के पुनरावृत्ति को रोकता है। हमें परिणाम [1, 2] । हालाँकि, Python 3.7 में यह व्यवहार बदल गया है। विदेशी StopIteration जगह RuntimeError :

 Traceback (most recent call last): File "test.py", line 10, in one_two_repeat yield next(i) StopIteration The above exception was the direct cause of the following exception: Traceback (most recent call last): File "test.py", line 12, in <module> print(list(one_two_repeat(3))) RuntimeError: generator raised StopIteration 

पायथन 3.5 के बाद से समान व्यवहार को सक्षम करने के लिए आप __future__ import generator_stop उपयोग कर सकते हैं।