मल्टीप्रोसेसिंग के साथ फ़ंक्शन का रिटर्न वैल्यू वैरिएबल पर असाइन करना? और आईडीएलई के बारे में एक समस्या है?

Question

मैं अजगर में मल्टीप्रोसेसिंग को समझने की कोशिश कर रहा हूं।

from multiprocessing import Process 

def multiply(a,b): 
    print(a*b) 
    return a*b 

if __name__ == '__main__': 
    p = Process(target= multiply, args= (5,4)) 
    p.start() 
    p.join() 
    print("ok.") 

इस codeblock, उदाहरण के लिए, यदि कोई चर कि "परिणाम" कहा जाता था। हम "परिणाम" में गुणात्मक कार्य के वापसी मूल्य को कैसे आवंटित कर सकते हैं?

और आईडीएलई के बारे में एक छोटी सी समस्या: जब मुझे पाइथन शेल के साथ इस नमूना को चलाने की कोशिश की जाती है, तो यह ठीक से काम नहीं करता है? मैं दोगुना .py फ़ाइल क्लिक करते हैं, उत्पादन है कि तरह है:

20 
ok. 

लेकिन अगर मैं निष्क्रिय में इस चलाने का प्रयास:

ok. 

धन्यवाद ...

Answer 1

ठीक है, मैं किसी भी तरह कामयाब इस। मैंने पायथन दस्तावेज देखा, और मैंने सीखा कि: कतार वर्ग का उपयोग करने के साथ, हम एक समारोह से वापसी मूल्य प्राप्त कर सकते हैं। और मेरे कोड के अंतिम संस्करण इस तरह है:

from multiprocessing import Process, Queue 

def multiply(a,b,que): #add a argument to function for assigning a queue 
    que.put(a*b) #we're putting return value into queue 

if __name__ == '__main__': 
    queue1 = Queue() #create a queue object 
    p = Process(target= multiply, args= (5,4,queue1)) #we're setting 3rd argument to queue1 
    p.start() 
    print(queue1.get()) #and we're getting return value: 20 
    p.join() 
    print("ok.") 

और वहाँ भी है एक पाइप() फ़ंक्शन, मुझे लगता है कि हम पाइप समारोह का भी उपयोग कर सकते हैं। लेकिन कतार अब मेरे लिए काम किया है।

Answer 2

क्या इससे मदद मिलती है? यह कार्य (और उनके तर्कों) की एक सूची लेता है, समानांतर में उन्हें चलाता और रिटर्न उनके outputs .: (यह पुराना है। इस की ज्यादातर नए संस्करण https://github.com/cpbl/cpblUtilities/blob/master/parallel.py पर है)

def runFunctionsInParallel(listOf_FuncAndArgLists): 
    """ 
    Take a list of lists like [function, arg1, arg2, ...]. Run those functions in parallel, wait for them all to finish, and return the list of their return values, in order. 

(This still needs error handling ie to ensure everything returned okay.) 

    """ 
    from multiprocessing import Process, Queue 

    def storeOutputFFF(fff,theArgs,que): #add a argument to function for assigning a queue 
     print 'MULTIPROCESSING: Launching %s in parallel '%fff.func_name 
     que.put(fff(*theArgs)) #we're putting return value into queue 

    queues=[Queue() for fff in listOf_FuncAndArgLists] #create a queue object for each function 
    jobs = [Process(target=storeOutputFFF,args=[funcArgs[0],funcArgs[1:],queues[iii]]) for iii,funcArgs in enumerate(listOf_FuncAndArgLists)] 
    for job in jobs: job.start() # Launch them all 
    for job in jobs: job.join() # Wait for them all to finish 
    # And now, collect all the outputs: 
    return([queue.get() for queue in queues])