@Pythonetc सितंबर 2019

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

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


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

 import asyncio async def printer(): try: try: while True: print('*') await asyncio.sleep(1) except asyncio.CancelledError: print('') finally: await asyncio.sleep(2) print('') # 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)) #  printed 

परिणाम:

 * * || *  

सुनिश्चित करें कि आप चक्र को रोकने से पहले सभी कार्यों को पूरा करने की प्रतीक्षा करें। यदि ऐसा नहीं किया जाता है, तो आप कुछ finally ब्लॉक छोड़ सकते हैं और कुछ संदर्भ प्रबंधक अक्षम नहीं होंगे।


पायथन आपको बिटकॉइन शिफ्ट ऑपरेटर सहित कई ऑपरेटरों को ओवरराइड करने की अनुमति देता है। इस ऑपरेटर के उपयोग से कार्यों की संरचना बनाने का एक उदाहरण यहां दिया गया है। तीर डेटा ट्रांसफर की दिशा का संकेत देते हैं:

 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') । मेटाक्लस कीवर्ड मेटाक्लस चुनने के लिए आरक्षित है, और आप अपनी इच्छानुसार दूसरों का उपयोग कर सकते हैं।

यहाँ एक मेटाकाॅल का उदाहरण दिया गया है जो एक गुण के बिना एक वर्ग बनाता है। 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') 

सिमेंटिक सटीकता के लिए, आप अपने स्वयं के exhaust समारोह को परिभाषित कर सकते हैं:

 def exhaust(iterable): for _ in iterable: pass 

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

हालाँकि, आप एक Sequence प्रकार प्रदान कर सकते हैं क्योंकि यह केवल पढ़ने के लिए है। अधिक सटीक रूप से, इस मामले में, Sequence प्रतिभागियों के प्रकार में सहसंयोजक है।

आप covariant प्रदान करके परिभाषित कर सकते हैं covariant covariant=True TypeVar तर्क के रूप में covariant=True :

 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) 

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