आंशिक आवेदन अच्छा है। क्या कार्यक्षमता functools.partialप्रदान करता है कि आप lambdas के माध्यम से प्राप्त नहीं कर सकते हैं?
>>> sum = lambda x, y : x + y
>>> sum(1, 2)
3
>>> incr = lambda y : sum(1, y)
>>> incr(2)
3
>>> def sum2(x, y):
return x + y
>>> incr2 = functools.partial(sum2, 1)
>>> incr2(4)
5है functoolsकिसी भी तरह अधिक कुशल, या पढ़ने योग्य?
जवाबों:
क्या कार्यक्षमता
functools.partialप्रदान करता है कि आप lambdas के माध्यम से प्राप्त नहीं कर सकते हैं?
अतिरिक्त कार्यक्षमता के मामले में बहुत अधिक नहीं है (लेकिन, बाद में देखें) - और, पठनीयता देखने वाले की नजर में है।
अधिकांश लोग जो कार्यात्मक प्रोग्रामिंग भाषाओं से परिचित हैं (जो विशेष रूप से लिस्प / स्कीम के परिवार वाले हैं) lambdaठीक-ठाक पसंद करते हैं - मैं कहता हूं "सबसे", निश्चित रूप से सभी नहीं , क्योंकि गुइडो और मैं आश्वस्त रूप से उन "परिचित" (आदि) में से हैं। ) अभी तक lambdaपायथन में एक आंखों की बीमारी के रूप में सोचें ...
वह इसे पाइथन में स्वीकार करने के लिए पश्चाताप कर रहा था, जबकि इसे पायथन 3 से निकालने की योजना बनाई गई थी, "पायथन ग्लिट्स" में से एक के रूप में।
मैंने उसमें उनका पूरा समर्थन किया। (मैं lambda योजना में प्यार करता हूं ... जबकि अजगर में इसकी सीमाएं हैं , और अजीब तरह से यह सिर्फ doesn ' बाकी भाषा के साथ, मेरी त्वचा को क्रॉल करें)।
हालांकि ऐसा नहीं है, हालांकि, lambdaप्रेमियों की भीड़ के लिए - जिन्होंने पायथन के इतिहास में देखे गए विद्रोह के लिए सबसे करीबी चीजों में से एक का मंचन किया, जब तक कि गुइडो पीछे नहीं हटे और छोड़ने का फैसला lambdaकिया।
कई functoolsकार्यों को निरंतर बनाने के लिए, पहचान बनाने के लिए। आदि) नहीं हुआ (स्पष्ट रूप से अधिक lambdaकार्यक्षमता को दोहराए जाने से बचने के लिए ), हालांकि partialनिश्चित रूप से बना रहा (यह कोई कुल दोहराव नहीं है, न ही यह एक नजर है)।
याद रखें कि lambdaशरीर एक अभिव्यक्ति तक ही सीमित है , इसलिए इसे सीमाएँ मिली हैं। उदाहरण के लिए...:
>>> import functools
>>> f = functools.partial(int, base=2)
>>> f.args
()
>>> f.func
<type 'int'>
>>> f.keywords
{'base': 2}
>>> functools.partialलौटाया गया फ़ंक्शन आत्मनिरीक्षण के लिए उपयोगी विशेषताओं के साथ सजाया गया है - वह फ़ंक्शन जो इसे लपेट रहा है, और किस स्थिति और नामित तर्क इसे ठीक करता है। इसके अलावा, नामित तर्कों को सही तरीके से ओवरराइड किया जा सकता है ("फिक्सिंग" बल्कि, एक अर्थ में, दोषों की सेटिंग है):
>>> f('23', base=10)
23इसलिए, जैसा कि आप देखते हैं, यह निश्चित रूप से उतना सरल नहीं है lambda s: int(s, base=2)! -)
हां, आप अपने लैम्ब्डा का विरोध कर सकते हैं ताकि आपको कुछ इस तरह दिया जा सके - जैसे, कीवर्ड-ओवरराइडिंग के लिए,
>>> f = lambda s, **k: int(s, **dict({'base': 2}, **k))लेकिन मुझे सबसे ज्यादा उम्मीद है कि सबसे उत्साही lambdaव्यक्ति भी इस डरावनी partialकॉल की तुलना में अधिक पठनीय नहीं मानते हैं! -)। "विशेषता सेटिंग" भाग और भी कठिन है, क्योंकि "शरीर की एक एकल अभिव्यक्ति" पायथन की सीमा है lambda(प्लस तथ्य यह है कि असाइनमेंट कभी भी पायथन अभिव्यक्ति का हिस्सा नहीं हो सकता है) ... आप एक अभिव्यक्ति के भीतर "फ़ेकिंग असाइनमेंट" समाप्त करते हैं स्ट्रेचिंग लिस्ट को अच्छी तरह से समझ कर उसकी डिज़ाइन सीमा से ...:
>>> f = [f for f in (lambda f: int(s, base=2),)
if setattr(f, 'keywords', {'base': 2}) is None][0]अब नामित-तर्कों को एक साथ अभिव्यक्ति में तीन विशेषताओं की स्थापना के साथ-साथ, और मुझे बताएं कि यह कितना पठनीय है ...!
defऔर lambdaकीवर्ड होगा: उन दोनों को बनाओ function(एक नाम पसंद जावास्क्रिप्ट वास्तव में सही हो गया), और मेरी आपत्तियों में से कम से कम 1/3 गायब हो जाएंगे -)। जैसा कि मैंने कहा, मुझे लिस्प में लैम्ब्डा से कोई आपत्ति नहीं है ...! -)
खैर, यहाँ एक उदाहरण है जो एक अंतर दिखाता है:
In [132]: sum = lambda x, y: x + y
In [133]: n = 5
In [134]: incr = lambda y: sum(n, y)
In [135]: incr2 = partial(sum, n)
In [136]: print incr(3), incr2(3)
8 8
In [137]: n = 9
In [138]: print incr(3), incr2(3)
12 8इवान मूर की ये पोस्ट "लंबोदा की सीमाओं" पर विस्तार करती है और अजगर में बंद हो जाती है:
lambda y, n=n: ...। लेट बाइंडिंग ( केवल किसी फ़ंक्शन के शरीर में दिखने वाले नामों में, उसके defया समतुल्य में नहीं lambda) कुछ भी नहीं है, लेकिन एक बग है, जैसा कि मैंने अतीत में लंबे एसओ के उत्तर में लंबाई में दिखाया है: आप जल्दी से स्पष्ट रूप से बाँधते हैं जब आप चाहते हैं, देर से बाध्यकारी डिफ़ॉल्ट का उपयोग करते हैं कि आप क्या चाहते है, और है कि वास्तव में सही डिजाइन विकल्प अजगर के डिजाइन के बाकी के संदर्भ दिया।
अजगर के नवीनतम संस्करण (> = 2.7) में, आप कर सकते हैं pickleएक partialनहीं, बल्कि एक lambda:
>>> pickle.dumps(partial(int))
'cfunctools\npartial\np0\n(c__builtin__\nint\np1\ntp2\nRp3\n(g1\n(tNNtp4\nb.'
>>> pickle.dumps(lambda x: int(x))
Traceback (most recent call last):
File "<ipython-input-11-e32d5a050739>", line 1, in <module>
pickle.dumps(lambda x: int(x))
File "/usr/lib/python2.7/pickle.py", line 1374, in dumps
Pickler(file, protocol).dump(obj)
File "/usr/lib/python2.7/pickle.py", line 224, in dump
self.save(obj)
File "/usr/lib/python2.7/pickle.py", line 286, in save
f(self, obj) # Call unbound method with explicit self
File "/usr/lib/python2.7/pickle.py", line 748, in save_global
(obj, module, name))
PicklingError: Can't pickle <function <lambda> at 0x1729aa0>: it's not found as __main__.<lambda>multiprocessing.Pool.map()। stackoverflow.com/a/3637905/195139
partialपाइथन 2.7 में लाइक किया जा सकता है।
क्या फंक्शनलबल्स किसी तरह अधिक कुशल हैं ..?
इसके आंशिक उत्तर के रूप में मैंने प्रदर्शन का परीक्षण करने का निर्णय लिया। यहाँ मेरा उदाहरण है:
from functools import partial
import time, math
def make_lambda():
x = 1.3
return lambda: math.sin(x)
def make_partial():
x = 1.3
return partial(math.sin, x)
Iter = 10**7
start = time.clock()
for i in range(0, Iter):
l = make_lambda()
stop = time.clock()
print('lambda creation time {}'.format(stop - start))
start = time.clock()
for i in range(0, Iter):
l()
stop = time.clock()
print('lambda execution time {}'.format(stop - start))
start = time.clock()
for i in range(0, Iter):
p = make_partial()
stop = time.clock()
print('partial creation time {}'.format(stop - start))
start = time.clock()
for i in range(0, Iter):
p()
stop = time.clock()
print('partial execution time {}'.format(stop - start))पायथन 3.3 पर यह देता है:
lambda creation time 3.1743163756961392
lambda execution time 3.040552701787919
partial creation time 3.514482823352731
partial execution time 1.7113973411608114जिसका मतलब है कि आंशिक रूप से निर्माण के लिए थोड़ा और समय चाहिए लेकिन निष्पादन के लिए काफी कम समय। यह प्रारंभिक और देर से बाध्यकारी के प्रभाव को अच्छी तरह से प्रभावित कर सकता है जो आरएस से जवाब में चर्चा की जाती है ।
partialशुद्ध पायथन के बजाय C में लिखा गया है, जिसका अर्थ है कि यह केवल एक फ़ंक्शन बनाने वाले फ़ंक्शन की तुलना में अधिक कुशल कॉल करने योग्य उत्पादन कर सकता है।
एलेक्स द्वारा बताई गई अतिरिक्त कार्यक्षमता के अलावा, फंक्शनलकूल का एक और फायदा गति है। आंशिक के साथ आप एक और स्टैक फ्रेम के निर्माण (और विनाशकारी) से बच सकते हैं।
न तो आंशिक और न ही लैम्ब्डा द्वारा उत्पन्न फ़ंक्शन में डिफ़ॉल्ट रूप से डॉकस्ट्रिंग्स हैं (हालांकि आप किसी भी ऑब्जेक्ट के लिए डॉक्टर स्ट्रिंग सेट कर सकते हैं __doc__)।
आप इस ब्लॉग में अधिक जानकारी पा सकते हैं: पायथन में आंशिक समारोह अनुप्रयोग
मैं तीसरे उदाहरण में इरादे को तेज समझता हूं।
जब मैं लंबोदर को पार्स करता हूं, तो मैं मानक पुस्तकालय द्वारा सीधे पेशकश की तुलना में अधिक जटिलता / विषमता की उम्मीद कर रहा हूं।
इसके अलावा, आप देखेंगे कि तीसरा उदाहरण केवल वही है जो पूर्ण हस्ताक्षर पर निर्भर नहीं करता है sum2; इस प्रकार यह थोड़ा और अधिक युग्मित बना रहा है।
functools.partialकॉल को पार्स करने में बहुत अधिक समय लगा , जबकि लंबोदर स्वयं स्पष्ट हैं।
functools.partialकि आपके द्वारा बताई गई अतिरिक्त कार्यक्षमता इसे लंबोदर से बेहतर बनाती है। शायद यह एक और पोस्ट का विषय है, लेकिन यह एक डिज़ाइन स्तर पर क्या है जो आपको इतना परेशान करता हैlambda?