Python: ทำไม functools.partial จึงมีความจำเป็น

แอพลิเคชันบางส่วนจะเย็น มีฟังก์ชั่นอะไรบ้าง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 ได้?

ไม่มากในแง่ของฟังก์ชั่นพิเศษ(แต่ดูในภายหลัง) - และการอ่านอยู่ในสายตาของคนดู
คนส่วนใหญ่ที่คุ้นเคยกับภาษาการเขียนโปรแกรมที่ใช้งานได้ (ในครอบครัว Lisp / Scheme โดยเฉพาะ) ดูเหมือนจะlambdaสบายดี - ฉันพูดว่า "ส่วนใหญ่" ไม่แน่นอนทั้งหมดเพราะ Guido และฉันมั่นใจว่าเป็นคนที่คุ้นเคย "(ฯลฯ ) ) แต่คิดว่าlambdaเป็นความผิดปกติของนัยน์ตาในงูหลาม ...
เขาสำนึกผิดว่าเคยยอมรับมันเป็นงูหลามในขณะที่วางแผนที่จะลบมันออกจากงูหลาม 3 เป็นหนึ่งใน "ข้อบกพร่องของงูใหญ่"
ฉันสนับสนุนเขาอย่างเต็มที่ในเรื่องนั้น (ฉันชอบlambda ใน Scheme ... ในขณะที่ข้อ จำกัดใน Pythonและวิธีแปลก ๆ มันก็ไม่ได้ ' ด้วยภาษาที่เหลือทำให้ผิวของฉันคลาน)

ไม่เช่นนั้น แต่สำหรับพยุหะของ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

ดังนั้นที่คุณดูจะdefinelyไม่เป็นที่เรียบง่ายเป็นlambda s: int(s, base=2)-!)

ใช่คุณสามารถบิดแลมบ์ดาของคุณเพื่อให้สิ่งนี้แก่คุณเช่นสำหรับการแทนที่คำหลัก

>>> f = lambda s, **k: int(s, **dict({'base': 2}, **k))

แต่ฉันหวังเป็นอย่างยิ่งว่าแม้แต่คนที่กระตือรือร้นที่สุดlambdaก็ไม่คิดว่าหนังสยองขวัญนี้สามารถอ่านได้ดีไปกว่าการpartialโทร! -) ส่วน "การตั้งค่าแอตทริบิวต์" นั้นยากขึ้นเนื่องจากข้อ จำกัด "การแสดงออกของร่างกายเดียว" ของ Python lambda(รวมถึงความจริงที่ว่าการมอบหมายไม่สามารถเป็นส่วนหนึ่งของการแสดงออกของ Python) ... คุณจบ "แกล้งทำมอบหมายภายในนิพจน์" โดยการยืดความเข้าใจในรายการให้เกินกว่าขีด จำกัด การออกแบบ ... :

>>> f = [f for f in (lambda f: int(s, base=2),)
           if setattr(f, 'keywords', {'base': 2}) is None][0]

ตอนนี้รวมเอาการขัดแย้ง overridability ชื่อ - รวมทั้งการตั้งค่าของสามคุณลักษณะในการแสดงออกเดียวและบอกฉันว่าอ่านได้ว่าจะเป็น ... !

นี่คือตัวอย่างที่แสดงความแตกต่าง:

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

ข้อความเหล่านี้ของ Ivan Moore ได้เพิ่มเติมเกี่ยวกับ "ข้อ จำกัด ของ lambda" และการปิดใน python:

• ปิดใน Python (ตอนที่ 2)
• ปิดใน Python (ตอนที่ 3)

ใน Python เวอร์ชันล่าสุด (> = 2.7) คุณสามารถpicklea 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>

functools มีประสิทธิภาพมากขึ้นอย่างใด ..

เป็นส่วนหนึ่งคำตอบนี้ฉันตัดสินใจที่จะทดสอบประสิทธิภาพ นี่คือตัวอย่างของฉัน:

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

บน Python 3.3 มันให้:

lambda creation time 3.1743163756961392
lambda execution time 3.040552701787919
partial creation time 3.514482823352731
partial execution time 1.7113973411608114

ซึ่งหมายความว่าบางส่วนต้องการเวลาเพิ่มเล็กน้อยในการสร้าง แต่ใช้เวลาในการดำเนินการน้อยกว่ามาก นี้รวมทั้งสามารถเป็นผลของต้นและปลายที่มีผลผูกพันซึ่งจะกล่าวถึงในคำตอบจากอาร์

นอกเหนือจากฟังก์ชั่นพิเศษที่ Alex พูดถึงข้อดีอีกอย่างของ functools.partial ก็คือความเร็ว ด้วยบางส่วนคุณสามารถหลีกเลี่ยงการสร้าง (และทำลาย) สแต็กเฟรมอื่น

ทั้งฟังก์ชั่นที่สร้างขึ้นโดยบางส่วนหรือ lambdas ไม่มี docstrings ตามค่าเริ่มต้น (แม้ว่าคุณจะสามารถตั้งค่าสตริง doc สำหรับวัตถุใด ๆ ผ่าน__doc__)

คุณสามารถค้นหารายละเอียดเพิ่มเติมได้ในบล็อกนี้: แอปพลิเคชันฟังก์ชันบางส่วนใน Python

ฉันเข้าใจเจตนาที่เร็วที่สุดในตัวอย่างที่สาม

เมื่อฉันแยกวิเคราะห์ lambdas ฉันคาดหวังว่าจะมีความซับซ้อน / แปลกมากกว่าที่ห้องสมุดมาตรฐานเสนอโดยตรง

นอกจากนี้คุณจะสังเกตเห็นว่าตัวอย่างที่สามเป็นเพียงคนเดียวที่ไม่ได้ขึ้นอยู่กับลายเซ็นเต็มรูปแบบของsum2; จึงทำให้มันมีความแน่นมากขึ้นเล็กน้อย