Python：多进程传参missing 1 required positional argument

问题引出

许多时候，我们对程序的速度都是有要求的，速度自然是越快越好。对于Python的话，一般都是使用multiprocessing这个库来实现程序的多进程化，例如：

我们有一个函数my_print，它的作用是打印我们的输入：

def my_print(x):
    print(x)

但是我们嫌它的速度太慢了，因此我们要将这个程序多进程化：

from multiprocessing import Pool
 
def my_print(x):
    print(x)
 
if __name__ == "__main__":
    x = [1, 2, 3, 4, 5]
    pool = Pool()
    pool.map(my_print, x)
    pool.close()
    pool.join()

很好，现在速度与之前的单进程相比提升非常的快，但是问题来了，如果我们的参数不只有一个x，而是有多个，这样能行吗？比如现在my_print新增一个参数y：

def my_print(x, y):
    print(x + y)

查看pool.map的函数说明：

def map(self, func, iterable, chunksize=None):
    '''
    Apply `func` to each element in `iterable`, collecting the results
    in a list that is returned.
    '''
    return self._map_async(func, iterable, mapstar, chunksize).get()

发现函数的参数是作为iter传进去的，但是我们现在有两个参数，自然想到使用zip将参数进行打包：

if __name__ == "__main__":
    x = [1, 2, 3, 4, 5]
    y = [1, 1, 1, 1, 1]
    zip_args = list(zip(x, y))
    pool = Pool()
    pool.map(my_print, zip_args)
    pool.close()
    pool.join()

可是执行后却发现，y参数并没有被传进去：

在这里插入图片描述
那么如何传入多个参数呢？这也就是本文的重点，接着往下看吧。

解决方案

2.1 使用偏函数（partial）
偏函数有点像数学中的偏导数，可以让我们只关注其中的某一个变量而不考虑其他变量的影响。上面的例子中，Y始终等于1，那么我们在传入参数的时候，只需要考虑X的变化即可。例如你有一个函数，该函数有两个参数a,b，a是不同路径的下的图片的路径，b是输出的路径。很明显，a是一直在变化的，但是因为我们要将所有图片保存在同一个文件夹下，那么b很可能一直都没变。具体如下：

if __name__ == '__main__':# 多线程，多参数，partial版本
    x = [1, 2, 3, 4, 5]
    y = 1
 
    partial_func = partial(my_print, y=y)
    pool = Pool()
    pool.map(partial_func, x)
    pool.close()
    pool.join()

2.2 使用可变参数
在Python函数中，函数可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，这就直接给我们提供了一种思路。具体如下：

def multi_wrapper(args):
   return my_print(*args)
 
def my_print(x, y):
    print(x + y)
if __name__ == "__main__": # 多线程，多参数，可变参数版本
    x = [1, 2, 3, 4, 5]
    y = [1, 1, 1, 1, 1]
    zip_args = list(zip(x, y))
 
    pool = Pool()
    pool.map(multi_wrapper, zip_args)
    pool.close()
    pool.join()

2.3 使用pathos提供的多进程库

from pathos.multiprocessing import ProcessingPool as newPool
 
if __name__ == '__main__':# 多线程，多参数，pathos版本
    x = [1, 2, 3, 4, 5]
    y = [1, 1, 1, 1, 1]
 
    pool = newPool()
    pool.map(my_print, x, y)
    pool.close()
    pool.join()

在该库的map函数下，可以看到，它允许多参数输入，其实也就是使用了可变参数：

def map(self, f, *args, **kwds):
    AbstractWorkerPool._AbstractWorkerPool__map(self, f, *args, **kwds)
    _pool = self._serve()
    return _pool.map(star(f), zip(*args)) # chunksize

2.4 使用starmap函数

if __name__ == '__main__': # 多线程，多参数，starmap版本
    x = [1, 2, 3, 4, 5]
    y = [1, 1, 1, 1, 1]
 
    zip_args = list(zip(x, y))
    pool = Pool()
    pool.starmap(my_print, zip_args)
    pool.close()
    pool.join()

总结

其实在以上4种实现方法中，第1种方法的限制较多，如果该函数的其它参数都在变化的话，那么它就不能很好地工作，而剩下的方法从体验上来讲是依次递增的，它们都可以接受任意多参数的输入，但是第2种需要额外写一个函数，扣分；第3种方法需要额外安装pathos包，扣分；而最后一种方法不需要任何额外不择就可以完成，所以，推荐大家选择第4种方法！

————————————————
版权声明：本文为CSDN博主「Jayce~」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_15969343/article/details/84672527

BBJG_001

发布了157 篇原创文章 · 获赞 163 · 访问量 2万+

私信关注

Python：多进程传参missing 1 required positional argument

猜你喜欢