Python 映射异步与应用异步：在这种情况下我应该使用什么

我正在处理一些ascii数据，进行一些操作，然后将所有内容写回另一个文件（由

post\u processing\u 0.main完成的作业，不返回任何内容）。我想将代码与多处理模块并行，请参阅以下代码段：

from multiprocessing import Pool
import post_processing_0

def chunks(lst,n):
    return [ lst[i::n] for i in xrange(n) ]

def main():
    pool = Pool(processes=proc_num)
    P={}
    for i in range(0,proc_num):
        P['process_'+str(i)]=pool.apply_async(post_processing_0.main, [split_list[i]])
    pool.close()
    pool.join()


proc_num=8
timesteps=100
list_to_do=range(0,timesteps)
split_list=chunks(list_to_do,proc_num)

main()

我读过map和async之间的区别，但我不太理解。我对多处理模块的应用正确吗

在这种情况下，我应该使用map\u async还是apply\u async？为什么

编辑：

我不认为这是问题的重复。在问题中，答案集中在使用这两个函数可以得到的结果的顺序上。这里我要问的是：当没有返回任何内容时有什么区别？
apply\u async
向池提交单个作业
map\u async
提交多个作业，这些作业使用不同的参数调用同一个函数。前者采用函数加参数列表；后者采用一个函数加上表示参数的iterable（即序列）
map\u async
只能调用一元函数（即使用一个参数的函数）

在您的情况下，最好稍微重新构造代码，将所有参数放在一个列表中，然后使用该列表调用一次
map\u async
。
我建议
map\u async
，原因有三：

这是一个看起来更干净的代码。这：

pool = Pool(processes=proc_num)
async_result = pool.map_async(post_processing_0.main, split_list)
pool.close()
pool.join()

看起来比这更好：

pool = Pool(processes=proc_num)
P={}
for i in range(0,proc_num):
    P['process_'+str(i)]=pool.apply_async(post_processing_0.main, [split_list[i]])
pool.close()
pool.join()


使用
apply\u async
，如果在
post\u processing\u 0.main
中发生异常，除非在失败的
AsyncResult
对象上显式调用
p['process\u x'].get（）
，这将需要对所有
p
对象进行迭代，否则您将无法知道该异常。使用
map\u async
时，如果调用
async\u result.get（）
，则会引发异常-无需迭代

map\u async
具有内置的分块功能，如果
split\u list
非常大，这将使您的代码性能显著提高

除此之外，如果你不关心结果，行为基本上是一样的。
我读到的问题可能重复，但这并不能消除我的疑虑。我要问一个更严格的问题：在这个情况下，什么是区别，没有并行化函数返回的结果，所以如果我们考虑4个进程和16个文件到后进程，MAP将“创建”16个同时运行的实例？你的意思是池大小为4，参数列表的大小为16？在这种情况下，一次只运行4个；第一个完成后，第五个将开始，等等。好的！然后我明白了没有区别（除了修改代码）。对吗？我在回答中说了区别是什么。例如，
map\u async
只能调用一元函数。尽管我读到的其他答案仍然给我留下了疑问，但这个答案以非常简洁的方式澄清了“apply\u async”和“map\u async”之间的区别。非常感谢。