Python: зачем нужен functools.partial?

Частичное приложение - это круто. Какие функции functools.partialвы не можете получить с помощью лямбда-выражений?

>>> 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вы не можете получить с помощью лямбда-выражений?

Немногое с точки зрения дополнительной функциональности (но, см. Ниже) - и читаемость в глазах смотрящего.
Большинству людей, знакомых с функциональными языками программирования (в частности, из семейств Lisp / Scheme), кажется, это нравится lambdaпросто - я говорю «большинство», определенно не все, потому что мы с Гвидо, несомненно, относимся к тем, кто «знаком с» (т. ), но считают, lambdaчто это неприятная аномалия в Python ...
Он раскаивался в том, что когда-либо принимал это в Python, тогда как планировал удалить его из Python 3, как один из «глюков Python».
Я полностью его в этом поддержал. (Мне нравится lambda Scheme ... в то время как его ограничения в Python и странный способ, которым он просто не с остальным языком заставляю кожу ползать).

Однако не так для орды lambdaвлюбленных, которые устроили один из самых близких к восстанию событий в истории Python, пока Гвидо не отступил и не решил уйти 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призыв! -). Часть «установки атрибута» еще сложнее из-за ограничения 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

Эти сообщения Ивана Мура расширяют «ограничения лямбда» и замыкания в Python:

• Замыкания в Python (часть 2)
• Замыкания в Python (часть 3)

В последних версиях Python (> = 2.7), вы можете , но не :picklepartiallambda

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

Это означает, что частичному требуется немного больше времени для создания, но значительно меньше времени для выполнения. Это вполне может быть результатом раннего и позднего связывания, которые обсуждаются в ответе от ars .

Помимо дополнительных функций, упомянутых Алексом, еще одним преимуществом functools.partial является скорость. С partial вы можете избежать создания (и разрушения) другого кадра стека.

Ни функция, сгенерированная частичным, ни лямбда-выражения по умолчанию не имеют строк документации (хотя вы можете установить строку документа для любых объектов через __doc__ ).

Вы можете найти более подробную информацию в этом блоге: Приложение с частичной функцией в Python

Я быстрее всего понимаю намерение в третьем примере.

Когда я разбираю лямбды, я ожидаю большей сложности / странности, чем это предлагается непосредственно стандартной библиотекой.

Также вы заметите, что третий пример - единственный, который не зависит от полной подписи sum2; что делает его немного более слабым.