Gibt es eine Möglichkeit, Python Multithreads mit Wörterbüchern

Question

ausführen Ich frage mich, ob es sowieso mehrere Threads ausführen und die Ergebnisse des anderen Threads bestimmten Schlüsseln in dict zuweisen. Etwas wie folgt aus:

from joblib import Parallel, delayed 
from math import sqrt 
dict_of_sqrt = {} 
i = {'a':1,'b':2,'c':3,'e':4} 
dict_of_sqrt[k] = Parallel(n_jobs=2)(delayed(sqrt)(v**2) for k, v in i.items()) 

Das Ergebnis sollte das Wörterbuch mit den gleichen Schlüssel und zugeordneten neuen Werte berechnet parallel sein:

dict_of_sqrt = {'a':1, 'b':1.41, 'c'=1.73, 'e'=2} 

Es nehme an, sicher zu sein, weil ich schreibe auf verschiedene Schlüssel (ohne sich zu überlappen). Ich habe jedoch kein Beispiel gefunden.

Answer 1

Wenn Sie eine IO-Operation machen, dann können Sie Threads, aber wenn Sie eine CPU-intensive Operation durchgeführt haben, müssen Sie GIL berücksichtigen, so dass ich stattdessen verarbeiten werde.

Wenn Sie Multiprocessing-Bibliothek verwenden, denke ich, dass Pool das beste Objekt für Sie ist, wie Sie die Anzahl der ausführenden Threads steuern möchten. Um den Prozess auszuführen, können Sie entweder map oder apply_async mit einer Callback-Funktion verwenden. Sie können hier mehr über Karte vs apply_async lesen: Python multiprocessing.Pool: when to use apply, apply_async or map?

Ich mag das Queue-Objekt verwenden, um Daten an dem übergeordneten Prozess zurückzukehren, wie es Multiprozessing/Thread-sicher, aber es macht den über Kopf über die Queue zu gehen und Verarbeitung der Ergebnisse

Hier ist ein kurzes Beispiel für eine grundlegende Verwendung.

import multiprocessing 
from Queue import Empty 
from math import sqrt 
import string 



def my_sqrt(*args): 
    k, v, q = args[0] 
    q.put({k: sqrt(v)}) 

def main(): 

    p = multiprocessing.Pool(2) 
    m = multiprocessing.Manager() 
    q = m.Queue() 

    # This is just to generate data. 
    l = [(k, (v + 1)**2, q) for v, k in enumerate(string.lowercase)] 
    p.map(my_sqrt, l) 

    # Go over the Q 
    d = dict() 
    try: 
     while 1: 
      m = q.get_nowait() 
      d.update(m) 
    except Empty: 
     pass 

    print d 

if __name__ == '__main__': 
    main() 

Answer 2

Aktualisiert

from multiprocessing import Pool 
from time import sleep 
from random import choice 
import math 


# function that may take up to 5 seconds 
def myroot(t): 
    sleep(choice(range(5))) 
    return {t[0]:math.sqrt(t[1])} 

if __name__ == '__main__': 
    # dictionary keys -> n 
    # value should be n**2 
    d = {'a':1,'b':2,'c':3,'e':4} 
    dt = [(i,d[i]) for i in d] 
    # spawn 3 processes 
    pool = Pool(3) 
    # iterate all keys, feed them in sqr fuc 
    results = pool.map(myroot, dt) 
    # update object d, with result from each process 
    [d.update(i) for i in results] 
    print(d) 

Answer 3

Sie können die Werte parallel berechnet werden müssen und kehrte als Tupel Paare, von den neuen Schlüssel und Werte. Im aufrufenden Prozess müssen Sie es dann nur in ein Wörterbuch konvertieren.

from math import sqrt 
from multiprocessing import Pool 

i = {'a':1,'b':2,'c':3,'e':4} 

# pass me to `starmap` 
def sqrtval(k, v): 
    return k, sqrt(v) 

# pass me to `map` 
def sqrtval_py2(kv): 
    k, v = kv 
    return k, sqrt(v) 

tup = Pool().starmap(sqrtval, i.items()) 
# tup = Pool().map(sqrtval_py2, i.items()) 

print(tup) 
print(dict(tup)) 

Python 2 hat keinen starmap Verfahren für ein multiprocessing.Pool, so zur Bekämpfung dies der sqrtval würde ein Tupel von Schlüssel/Wert zu übernehmen haben und verwenden, die innerhalb der Abbildungsfunktion. Die Python 2-Alternative wird ebenfalls bereitgestellt.