@Pythonetc संकलन, जुलाई 2019

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

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


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

ठीक काम करता है, 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, ] 

बेशक, आप पहले तत्व को लूप के बाहर संभाल सकते हैं। यह क्लीनर दिखता है, लेकिन आंशिक कोड दोहराव की ओर जाता है। इसके अलावा, अमूर्त iterable साथ काम करते समय ऐसा करना इतना आसान नहीं होगा:

 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 

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

 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() उपयोग करें। 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 = '@' ।

हालांकि, दोनों वर्णित दृष्टिकोण संगामिति-सुरक्षित नहीं हैं, अर्थात्, वे कोरआउट कॉल श्रृंखला के लिए उपयुक्त नहीं हैं, जिसमें सिस्टम न केवल फ़ंक्शन को कॉल करता है, बल्कि उन्हें निष्पादित करने की भी अपेक्षा करता है। जब कोई कोरटाइन 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'), )) 

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

 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'), ))