@Pythonetc सितंबर 2018

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

पिछले चयन:

• अगस्त 2018
• जुलाई 2018
• जून 2018

ओवरराइड और ओवरलोड

दो अवधारणाएं हैं जो भ्रमित करना आसान है: ओवरराइडिंग और ओवरलोडिंग।

ओवरराइडिंग तब होती है जब एक बच्चा वर्ग पहले से ही माता-पिता की कक्षाओं द्वारा प्रदान की गई विधि को परिभाषित करता है, और इस तरह उसे बदल देता है। कुछ भाषाओं में, ओवरराइडिंग विधि को स्पष्ट रूप से चिह्नित करना आवश्यक है (C # में override संशोधक का उपयोग किया जाता है), और कुछ भाषाओं में यह वांछित (जावा में @Override एनोटेशन) के रूप में किया जाता है। पायथन को एक विशेष संशोधक के उपयोग की आवश्यकता नहीं होती है और ऐसे तरीकों के मानक अंकन प्रदान नहीं करता है (पठनीयता के लिए, कोई व्यक्ति कस्टम @override डेकोरेटर का उपयोग करता है, जो कुछ भी नहीं करता है)।

ओवरलोड एक और कहानी है। यह शब्द एक ऐसी स्थिति को संदर्भित करता है जहां एक ही नाम के साथ कई कार्य हैं, लेकिन विभिन्न हस्ताक्षर के साथ। जावा और C ++ में ओवरलोडिंग संभव है, इसका उपयोग अक्सर डिफ़ॉल्ट तर्क प्रदान करने के लिए किया जाता है:

 class Foo { public static void main(String[] args) { System.out.println(Hello()); } public static String Hello() { return Hello("world"); } public static String Hello(String name) { return "Hello, " + name; } } 

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

 def quadrilateral_area(*args): if len(args) == 4: quadrilateral = Quadrilateral(*args) elif len(args) == 1: quadrilateral = args[0] else: raise TypeError() return quadrilateral.area() 

यदि आपको टाइप संकेत की आवश्यकता है, तो @overload डेकोरेटर के साथ typing मॉड्यूल का उपयोग typing :

 from typing import overload @overload def quadrilateral_area( q: Quadrilateral ) -> float: ... @overload def quadrilateral_area( p1: Point, p2: Point, p3: Point, p4: Point ) -> float: ... 

ऑटो विचलन

collections.defaultdict आपको एक ऐसा शब्दकोश बनाने की अनुमति देता है जो डिफ़ॉल्ट मान लौटाता है यदि अनुरोधित कुंजी गायब है (बजाय KeyError फेंकने के लिए)। एक डिफ़ॉल्ट बनाने के लिए defaultdict आपको न केवल एक डिफ़ॉल्ट मान प्रदान करना होगा, बल्कि ऐसे मूल्यों का एक कारखाना।

तो आप एक वस्तुतः अनंत संख्या वाले शब्दकोश के साथ एक शब्दकोश बना सकते हैं, जो आपको d[a][b][c]...[z] जैसे निर्माणों का उपयोग करने की अनुमति देता है।

 >>> def infinite_dict(): ... return defaultdict(infinite_dict) ... >>> d = infinite_dict() >>> d[1][2][3][4] = 10 >>> dict(d[1][2][3][5]) {} 

इस व्यवहार को "ऑटो-विविफिकेशन" कहा जाता है, जो कि पर्ल से आता है।

इन्स्टेन्शियशन

वस्तुओं की तात्कालिकता में दो महत्वपूर्ण चरण शामिल हैं। सबसे पहले, वर्ग से __new__ विधि को कहा जाता है, जो एक नई वस्तु बनाता है और वापस करता है। तब पायथन इसे से __init__ विधि कहता है, जो इस ऑब्जेक्ट की प्रारंभिक स्थिति सेट करता है।

हालाँकि, __new__ को नहीं कहा जाएगा यदि __new__ एक ऐसी वस्तु लौटाता है जो मूल वर्ग का उदाहरण नहीं है। इस स्थिति में, ऑब्जेक्ट किसी अन्य वर्ग द्वारा बनाया जा सकता है, जिसका अर्थ है कि __init__ को पहले ही ऑब्जेक्ट पर बुलाया गया है:

 class Foo: def __new__(cls, x): return dict(x=x) def __init__(self, x): print(x) # Never called print(Foo(0)) 

इसका यह भी अर्थ है कि आपको नियमित निर्माणकर्ता ( Foo(...) ) का उपयोग करके __new__ में उसी वर्ग को __new__ नहीं करना चाहिए। इससे __init__ को दोहराया जा सकता है, या यहां तक ​​कि अनंत पुनरावृत्ति भी हो सकती है।

अनंत पुनरावृत्ति:

 class Foo: def __new__(cls, x): return Foo(-x) # Recursion 

डबल निष्पादन __init__ :

 class Foo: def __new__(cls, x): if x < 0: return Foo(-x) return super().__new__(cls) def __init__(self, x): print(x) self._x = x 

सही तरीका:

 class Foo: def __new__(cls, x): if x < 0: return cls.__new__(cls, -x) return super().__new__(cls) def __init__(self, x): print(x) self._x = x 

ऑपरेटर [] और स्लाइस

पायथन में, आप __getitem__ मैजिक विधि को परिभाषित करके [] ऑपरेटर को ओवरराइड कर सकते हैं। इसलिए, उदाहरण के लिए, आप एक ऐसी वस्तु बना सकते हैं जिसमें लगभग दोहराए जाने वाले तत्व शामिल हों:

 class Cycle: def __init__(self, lst): self._lst = lst def __getitem__(self, index): return self._lst[ index % len(self._lst) ] print(Cycle(['a', 'b', 'c'])[100]) # 'b' 

यहाँ असामान्य बात यह है कि [] ऑपरेटर अद्वितीय सिंटैक्स का समर्थन करता है। इसका उपयोग करके, आप न केवल [2] , बल्कि [2:10] , [2:10:2] , [2::2] और यहां तक ​​कि [:] । ऑपरेटर के शब्दार्थ हैं: [प्रारंभ: स्टॉप: स्टेप], हालांकि आप कस्टम ऑब्जेक्ट बनाने के लिए किसी अन्य तरीके से इसका उपयोग कर सकते हैं।

लेकिन अगर आप इस सिंटैक्स के साथ __getitem__ को कॉल __getitem__ , तो इसे इंडेक्स पैरामीटर के रूप में क्या मिलेगा? यही कारण है कि टुकड़ा वस्तुओं मौजूद हैं।

 In : class Inspector: ...: def __getitem__(self, index): ...: print(index) ...: In : Inspector()[1] 1 In : Inspector()[1:2] slice(1, 2, None) In : Inspector()[1:2:3] slice(1, 2, 3) In : Inspector()[:] slice(None, None, None) 

तुम भी tuples और स्लाइस के वाक्यविन्यास गठबंधन कर सकते हैं:

 In : Inspector()[:, 0, :] (slice(None, None, None), 0, slice(None, None, None)) 

slice कुछ भी नहीं करता है, केवल विशेषताओं को start , stop और step संग्रहीत stop ।

 In : s = slice(1, 2, 3) In : s.start Out: 1 In : s.stop Out: 2 In : s.step Out: 3 

असिंसीओ कोरटाइन को बाधित करना

किसी भी निष्पादन योग्य asyncio को cancel() विधि का उपयोग करके निरस्त किया जा सकता है। इस मामले में, एक रद्द किए गएError को coroutine में भेजा जाएगा, परिणामस्वरूप, यह और इससे जुड़े सभी coroutines को तब तक बाधित किया जाएगा जब तक कि त्रुटि को पकड़ा और दबा नहीं दिया जाता।

CancelledError किया गया एक्सरसाइज Exception का एक उपवर्ग है, जिसका अर्थ है कि इसे गलती से "किसी भी त्रुटि" को पकड़ने के लिए डिज़ाइन किए गए try ... except Exception पकड़ा जा सकता है। एक coroutine के लिए बग को सुरक्षित रूप से पकड़ने के लिए, आपको यह करना होगा:

 try: await action() except asyncio.CancelledError: raise except Exception: logging.exception('action failed') 

निष्पादन योजना

एक निश्चित समय में कुछ कोड के निष्पादन की योजना बनाने के लिए, asyncio आमतौर पर एक कार्य बनाता है जो await asyncio.sleep(x) करता है:

 import asyncio async def do(n=0): print(n) await asyncio.sleep(1) loop.create_task(do(n + 1)) loop.create_task(do(n + 1)) loop = asyncio.get_event_loop() loop.create_task(do()) loop.run_forever() 

लेकिन एक नया कार्य बनाना महंगा हो सकता है, और यदि आप अतुल्यकालिक संचालन करने की योजना नहीं बनाते हैं, तो आपको ऐसा करना होगा (जैसे मेरे उदाहरण में कार्य do )। इसके बजाय, आप फ़ंक्शंस loop.call_later और loop.call_at उपयोग कर सकते हैं, जो आपको एक एसिंक्रोनस कॉलबैक कॉल शेड्यूल करने की अनुमति देता है:

 import asyncio def do(n=0): print(n) loop = asyncio.get_event_loop() loop.call_later(1, do, n+1) loop.call_later(1, do, n+1) loop = asyncio.get_event_loop() do() loop.run_forever()