Python：为什么需要 functools.partial？

Question

部分应用很酷。 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 是否更高效或更具可读性？

Answer 1

functools.partial 提供了哪些功能是您无法通过 lambda 实现的？

没有太多额外的功能（但是，见下文）——而且，可读性是情人眼里出西施。
大多数熟悉函数式编程语言的人（特别是 Lisp/Scheme 系列中的语言）似乎都非常喜欢 lambda - 我说的是“大多数”，绝对不是全部，因为 Guido 和我确实是那些“熟悉”（等等）的人之一，但仍认为 lambda 是 Python 中令人讨厌的异常现象......
他对将其接受到 Python 中感到后悔，同时计划将其从 Python 3 中删除，作为“Python 的故障”之一。
我完全支持他。 （我喜欢Scheme中的lambda...而它在Python中的局限性，以及它不适合的奇怪方式 加上其余的语言，让我起鸡皮疙瘩）。

然而，对于成群的 lambda 爱好者来说却并非如此——他们上演了 Python 历史上最接近叛乱的事件之一，直到 Guido 改变主意并决定离开 lambda 在。
尽管 functools 中的几个可能的添加（使函数返回常量、标识等）并没有发生（以避免显式重复更多 lambda 的功能） >部分当然保留了（它不是完全重复，也不是碍眼）。

请记住，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)!-)

是的，你可以扭曲你的 lambda 来给你一些这样的东西 - 例如，对于关键字覆盖，

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

现在将命名参数可重写性以及三个属性的设置结合到一个表达式中，并告诉我可读性如何 那将是......！

Answer 2

好吧，这里有一个显示差异的示例：

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 的这些帖子扩展了 python 中的“lambda 限制”和闭包：

• Python 中的闭包（第 2 部分）
• Python 中的闭包（第 3 部分）

Answer 3

在最新版本的 Python (>=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>

Answer 4

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

这意味着partial需要更多的时间来创建，但执行的时间要少得多。这很可能是早期和晚期绑定的影响，这在 ars 的答案中进行了讨论。

Answer 5

除了 Alex 提到的额外功能之外，functools.partial 的另一个优点是速度。使用partial，您可以避免构造（和破坏）另一个堆栈帧。

默认情况下，partial 和 lambda 生成的函数都没有文档字符串（尽管您可以通过 __doc__ 为任何对象设置文档字符串）。

您可以在此博客中找到更多详细信息： Python中的偏函数应用

Answer 6

超级老的问题，但我想我会把它放在这里，以防它对某人有用。

与 lambda 相比，partial 的优点之一在于它们在循环中的行为方式。由于 lambda 计算参数的方式，在使用它们时很容易出错，那就是将 lambda 函数声明为循环的一部分（例如菜单项的回调方法）。

例如，这给出了一个答案，不熟悉 lambda 中这种行为的开发人员可能会感到惊讶，

funcs = []
for i in range(10):
    f = lambda j: i + j
    funcs.append(f)
print(f(1) for f in funcs)
# [10, 10, 10, 10, 10, 10, 10, 10, 10, 10]

但是，如果您使用部分，则不会遇到此问题；

parts = []
for i in range(10):
    p = partial(sum, (i, ))
    parts.append(p)
print([p(1) for p in parts])
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

当然，有 lambda 解决这个问题的方法，但对于部分语法是（IMO ）更加简单并且行为如您所期望的那样。

Answer 7

我在第三个例子中最快理解了意图。

当我解析 lambda 时，我期望比标准库直接提供的更复杂/奇怪。

另外，您还会注意到第三个示例是唯一一个不依赖于 sum2 的完整签名的示例；从而使其耦合更加松散。

Answer 8

泛函在评估某些变量时具有有用的用途。

来自局外人，这里有一系列更友好的示例：

from functools import partial

sum = lambda x, y: x + y            # sum(x, y) == x + y

n = 2
normalSum = lambda x: sum(x, n)     # normalSum(x) == sum(x, y=n)
partialSum = partial(sum, y = n)    # partialSum(sum(y=n)) == sum(x, 2)
print(normalSum(2), partialSum(2))  # 4 4

n = 6
print(normalSum(2), partialSum(2))  # 8 4

请注意部分部分如何保存当时 n 的值。

...
n = 2
partialSumOrig = partial(sum, y = n)        # partialSumOrig(sum(y=n)) == sum(x, 2)
n = 6
partialSumNew = partial(sum, y = n)         # partialSumNew(sum(y=n)) == sum(x, 6)

print(partialSumOrig(2), partialSumNew(2))  # 4 8

展示如何将参数传递到嵌套 lambda 中的额外示例：

...
n = 8
partialSumOrig = partial(sum, y = n)  # partialSumOrig(sum(y=n)) == sum(x, 8)
partialSumNew = partial(sum, n)       # partialSumNew(sum(n)) == sum(8, y)

print(partialSumOrig(2))  # 10        # partialSumOrig(sum(2, 8)) == sum(2, 8)
print(partialSumNew(2))   # 10        # partialSumNew(sum(8, 2)) == sum(8, 2)

展示如何在部分中传递参数的最后一个示例：

...
n = 2
m = 2
partialSumSilly = partial(sum, n, m)  # partialSumSilly(sum(n, m)) == sum(2, 2)
print(partialSumSilly())              # 4

最大的收获是：

• normalSum() 行为类似于后期绑定，其中 n 在运行时进行评估。
• partialSum() 行为类似于早期绑定，其中 n 在定义时进行计算。

注意：实际上，由于其解释性质，几乎所有内容都是 cpython 中的后期绑定。