मेरे टेलीग्राम-चैनल @pythonetc, जुलाई 2019 के टिप्स और ट्रिक्स

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

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


आप बस उन्हें असाइन करके क्लोजर वैरिएबल को म्यूट नहीं कर सकते। पायथन असाइनमेंट को एक फंक्शन बॉडी के अंदर एक परिभाषा मानता है और बिल्कुल बंद नहीं करता है।

ठीक काम करता है, प्रिंट 2 :

 def make_closure(x): def closure(): print(x) return closure make_closure(2) 

UnboundLocalError: local variable 'x' referenced before assignment फेंकता है UnboundLocalError: local variable 'x' referenced before assignment :

 def make_closure(x): def closure(): print(x) x *= 2 print(x) return closure make_closure(2)() 

इसे काम करने के लिए आपको nonlocal उपयोग करना चाहिए। यह स्पष्ट रूप से व्याख्याकार को एक परिभाषा के रूप में काम नहीं करने के लिए कहता है:

 def make_closure(x): def closure(): nonlocal x print(x) x *= 2 print(x) return closure make_closure(2)() 

कभी-कभी पुनरावृत्ति के दौरान आप जानना चाह सकते हैं कि क्या यह चलना का पहला या अंतिम तत्व है। इसे संभालने का सरल तरीका स्पष्ट ध्वज का उपयोग करना है:

 def sparse_list(iterable, num_of_zeros=1): result = [] zeros = [0 for _ in range(num_of_zeros)] first = True for x in iterable: if not first: result += zeros result.append(x) first = False return result assert sparse_list([1, 2, 3], 2) == [ 1, 0, 0, 2, 0, 0, 3, ] 

आप पहले तत्व को लूप के बाहर भी संसाधित कर सकते हैं, जो अधिक स्पष्ट लग सकता है लेकिन कुछ हद तक कोड दोहराव की ओर जाता है। अमूर्त पुनरावृत्तियों के साथ काम करना भी एक साधारण बात नहीं है:

 def sparse_list(iterable, num_of_zeros=1): result = [] zeros = [0 for _ in range(num_of_zeros)] iterator = iter(iterable) try: result.append(next(iterator)) except StopIteration: return [] for x in iterator: result += zeros result.append(x) return result 

आप i == 0 लिए enumerate और चेक का भी उपयोग कर सकते हैं (केवल पहले तत्व का पता लगाने के लिए काम करता है, अंतिम वाले पर नहीं), लेकिन अंतिम समाधान एक जनरेटर हो सकता है जो first और last झंडे के साथ-साथ एक तत्व के तत्व को लौटाता है iterable:

 def first_last_iter(iterable): iterator = iter(iterable) first = True last = False while not last: if first: try: current = next(iterator) except StopIteration: return else: current = next_one try: next_one = next(iterator) except StopIteration: last = True yield (first, last, current) first = False 

प्रारंभिक कार्य अब इस तरह दिख सकता है:

 def sparse_list(iterable, num_of_zeros=1): result = [] zeros = [0 for _ in range(num_of_zeros)] for first, last, x in first_last_iter(iterable): if not first: result += zeros result.append(x) return result 

यदि आप दो घटनाओं के बीच समय को मापना चाहते हैं, तो आपको समय के बजाय time.monotonic() उपयोग करना चाहिए। time.monotonic() सिस्टम घड़ी अपडेट होने पर भी कभी पीछे नहीं जाती है:

 from contextlib import contextmanager import time @contextmanager def timeit(): start = time.monotonic() yield print(time.monotonic() - start) def main(): with timeit(): time.sleep(2) main() 

नेस्टेड संदर्भ प्रबंधकों को आमतौर पर पता नहीं होता है कि वे नेस्टेड हैं। आप उन्हें बाहरी संदर्भ द्वारा आंतरिक संदर्भ प्रबंधकों को बताकर जान सकते हैं:

 from contextlib import AbstractContextManager import time class TimeItContextManager(AbstractContextManager): def __init__(self, name, parent=None): super().__init__() self._name = name self._parent = parent self._start = None self._substracted = 0 def __enter__(self): self._start = time.monotonic() return self def __exit__(self, exc_type, exc_value, traceback): delta = time.monotonic() - self._start if self._parent is not None: self._parent.substract(delta) print(self._name, 'total', delta) print(self._name, 'outer', delta - self._substracted) return False def child(self, name): return type(self)(name, parent=self) def substract(self, n): self._substracted += n timeit = TimeItContextManager def main(): with timeit('large') as large_t: with large_t.child('medium') as medium_t: with medium_t.child('small-1'): time.sleep(1) with medium_t.child('small-2'): time.sleep(1) time.sleep(1) time.sleep(1) main() 

यदि आप कॉल श्रृंखला के नीचे कुछ जानकारी पास करना चाहते हैं, तो आप आमतौर पर सबसे सरल तरीके से संभव का उपयोग करते हैं: आप इसे कार्य तर्कों के रूप में पास करते हैं।

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

सबसे सरल समाधान एक वैश्विक चर है। पायथन में, आप संदर्भ धारकों के रूप में मॉड्यूल और कक्षाओं का उपयोग कर सकते हैं क्योंकि वे हैं, कड़ाई से बोलने वाले, वैश्विक चर भी। आप शायद लॉगर जैसी चीजों के लिए दैनिक आधार पर करते हैं।

यदि आपका एप्लिकेशन बहु-थ्रेडेड है, तो नंगे वैश्विक चर आपके लिए काम नहीं करेंगे क्योंकि वे थ्रेड-सुरक्षित नहीं हैं। आपके पास एक ही समय में एक से अधिक कॉल चेन चल सकती हैं, और उनमें से प्रत्येक को अपने स्वयं के संदर्भ की आवश्यकता होती है। threading मॉड्यूल आपको कवर करता है, यह threading.local() प्रदान करता है। threading.local() ऑब्जेक्ट जो थ्रेड-सुरक्षित है। केवल एसेसिंग एक्सेस द्वारा कोई डेटा threading.local().symbol = '@' : threading.local().symbol = '@' ।

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

 import asyncio import sys global_symbol = '.' async def indication(timeout): while True: print(global_symbol, end='') sys.stdout.flush() await asyncio.sleep(timeout) async def sleep(t, indication_t, symbol='.'): loop = asyncio.get_event_loop() global global_symbol global_symbol = symbol task = loop.create_task( indication(indication_t) ) await asyncio.sleep(t) task.cancel() loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.gather( sleep(1, 0.1, '0'), sleep(1, 0.1, 'a'), sleep(1, 0.1, 'b'), sleep(1, 0.1, 'c'), )) 

आप लूप सेट करके और कॉरटॉयन्स के बीच स्विच करने के संदर्भ को हर बार पुनर्स्थापित कर सकते हैं। आप इसे Python 3.7 के बाद से contextvars मॉड्यूल के साथ कर सकते हैं।

 import asyncio import sys import contextvars global_symbol = contextvars.ContextVar('symbol') async def indication(timeout): while True: print(global_symbol.get(), end='') sys.stdout.flush() await asyncio.sleep(timeout) async def sleep(t, indication_t, symbol='.'): loop = asyncio.get_event_loop() global_symbol.set(symbol) task = loop.create_task(indication(indication_t)) await asyncio.sleep(t) task.cancel() loop = asyncio.get_event_loop() loop.run_until_complete(asyncio.gather( sleep(1, 0.1, '0'), sleep(1, 0.1, 'a'), sleep(1, 0.1, 'b'), sleep(1, 0.1, 'c'), ))