Python: Por que o functools.partial é necessário?

Aplicação parcial é legal. Que funcionalidade functools.partialoferece e que você não consegue passar pelas 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

De functoolsalguma forma, é mais eficiente ou legível?

Que funcionalidade functools.partialoferece e que você não consegue passar pelas lambdas?

Não há muito em termos de funcionalidade extra (mas, veja mais adiante) - e a legibilidade está nos olhos de quem vê.
A maioria das pessoas que estão familiarizadas com linguagens de programação funcionais (aquelas da família Lisp / Scheme em particular) parece gostar lambdamuito bem - eu digo "a maioria", definitivamente não todas, porque Guido e eu certamente estamos entre os "familiarizados" (etc ) ainda pense lambdacomo uma anomalia desagradável em Python ...
Ele se arrependeu de ter aceitado o Python, enquanto planejava removê-lo do Python 3, como uma das "falhas do Python".
Eu o apoiei totalmente nisso. (Adoro lambda no Scheme ... enquanto suas limitações em Python e a maneira estranha como ele simplesmente não faz ' com o resto do idioma, faça minha pele arrepiar).

Não é assim, no entanto, para as hordas de lambdaamantes - que encenaram uma das coisas mais próximas de uma rebelião já vista na história de Python, até Guido voltar atrás e decidir sair lambda.
Várias adições possíveis a functools(para fazer funções retornarem constantes, identidade, etc) não aconteceu (para evitar duplicar explicitamente mais lambdafuncionalidades), embora partialtenha permanecido, é claro (não é uma duplicação total , nem é uma desagradável).

Lembre-se de que lambdao corpo é limitado para ser uma expressão , por isso tem limitações. Por exemplo...:

>>> import functools
>>> f = functools.partial(int, base=2)
>>> f.args
()
>>> f.func
<type 'int'>
>>> f.keywords
{'base': 2}
>>> 

functools.partialA função retornada é decorada com atributos úteis para introspecção - a função que está agrupando e quais argumentos posicionais e nomeados ela fixa nela. Além disso, os argumentos nomeados podem ser substituídos de volta (a "correção" é, em certo sentido, a configuração dos padrões):

>>> f('23', base=10)
23

Então, como você vê, definitivamente não é tão simplista quanto lambda s: int(s, base=2)! -)

Sim, você pode contorcer seu lambda para fornecer um pouco disso, por exemplo, para a substituição de palavras-chave,

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

mas espero sinceramente que mesmo o lambdaamante mais ardente não considere esse horror mais legível do que a partialligação! -). A parte "configuração do atributo" é ainda mais difícil, devido à limitação "do corpo como uma única expressão" do Python lambda(além do fato de que a atribuição nunca poder fazer parte de uma expressão do Python) ... você acaba "fingindo atribuições dentro de uma expressão" estendendo a compreensão da lista muito além dos limites de design ...:

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

Agora combine a substituibilidade dos argumentos nomeados, mais a configuração de três atributos, em uma única expressão e me diga o quão legível isso será ...!

Bem, aqui está um exemplo que mostra uma diferença:

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

Essas postagens de Ivan Moore expandem as "limitações do lambda" e os fechamentos em python:

• Encerramentos em Python (parte 2)
• Fechamentos em Python (parte 3)

Nas versões mais recentes do Python (> = 2.7), você pode picklea partial, mas não a 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>

O functools é de alguma forma mais eficiente ..?

Como resposta parcial a isso, decidi testar o desempenho. Aqui está o meu exemplo:

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

no Python 3.3, ele fornece:

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

O que significa que o parcial precisa de um pouco mais de tempo para criação, mas consideravelmente menos tempo para a execução. Isso pode muito bem ser o efeito da ligação antecipada e tardia, discutida na resposta de ars .

Além da funcionalidade extra mencionada por Alex, outra vantagem do functools.partial é a velocidade. Com parcial, você pode evitar construir (e destruir) outro quadro de pilha.

Nem a função gerada por parciais nem por lambdas possui documentos por padrão (embora você possa definir o documento para qualquer objeto via __doc__).

Você pode encontrar mais detalhes neste blog: Aplicativo de Função Parcial em Python

Entendo a intenção mais rapidamente no terceiro exemplo.

Quando analiso lambdas, espero mais complexidade / singularidade do que a oferecida pela biblioteca padrão diretamente.

Além disso, você notará que o terceiro exemplo é o único que não depende da assinatura completa de sum2; tornando-o assim um pouco mais frouxamente acoplado.