Python bietet verschiedene Möglichkeiten zur Parallele für Schleifen mit jeweils eigenen Stärken und Schwächen. Die beste Wahl hängt von der Art der Arbeit innerhalb der Schleife und der verfügbaren Hardware ab.
1. `multiprocessing`: Dies ist im Allgemeinen die beste Wahl für CPU-gebundene Aufgaben (Aufgaben, die die meiste Zeit damit verbringen, Berechnungen zu erledigen). Es schafft mehrere Prozesse mit jeweils einen eigenen Dolmetscher, was eine echte Parallelität ermöglicht und die globale Interpreter -Sperre (GIL) umgeht, die das Fäden in CPython einschränkt.
`` `Python
Multiprozessierung importieren
Def Process_Item (Element):
"" Die Funktion, die parallel ausgeführt wird. "" ""
# Ihr Code zur Verarbeitung eines einzelnen Elements geht hier.
Ergebnis =Element * 2 # Beispiel:Verdoppeln Sie das Element
Rückgabeergebnis
Wenn __name__ =='__main__':# wichtig für die Windows -Kompatibilität wichtig ist
Elemente =Bereich (10)
mit Multiprocessing.pool (processes =multiprocessing.cpu_count ()) als Pool:
Ergebnisse =Pool.map (process_item, Elemente)
Druck (Ergebnisse)
`` `
* `multiprocessing.pool` erstellt einen Pool von Arbeitsprozessen.
* `pool.map` wendet` process_item` auf jedes Element in `items` gleichzeitig an. Es gibt eine Liste der Ergebnisse in der gleichen Reihenfolge wie die Eingabe zurück.
* `multiprocessing.cpu_count ()` Bestimmt die Anzahl der CPU -Kerne und ermöglicht eine optimale Parallelität. Sie können bei Bedarf eine geringere Anzahl von Prozessen angeben.
2. `Concurrent.futures`: Dies bietet sowohl Threads als auch Prozesse eine höhere Schnittstelle über höhere Ebene und bietet mehr Flexibilität. Für CPU-gebundene Aufgaben möchten Sie `ProcessPoolexecutor` verwenden.
`` `Python
importieren
Def Process_Item (Element):
"" Die Funktion, die parallel ausgeführt wird. "" ""
# Ihr Code zur Verarbeitung eines einzelnen Elements geht hier.
Ergebnis =Element * 2 # Beispiel:Verdoppeln Sie das Element
RECHTIONISIERUNG RETUTION, ERGEBNISSE #REITEN SIE SCHNITTE UND AUSGABE AUF DER SPACE
Wenn __name__ =='__main__':
Elemente =Bereich (10)
mit Concurrent.futures.Processpoolexecutor () als Testamentsvollstrecker:
results =executor.map (process_item, items) #order erhalten erhalten
Für den Artikel führen Sie zu Ergebnissen:
print (f "Eingabe:{Element}, Ausgabe:{Ergebnis}")
`` `
`Concurrent.futures` bietet mehr Kontrolle, insbesondere mit` Executor.Submit` für individuelle Aufgaben und Handhabungsausnahmen.
3. `Threading` (im Allgemeinen nicht für CPU-gebundene Aufgaben empfohlen): Das Threading eignet sich für I/O-gebundene Aufgaben (Aufgaben, die die meiste Zeit auf externe Ressourcen wie Netzwerkanfragen oder Festplattenbetrieb verbringen). Aufgrund des GIL bieten Fäden in CPython keine echte Parallelität für CPU-gebundene Aufgaben.
`` `Python
Threading importieren
Def process_item (Element, Ergebnisse):
#Ihr Code, um einen einzelnen Element zu verarbeiten, geht hier.
result =item * 2 #example:doppelung des teature
results.append (Ergebnis)
Wenn __name__ =='__main__':
Elemente =Bereich (10)
Ergebnisse =[]
Threads =[]
Für Artikel in Artikeln:
thread =threading.thread (target =process_item, args =(item, Ergebnisse))
threads.append (Thread)
thread.start ()
Für Threads in Threads:
thread.join ()
Druck (Ergebnisse)
`` `
In diesem Beispiel wird eine gemeinsam genutzte Liste ("Ergebnisse" verwendet, die für die Gewindesicherheit sorgfältig berücksichtigt werden muss (bei Bedarf mit Schlösser). Es ist komplexer als "Multiprocessing" oder "Concurrent.Futures" für CPU-gebundene Workloads und wahrscheinlich keinen Leistungsschub für sie darstellt.
die richtige Methode auswählen:
* CPU-gebunden: Verwenden Sie `multiprocessing` oder` concurrent.futures` mit `ProcessPoolexecutor`. `multiprocessing` ist im Allgemeinen einfacher für einfache Map-Reduce-Operationen.
* I/O-Bound: Verwenden Sie `Threading` oder` concurrent.futures` mit `threadpoolexecutor`. `Concurrent.futures` bietet eine bessere Ausnahmebehandlung und -kontrolle.
* gemischt: Möglicherweise ist ein Hybridansatz erforderlich, der Prozesse für CPU-intensive Teile und Fäden für I/O-gebundene Teile kombiniert.
Denken Sie daran, potenzielle Ausnahmen innerhalb Ihrer Arbeiterfunktionen zu bewältigen und den Aufwand des Erstellens und Verwaltens von Prozessen oder Threads zu berücksichtigen. Bei sehr kleinen Aufgaben könnte der Overhead die Vorteile der Parallelisierung überwiegen. Profilieren Sie Ihren Code, um festzustellen, ob die Parallelisierung tatsächlich eine Leistungsverbesserung bereitstellt.
