@Pythonetc नवंबर 2018

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

पिछले चयन:

• अक्टूबर 2018
• सितंबर 2018
• अगस्त 2018
• जुलाई 2018
• जून 2018

एटिपिकल डेकोरेटर्स

फ़ंक्शन डेकोरेटर्स को केवल नए कार्यों को वापस करने की आवश्यकता नहीं है, वे किसी अन्य मूल्य को वापस कर सकते हैं:

def call(*args, **kwargs): def decorator(func): return func(*args, **kwargs) return decorator @call(15) def sqr_15(x): return x * x assert sqr_15 == 225 

यह सिर्फ एक पुनर्भरण विधि के साथ सरल कक्षाएं बनाने के लिए उपयोगी हो सकता है:

 from abc import ABCMeta, abstractmethod class BinaryOperation(metaclass=ABCMeta): def __init__(self, left, right): self._left = left self._right = right def __repr__(self): klass = type(self).__name__ left = self._left right = self._right return f'{klass}({left}, {right})' @abstractmethod def do(self): pass @classmethod def make(cls, do_function): return type( do_function.__name__, (BinaryOperation,), dict(do=do_function), ) class Addition(BinaryOperation): def do(self): return self._left + self._right @BinaryOperation.make def Subtraction(self): return self._left - self._right 

__length_hint__

PEP 424 जनरेटर और अन्य पुनरावृत्तियों की अनुमति देता है जिनके पास अनुमानित लंबाई वापस करने के लिए एक विशिष्ट पूर्व निर्धारित आकार नहीं है। उदाहरण के लिए, यह जनरेटर संभवतः लगभग 50 तत्वों को लौटाएगा:

 (x for x in range(100) if random() > 0.5) 

यदि आप कुछ लिखने योग्य हैं और एक अनुमानित लंबाई वापस करना चाहते हैं, तो __length_hint__ विधि को परिभाषित करें। और यदि आपको सटीक लंबाई पता है, तो __len__ उपयोग __len__ । यदि आप एक चलने योग्य वस्तु का उपयोग करते हैं और यह जानना चाहते हैं कि यह कब तक हो सकता है, तो operator.length_hint उपयोग करें operator.length_hint ।

जनरेटर के साथ

ऑपरेटर को जनरेटर के साथ उपयोग किया जा सकता है: x in g । इस स्थिति में, पायथन g पर x तक x जाएगा जब तक कि x या जब तक g समाप्त नहीं होता है।

 >>> def g(): ... print(1) ... yield 1 ... print(2) ... yield 2 ... print(3) ... yield 3 ... >>> 2 in g() 1 2 True 

range() , हालांकि, थोड़ा बेहतर काम करता है। इसके पास एक मैजिक ओवरराइड विधि __contains__ , धन्यवाद जिसके कारण कम्प्यूटेशनल जटिलता O (1) के बराबर हो जाती है:

 In [1]: %timeit 10**20 in range(10**30) 375 ns ± 10.7 ns per loop 

ध्यान दें कि यह पायथन 2 से xrange() फ़ंक्शन के साथ काम नहीं करेगा।

संचालक + = और +

अजगर के दो अलग-अलग संचालक हैं: += और + । __iadd__ और __add__ विधियां उनके व्यवहार के लिए क्रमशः जिम्मेदार हैं।

 class A: def __init__(self, x): self.x = x def __iadd__(self, another): self.x += another.x return self def __add__(self, another): return type(self)(self.x + another.x) 

यदि __iadd__ परिभाषित नहीं किया जाता है, तो a += b a = a + b रूप में काम करेगा।

+= और + बीच शब्दार्थ अंतर यह है कि पहला व्यक्ति वस्तु को बदलता है, और दूसरा एक नया बनाता है:

 >>> a = [1, 2, 3] >>> b = a >>> a += [4] >>> a [1, 2, 3, 4] >>> b [1, 2, 3, 4] >>> a = a + [5] >>> a [1, 2, 3, 4, 5] >>> b [1, 2, 3, 4] 

एक वर्ग की विशेषता के रूप में कार्य

आप एक फ़ंक्शन को एक वर्ग विशेषता के रूप में संग्रहीत नहीं कर सकते, क्योंकि यह स्वचालित रूप से एक विधि में परिवर्तित हो जाएगा यदि इसे एक उदाहरण के माध्यम से एक्सेस किया जाता है:

 >>> class A: ... CALLBACK = lambda x: x ** x ... >>> A.CALLBACK <function A.<lambda> at 0x7f68b01ab6a8> >>> A().CALLBACK <bound method A.<lambda> of <__main__.A object at 0x7f68b01aea20>> >>> A().CALLBACK(4) Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: <lambda>() takes 1 positional argument but 2 were given 

आप एक तुच्छ विवरणक में फ़ंक्शन को धोखा और लपेट सकते हैं:

 >>> class FunctionHolder: ... def __init__(self, f): ... self._f = f ... def __get__(self, obj, objtype): ... return self._f ... >>> class A: ... CALLBACK = FunctionHolder(lambda x: x ** x) ... >>> A().CALLBACK <function A.<lambda> at 0x7f68b01ab950> 

आप विशेषता के बजाय वर्ग विधि का उपयोग करके भी स्थिति से बाहर निकल सकते हैं।

 class A: @classmethod def _get_callback(cls): return lambda x: x ** x