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

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

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


asyncio लूप को कार्य करने के लिए नहीं चलना पड़ता है। आप कार्य बना सकते हैं और रोक सकते हैं भले ही अभी लूप बंद हो गया हो। यदि लूप बंद हो जाता है, तो कुछ कार्य अच्छे के लिए अपूर्ण रह सकते हैं।

 import asyncio async def printer(): try: try: while True: print('*') await asyncio.sleep(1) except asyncio.CancelledError: print('x') finally: await asyncio.sleep(2) print('o') # never happens loop = asyncio.get_event_loop() run = loop.run_until_complete task = loop.create_task(printer()) run(asyncio.sleep(1)) # printer works here print('||') run(asyncio.sleep(1)) # printer works here task.cancel() # nothing happens run(asyncio.sleep(1)) # x printed 

आउटपुट:

 * * || * x 

लूप को रोकने से पहले आपको सभी कार्यों का इंतजार करना होगा। यदि आप नहीं करते हैं, तो आपके पास कुछ ब्लॉक हो सकते हैं और कुछ संदर्भ प्रबंधकों को बाहर नहीं निकाला जा सकता है।


अजगर आपको कई अलग-अलग ऑपरेटरों को अधिभार देता है और शिफ्ट ऑपरेटर उनमें से एक है। इस ऑपरेटर का उपयोग करके फ़ंक्शन रचना कैसे बनाएं, इसका एक उदाहरण यहां दिया गया है। यहां, तीर-जैसे संकेत डेटा-प्रवाह दिशा दिखाते हैं:

 from collections import deque from math import sqrt class Compose: def __init__(self): self._functions = deque() def __call__(self, *args, **kwargs): result = None for f in self._functions: result = f(*args, **kwargs) args = [result] kwargs = dict() return result def __rshift__(self, f): self._functions.append(f) return self def __lshift__(self, f): self._functions.appendleft(f) return self compose = Compose sqrt_abs = (compose() << sqrt << abs) sqrt_abs2 = (compose() >> abs >> sqrt) print(sqrt_abs(-4)) # 2.0 print(sqrt_abs2(-4)) # 2.0 

आप वर्ग परिभाषा से कस्टम मेटाक्लस के लिए तर्क पारित कर सकते हैं। class संकेतन समर्थन खोजशब्द तर्क: class Klass(Parent, arg='arg') । metaclass कीवर्ड metaclass सेट करने के लिए आरक्षित है, लेकिन अन्य उपयोग करने के लिए स्वतंत्र हैं।

यहां मेटाक्लास का एक उदाहरण है जो बिना किसी विशेषता के वर्ग बनाता है। remove तर्क में उस विशेषता का नाम दिया गया है:

 class FilterMeta(type): def __new__(mcs, name, bases, namespace, remove=None, **kwargs): if remove is not None and remove in namespace: del namespace[remove] return super().__new__(mcs, name, bases, namespace) class A(metaclass=FilterMeta, remove='half'): def half(x): return x // 2 half_of_4 = half(4) half_of_100 = half(100) a = A() print(a.half_of_4) # 2 print(a.half_of_100) # 50 a.half # AttributeError 

कभी-कभी आप एक जनरेटर को समाप्त करना चाहते हैं, लेकिन आप उन मूल्यों के बारे में परवाह नहीं करते हैं जो इसकी उपज देता है। आप कुछ साइड इफेक्ट के बारे में परवाह करते हैं, हालांकि, यह एक अपवाद हो सकता है, एक फाइल पर लिखना, वैश्विक चर संशोधन आदि।

ऐसा करने के लिए सुविधाजनक और व्यापक रूप से उपयोग किया जाने वाला तरीका list(gen()) । हालाँकि, यह कोड मेमोरी में सभी मानों को सहेजने के तुरंत बाद उन्हें छोड़ देता है। वह अवांछनीय हो सकता है।

यदि आप इससे बचना चाहते हैं तो आप इसके बजाय सीमित आकार के साथ deque उपयोग कर सकते हैं:

 from collections import deque def inversed(nums): for num in nums: yield 1 / num try: deque(inversed([1, 2, 0]), maxlen=0) except ZeroDivisionError: print('E')</code> To be more semantically precise you better define your own <code>exhaust</code> function: <source lang="python"> def exhaust(iterable): for _ in iterable: pass 

कल्पना कीजिए कि आपके पास एक जोड़ी कक्षाएं हैं जो एक माता-पिता और बच्चे हैं, User और Admin कहते हैं। आपके पास एक फ़ंक्शन भी है जो एक तर्क के रूप में उपयोगकर्ताओं की सूची लेता है। क्या आप फिर प्रवेश की सूची प्रदान कर सकते हैं? इसका उत्तर नहीं है: फ़ंक्शन किसी अन्य उपयोगकर्ता को प्रवेश की सूची में जोड़ सकता है जो अमान्य है और यह गारंटी देता है कि सूची प्रदान करती है।

हालाँकि, आप Sequence के केवल पढ़ने के बाद से ही Sequence प्रदान कर सकते हैं। यहाँ उचित शब्द है Sequence अपने सदस्यों के प्रकार पर सहसंयोजक है।

आप सहसंयोजक प्रकार प्रदान करके परिभाषित कर सकते हैं

 from typing import TypeVar, Generic T = TypeVar('T', covariant=True) class Holder(Generic[T]): def __init__(self, var: T): self._var: T = var def get(self) -> T: return self._var class User: pass class Admin(User): pass def print_user_from_holder(holder: Holder[User]) -> None: print(holder.get()) h: Holder[Admin] = Holder(Admin()) print_user_from_holder(h) 

कंट्राइवाइज, फंक्शन को कंटेनर की आवश्यकता हो सकती है ताकि वहां एडिंस लगाए जा सकें। इस तरह के राइट-ओनली कंटेनर इसके सदस्यों के प्रकार पर विपरीत होते हैं:

 from typing import TypeVar, Generic T = TypeVar('T', contravariant=True) class Holder(Generic[T]): def __init__(self, var: T): self._var: T = var def change(self, x: T): self._var = x class User: pass class Admin(User): pass def place_admin_to_holder(holder: Holder[Admin]) -> None: holder.change(Admin()) h: Holder[User] = Holder(User()) place_admin_to_holder(h) 

वे वर्ग जो न तो सहसंयोजक होते हैं और न ही कंट्राविरेंट को अपरिवर्तनीय कहा जाता है ।