Python多处理包装器

我有一个简单的多处理包装器。它接受一个函数并并行运行，然后返回数据

然而，我似乎在硬编码我的论点。我不确定如何传递更动态的参数列表

这是我的密码

import multiprocessing as mp                                                     
import time                                                                      

class MPWrap(object):                                                            
    def __init__(self,verbose=False):                                            
        self.a=mp.Pool(10)                                                       
        self.resultObj=[]                                                        
        self.verbose=verbose                                                     

    def apply(self,func,args):                                                   
        for i in args:                                                           
            self.resultObj.append(                                               
                    self.a.apply_async(func,kwds={'x':i})                        
                )                                                                

    def status(self):                                                            
        incomplete_count = sum(1 for x in self.resultObj if not x.ready())       
        if self.verbose:                                                         
          s="todo %d/%d tasks"%(incomplete_count,len(self.resultObj))            
          print s                                                                
        return incomplete_count                                                  

    def get(self):                                                               
        return  [ i.get() for i in self.resultObj ]                              

    def __del__(self):                                                           
        self.a.close()                                                           
        self.a.join()                                                            
        print "Done..."                                                          



def square(x):                                                                   
    time.sleep(x)                                                                
    return x*x                                                                   

def main():                                                                      
    x=MPWrap()                                                                   

    x.apply(square,                                                              
            args=[1,2,3,4,5,6,7,8,9]                                             
            )                                                                    
    while x.status() is None:                                                    
        time.sleep(.5)                                                           
        if x.status()==0:break                                                   
    print x.get()  

if __name__=="__main__":                                                                      x[1, 4, 9, 16, 25, 36, 49, 64, 81]
    main()         

---

使用函数生成函数参数应该可以：

def apply(self,func,args,fargs=lambda i:(),fkwargs=lambda i:{}):                                                   
    for i in args:                                                           
        self.resultObj.append(                                               
                self.a.apply_async(func,fargs(i),fkwargs(i))                        
            )

及

x.apply(square,                                                              
        args=[1,2,3,4,5,6,7,8,9],
        fkwargs=lambda i: {'x':i}                                             
        ) 

apply_async用于运行独立的单个任务。如果有一组相同的任务，则应使用map_async或其变体之一。实际上，我不确定您的包装器提供的不是来自map\u async的内容

考虑：

def main():
    x = Pool(10)
    res = x.map_async(square, range(1,10))
    while not res.ready():
        res.wait(0.5)
    print res.get()

ETA：如果你想通过map函数来概括参数，我可以看到为这个目的创建包装的一些价值。考虑一下：

def unwrap(fdesc):
    (f, args, kwargs) = fdesc
    return (f, f(*args, **kwargs))

然后，您可以调用x.map_asyncunwrap、[square、[i]、{}for i in range1,10]，返回的结果是一个用函数键控的元组，因此，如果您使用多个函数，您可以区分和解释结果

---

基本上，您可以创建一个元组列表，其中包含函数、位置参数和关键字参数，然后将整个列表提供给map_async的一个调用。

我的包装器试图做的是删除池初始化和其他组件。我只是尝试初始化这个类，将任何函数与其适当的参数放在其中，然后得到它们的结果。也许，我应该坚持你提供给我的基本代码。我只是好奇而已all@user3589054我已经更新了我的答案，为您提供了通用的函数和参数处理，同时仍然使用multiprocessing.Pool结构。