本问题已经有最佳答案，请猛点这里访问。
我需要一些方法来使用pool.map()中接受多个参数的函数。根据我的理解，pool.map()的目标函数只能有一个iterable作为参数，但是有没有其他参数也可以传入的方法？在这种情况下，我需要传递一些配置变量，比如锁()，并将信息记录到目标函数中。
我试过做一些研究，我认为我可以使用部分函数使它工作？但是我不完全理解这些是如何工作的。任何帮助都将不胜感激！下面是一个简单的例子，说明我想做什么：
def target(items, lock):
for item in items:
# Do cool stuff
if (... some condition here ...):
lock.acquire()
# Write to stdout or logfile, etc.
lock.release()
def main():
iterable = [1, 2, 3, 4, 5]
pool = multiprocessing.Pool()
pool.map(target(PASS PARAMS HERE), iterable)
pool.close()
pool.join()
这里讨论：stackoverflow.com/questions/5442910/&hellip；(我成功地使用了J.F.Sebastien的"star"方法)
请在使用多进程时使用try/finally子句，finally中包含close()和join()，以确保在发生错误时关闭进程。stackoverflow.com/questions/30506489/&hellip；
您可以使用EDOCX1[0]进行此操作(如您怀疑的那样)：
from functools import partial
def target(lock, iterable_item):
for item in iterable_item:
# Do cool stuff
if (... some condition here ...):
lock.acquire()
# Write to stdout or logfile, etc.
lock.release()
def main():
iterable = [1, 2, 3, 4, 5]
pool = multiprocessing.Pool()
l = multiprocessing.Lock()
func = partial(target, l)
pool.map(func, iterable)
pool.close()
pool.join()
例子：
def f(a, b, c):
print("{} {} {}".format(a, b, c))
def main():
iterable = [1, 2, 3, 4, 5]
pool = multiprocessing.Pool()
a ="hi"
b ="there"
func = partial(f, a, b)
pool.map(func, iterable)
pool.close()
pool.join()
if __name__ =="__main__":
main()
号
输出：
hi there 1
hi there 2
hi there 3
hi there 4
hi there 5
太棒了，我想我所需要的就是一个这样清晰的例子。非常感谢！
很好的例子。但有一个问题：为什么在target的定义中有for item in items:？
@让·弗朗索瓦。复制/粘贴错误！谢谢你指出。
那些对锁有问题的人，请查看stackoverflow.com/questions/25557686/&hellip；
如果变量在第一个位置呢？如test(input, p1, p2, p3=None)，我有p1, p2, p3固定，input变化？
@Mithril写了一个这样的顶级函数：def mytest(p1, p2, input, p3=None): test(input, p1, p2, p3=None)，然后做func = partial(mytest, some_p1, some_p2, p3=some_p3)，把func传递给pool.map。
您可以使用允许多个参数的map函数，就像在pathos中找到的multiprocessing的分叉一样。
>>> from pathos.multiprocessing import ProcessingPool as Pool
>>>
>>> def add_and_subtract(x,y):
... return x+y, x-y
...
>>> res = Pool().map(add_and_subtract, range(0,20,2), range(-5,5,1))
>>> res
[(-5, 5), (-2, 6), (1, 7), (4, 8), (7, 9), (10, 10), (13, 11), (16, 12), (19, 13), (22, 14)]
>>> Pool().map(add_and_subtract, *zip(*res))
[(0, -10), (4, -8), (8, -6), (12, -4), (16, -2), (20, 0), (24, 2), (28, 4), (32, 6), (36, 8)]
pathos使您能够轻松地用多个输入嵌套分层并行映射，因此我们可以扩展我们的示例来证明这一点。
>>> from pathos.multiprocessing import ThreadingPool as TPool
>>>
>>> res = TPool().amap(add_and_subtract, *zip(*Pool().map(add_and_subtract, range(0,20,2), range(-5,5,1))))
>>> res.get()
[(0, -10), (4, -8), (8, -6), (12, -4), (16, -2), (20, 0), (24, 2), (28, 4), (32, 6), (36, 8)]
。
更有趣的是，构建一个可以传递到池中的嵌套函数。这是可能的，因为pathos使用dill，它可以序列化Python中的几乎所有内容。
>>> def build_fun_things(f, g):
... def do_fun_things(x, y):
... return f(x,y), g(x,y)
... return do_fun_things
...
>>> def add(x,y):
... return x+y
...
>>> def sub(x,y):
... return x-y
...
>>> neato = build_fun_things(add, sub)
>>>
>>> res = TPool().imap(neato, *zip(*Pool().map(neato, range(0,20,2), range(-5,5,1))))
>>> list(res)
[(0, -10), (4, -8), (8, -6), (12, -4), (16, -2), (20, 0), (24, 2), (28, 4), (32, 6), (36, 8)]
。
但是，如果您不能走出标准库，您将不得不以另一种方式进行。在这种情况下，最好的选择是使用multiprocessing.starmap，如这里所示：python multiprocessing pool.map用于多个参数(由@roberto在OP文章的注释中指出)
获取pathos：https://github.com/uqfoundation
如果您没有访问functools.partial的权限，也可以为此使用包装函数。
def target(lock):
def wrapped_func(items):
for item in items:
# Do cool stuff
if (... some condition here ...):
lock.acquire()
# Write to stdout or logfile, etc.
lock.release()
return wrapped_func
def main():
iterable = [1, 2, 3, 4, 5]
pool = multiprocessing.Pool()
lck = multiprocessing.Lock()
pool.map(target(lck), iterable)
pool.close()
pool.join()
。
这使得target()成为一个接受锁的函数(或任何你想给出的参数)，它将返回一个只接受一个iterable作为输入的函数，但仍然可以使用你的所有其他参数。这就是最终传递给pool.map()的内容，然后应该毫无问题地执行。
我已经非常晚了，但这段代码不起作用，因为嵌套函数不能被pickle。调用target(lck)将返回嵌套的wrapped_func函数，该函数需要经过处理才能传递给工作进程，并且总是失败。