我不能得到我的头如何部分工作在functools。 我有以下代码从这里:
>>> 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
现在在队列中
incr = lambda y : sum(1, y)
我得到，无论我传递给incr的参数是什么，它都会作为y传递给lambda，它会返回sum(1, y)即1 + y。
我理解。但是我不明白这一点。
在偏函数中，4是如何作为x传递的?对我来说，4应该取代求和2。x和4的关系是什么?
当前回答
偏导数非常有用。
例如，在“管道式”函数调用序列中(其中一个函数的返回值是传递给下一个函数的参数)。
有时，这样的管道中的函数需要一个参数，但它的上游函数返回两个值。
在这个场景中，使用functools。Partial可能允许您保持这个函数管道的完整性。
这里有一个具体的孤立的例子:假设你想要根据每个数据点到某个目标的距离对一些数据进行排序:
# create some data
import random as RND
fnx = lambda: RND.randint(0, 10)
data = [ (fnx(), fnx()) for c in range(10) ]
target = (2, 4)
import math
def euclid_dist(v1, v2):
x1, y1 = v1
x2, y2 = v2
return math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
要根据与目标的距离对这些数据进行排序，你需要做的当然是:
data.sort(key=euclid_dist)
但你不能——sort方法的key形参只接受接受单个参数的函数。
所以把euclid_dist重写成一个带单参数的函数:
from functools import partial
p_euclid_dist = partial(euclid_dist, target)
P_euclid_dist现在接受一个参数，
>>> p_euclid_dist((3, 3))
1.4142135623730951
所以现在你可以通过传入sort方法的key参数的partial函数来排序你的数据:
data.sort(key=p_euclid_dist)
# verify that it works:
for p in data:
print(round(p_euclid_dist(p), 3))
1.0
2.236
2.236
3.606
4.243
5.0
5.831
6.325
7.071
8.602
或者，例如，函数的一个参数在外部循环中发生了变化，但在内部循环的迭代中是固定的。通过使用partial，您不必在内部循环迭代期间传递额外的参数，因为修改后的(partial)函数不需要它。
>>> from functools import partial
>>> def fnx(a, b, c):
return a + b + c
>>> fnx(3, 4, 5)
12
创建一个局部函数(使用关键字arg)
>>> pfnx = partial(fnx, a=12)
>>> pfnx(b=4, c=5)
21
您还可以使用位置参数创建偏函数
>>> pfnx = partial(fnx, 12)
>>> pfnx(4, 5)
21
但这将抛出(例如，使用关键字参数创建partial，然后使用位置参数调用)
>>> pfnx = partial(fnx, a=12)
>>> pfnx(4, 5)
Traceback (most recent call last):
File "<pyshell#80>", line 1, in <module>
pfnx(4, 5)
TypeError: fnx() got multiple values for keyword argument 'a'
另一个用例:使用python的多处理库编写分布式代码。使用pool方法创建进程池:
>>> import multiprocessing as MP
>>> # create a process pool:
>>> ppool = MP.Pool()
Pool有一个map方法，但它只接受一个可迭代对象，所以如果你需要传入一个具有更长的形参列表的函数，请将该函数重新定义为partial，以修复除一个以外的所有函数:
>>> ppool.map(pfnx, [4, 6, 7, 8])
其他回答
偏导数非常有用。
例如，在“管道式”函数调用序列中(其中一个函数的返回值是传递给下一个函数的参数)。
有时，这样的管道中的函数需要一个参数，但它的上游函数返回两个值。
在这个场景中，使用functools。Partial可能允许您保持这个函数管道的完整性。
这里有一个具体的孤立的例子:假设你想要根据每个数据点到某个目标的距离对一些数据进行排序:
# create some data
import random as RND
fnx = lambda: RND.randint(0, 10)
data = [ (fnx(), fnx()) for c in range(10) ]
target = (2, 4)
import math
def euclid_dist(v1, v2):
x1, y1 = v1
x2, y2 = v2
return math.sqrt((x2 - x1)**2 + (y2 - y1)**2)
要根据与目标的距离对这些数据进行排序，你需要做的当然是:
data.sort(key=euclid_dist)
但你不能——sort方法的key形参只接受接受单个参数的函数。
所以把euclid_dist重写成一个带单参数的函数:
from functools import partial
p_euclid_dist = partial(euclid_dist, target)
P_euclid_dist现在接受一个参数，
>>> p_euclid_dist((3, 3))
1.4142135623730951
所以现在你可以通过传入sort方法的key参数的partial函数来排序你的数据:
data.sort(key=p_euclid_dist)
# verify that it works:
for p in data:
print(round(p_euclid_dist(p), 3))
1.0
2.236
2.236
3.606
4.243
5.0
5.831
6.325
7.071
8.602
或者，例如，函数的一个参数在外部循环中发生了变化，但在内部循环的迭代中是固定的。通过使用partial，您不必在内部循环迭代期间传递额外的参数，因为修改后的(partial)函数不需要它。
>>> from functools import partial
>>> def fnx(a, b, c):
return a + b + c
>>> fnx(3, 4, 5)
12
创建一个局部函数(使用关键字arg)
>>> pfnx = partial(fnx, a=12)
>>> pfnx(b=4, c=5)
21
您还可以使用位置参数创建偏函数
>>> pfnx = partial(fnx, 12)
>>> pfnx(4, 5)
21
但这将抛出(例如，使用关键字参数创建partial，然后使用位置参数调用)
>>> pfnx = partial(fnx, a=12)
>>> pfnx(4, 5)
Traceback (most recent call last):
File "<pyshell#80>", line 1, in <module>
pfnx(4, 5)
TypeError: fnx() got multiple values for keyword argument 'a'
另一个用例:使用python的多处理库编写分布式代码。使用pool方法创建进程池:
>>> import multiprocessing as MP
>>> # create a process pool:
>>> ppool = MP.Pool()
Pool有一个map方法，但它只接受一个可迭代对象，所以如果你需要传入一个具有更长的形参列表的函数，请将该函数重新定义为partial，以修复除一个以外的所有函数:
>>> ppool.map(pfnx, [4, 6, 7, 8])
在我看来，这是在python中实现curry的一种方式。
from functools import partial
def add(a,b):
return a + b
def add2number(x,y,z):
return x + y + z
if __name__ == "__main__":
add2 = partial(add,2)
print("result of add2 ",add2(1))
add3 = partial(partial(add2number,1),2)
print("result of add3",add3(1))
结果是3和4。
另外值得一提的是，当部分函数传递给另一个函数时，我们想要“硬编码”一些参数，那应该是最右边的参数
def func(a,b):
return a*b
prt = partial(func, b=7)
print(prt(4))
#return 28
但如果我们做同样的事情，只是改变一个参数
def func(a,b):
return a*b
prt = partial(func, a=7)
print(prt(4))
它会抛出错误， "TypeError: func()获得了参数'a'的多个值"
从机器学习的例子中加入了函数式编程的functools。Partial非常有用:
在同一数据集上构建多个模型
下面的例子展示了如何在同一个糖尿病数据集上拟合线性回归、支持向量机和随机森林回归模型，以预测目标并计算得分。
(部分)函数classify_diabetes()是通过curry(使用functools.partial())从函数classify_data()创建的。后面的函数不再需要传递数据，我们可以直接只传递模型类的实例。
from functools import partial
from sklearn.linear_model import LinearRegression
from sklearn.svm import SVR
from sklearn.ensemble import RandomForestRegressor
from sklearn.datasets import load_diabetes
def classify_data(data, model):
reg = model.fit(data['data'], data['target'])
return model.score(data['data'], data['target'])
diabetes = load_diabetes()
classify_diabetes = partial(classify_data, diabetes) # curry
for model in [LinearRegression(), SVR(), RandomForestRegressor()]:
print(f'model {type(model).__name__}: score = {classify_diabetes(model)}')
# model LinearRegression: score = 0.5177494254132934
# model SVR: score = 0.2071794500005485
# model RandomForestRegressor: score = 0.9216794155402649
建立机器学习管道
在这里，函数pipeline()是用咖喱创建的，它已经使用StandardScaler()在拟合模型之前对数据进行预处理(缩放/规范化)，如下面的例子所示:
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
pipeline = partial(make_pipeline, StandardScaler()) # curry
for model in [LinearRegression(), SVR(), RandomForestRegressor()]:
print(f"model {type(model).__name__}: " \
f"score = {pipeline(model).fit(diabetes['data'], diabetes['target'])\
.score(diabetes['data'], diabetes['target'])}")
# model LinearRegression: score = 0.5177494254132934
# model SVR: score = 0.2071794500005446
# model RandomForestRegressor: score = 0.9180227193805106
简而言之，partial为函数的参数提供默认值，否则这些参数将没有默认值。
from functools import partial
def foo(a,b):
return a+b
bar = partial(foo, a=1) # equivalent to: foo(a=1, b)
bar(b=10)
#11 = 1+10
bar(a=101, b=10)
#111=101+10
