क्या कोई मल्टीथ्रेडेड मानचित्र() फ़ंक्शन है?

Question

मेरे पास एक ऐसा फ़ंक्शन है जो साइड-इफेक्ट मुक्त है। मैं इसे एक सरणी में प्रत्येक तत्व के लिए चलाने के लिए और सभी परिणामों के साथ एक सरणी वापस करना चाहते हैं।

क्या पाइथन के पास सभी मूल्यों को उत्पन्न करने के लिए कुछ है?

Answer 1

बहु से Pool.map समारोह का प्रयास करें:

http://docs.python.org/library/multiprocessing.html#using-a-pool-of-workers

यह प्रति-se थ्रेड नहीं कर रहा है, लेकिन वह वास्तव में अच्छा है के बाद से बहु सूत्रण गंभीर रूप से Gil द्वारा पायथन में अपंग है।

Answer 2

आप मल्टीप्रोसेसिंग पायथन पैकेज (http://docs.python.org/library/multiprocessing.html) का उपयोग कर सकते हैं। क्लाउड पायथन पैकेज, PiCloud (http://www.picloud.com) से उपलब्ध है, एक मल्टी प्रोसेसिंग मैप() फ़ंक्शन भी प्रदान करता है, जो क्लाउड पर आपके मानचित्र को ऑफ़लोड कर सकता है।

Answer 3

यह कार्यक्षमता नहीं बनाई गई है। हालांकि, someone has already implemented it।

Answer 4

मुझे लगता है कि ऐसा कोई कार्य करने का कोई कारण नहीं होगा। सभी पायथन थ्रेड को एक ही सीपीयू पर निष्पादित करना होता है। मान लें कि आपके मानचित्र फ़ंक्शन में कोई I/O घटक नहीं है, आपको प्रसंस्करण में कोई गति दिखाई नहीं देगी (और संदर्भ स्विचिंग के कारण शायद मंदी दिखाई देगी)।

अन्य पोस्टर्स ने मल्टीप्रोसेसिंग का उल्लेख किया है - यह शायद एक बेहतर विचार है।

Answer 5

शायद Unladen Swallow Python 3 कार्यान्वयन का प्रयास करें? यह एक प्रमुख परियोजना हो सकती है, और स्थिर होने की गारंटी नहीं है, लेकिन यदि आप इच्छुक हैं तो यह काम कर सकता है। फिर list or set comprehensions उपयोग करने के लिए उचित कार्यात्मक संरचना की तरह लग रहा है।

Answer 6

पायथन अब समवर्ती। फ्यूचर्स मॉड्यूल है, जो एकाधिक धागे या एकाधिक प्रक्रियाओं के साथ काम करने के लिए मानचित्र प्राप्त करने का सबसे आसान तरीका है।

https://docs.python.org/3/library/concurrent.futures.html

Answer 7

नीचे मेरी map_parallel कार्य है। यह map की तरह काम करता है, सिवाय इसके कि यह प्रत्येक तत्व को एक अलग थ्रेड में समानांतर में चला सकता है (लेकिन नीचे नोट देखें)। यह उत्तर another SO answer पर बनाता है।

import threading 
import logging 
def map_parallel(f, iter, max_parallel = 10): 
    """Just like map(f, iter) but each is done in a separate thread.""" 
    # Put all of the items in the queue, keep track of order. 
    from queue import Queue, Empty 
    total_items = 0 
    queue = Queue() 
    for i, arg in enumerate(iter): 
     queue.put((i, arg)) 
     total_items += 1 
    # No point in creating more thread objects than necessary. 
    if max_parallel > total_items: 
     max_parallel = total_items 

    # The worker thread. 
    res = {} 
    errors = {} 
    class Worker(threading.Thread): 
     def run(self): 
      while not errors: 
       try: 
        num, arg = queue.get(block = False) 
        try: 
         res[num] = f(arg) 
        except Exception as e: 
         errors[num] = sys.exc_info() 
       except Empty: 
        break 

    # Create the threads. 
    threads = [Worker() for _ in range(max_parallel)] 
    # Start the threads. 
    [t.start() for t in threads] 
    # Wait for the threads to finish. 
    [t.join() for t in threads] 

    if errors: 
     if len(errors) > 1: 
      logging.warning("map_parallel multiple errors: %d:\n%s"%(
       len(errors), errors)) 
     # Just raise the first one. 
     item_i = min(errors.keys()) 
     type, value, tb = errors[item_i] 
     # Print the original traceback 
     logging.info("map_parallel exception on item %s/%s:\n%s"%(
      item_i, total_items, "\n".join(traceback.format_tb(tb)))) 
     raise value 
    return [res[i] for i in range(len(res))] 

नोट: एक बात का ध्यान के अपवाद है। सामान्य map की तरह, उपर्युक्त फ़ंक्शन अपवाद उठाता है यदि इसका कोई उप-धागा अपवाद उठाता है, और पुनरावृत्ति को रोक देगा। हालांकि, समानांतर प्रकृति के कारण, इस बात की कोई गारंटी नहीं है कि सबसे पहला तत्व पहला अपवाद उठाएगा।