Sie können einen Standard-`for`-Schleifen in Python nicht direkt mit dem integrierten` for`-Schleifenkonstrukt parallelisieren. Pythons Global Interpreter Lock (GIL) verhindert, dass mehrere Threads innerhalb eines einzelnen Prozesses gleichzeitig Python -Bytecodes ausführen. Dies bedeutet, dass die wahre Parallelität für CPU-gebundene Aufgaben innerhalb einer "für" Schleife mit gerechtem Faden nicht möglich ist.
Sie können jedoch mithilfe von Multiprozessing eine Parallelität erreichen, die die GIL durch Erstellen mehrerer Prozesse umgeht. So können Sie eine parallele Verarbeitung in Python mithilfe einer "für" Loop und der "Multiprocessing" -Bibliothek implementieren:
Methode 1:Verwenden von `multiprocessing.pool.map` (einfachste für viele identische Operationen)
Dies ist der einfachste Ansatz, wenn jede Iteration Ihrer Schleife denselben Betrieb für verschiedene Daten ausführt. `Pool.map` verteilt die Arbeit effizient über mehrere Prozesse hinweg.
`` `Python
Multiprozessierung importieren
Def Process_Item (Element):
"" "Die Funktion, die parallel für jedes Element ausgeführt wird." "" "
# Ihr Code, um einen einzelnen Element zu verarbeiten
# ... eine Berechnung ...
Rückgabeergebnis # Rückgabe des Ergebnisses der Berechnung
Wenn __name__ =='__main__':# wichtig für die Windows -Kompatibilität wichtig ist
Daten =[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # Ihre Daten
mit Multiprocessing.pool (processes =multiprocessing.cpu_count ()) als Pool:
Ergebnisse =pool.map (process_item, Daten)
Druck (Ergebnisse)
`` `
Dieser Code erstellt einen Pool von Arbeitsprozessen (die standardmäßig der Anzahl der CPU -Kerne entspricht). `pool.map` wendet` process_item` auf jedes Element in `Data` gleichzeitig an und gibt eine Liste der Ergebnisse in derselben Reihenfolge wie die Eingabe zurück.
Methode 2:Verwenden Sie `multiprocessing.pool.apply_async` (für komplexere Szenarien oder asynchrone Operationen)
Wenn Ihre Schleife komplexere logische oder asynchrone Operationen beinhaltet, bietet `apply_async` mehr Kontrolle.
`` `Python
Multiprozessierung importieren
Def Process_Item (Element):
# ... dein Code ...
Rückgabeergebnis
Wenn __name__ =='__main__':
Daten =[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Ergebnisse =[]
mit Multiprocessing.pool (processes =multiprocessing.cpu_count ()) als Pool:
# apply_async gibt ein asyncresult -Objekt zurück
async_results =[pool.apply_async (process_item, (item,)) für item in Data]
# Erhalten Sie die Ergebnisse (blockieren Sie, bis alle Prozesse abgeschlossen sind)
für async_result in async_results:
results.append (async_result.get ())
Druck (Ergebnisse)
`` `
Mit `Apply_async` können Sie Aufgaben einzeln einreichen und die Ergebnisse später abrufen. Dies ist nützlich, wenn die Verarbeitungszeit für jedes Element erheblich variiert.
Wichtige Überlegungen:
* `wenn __name__ =='__main __':`: Dies ist insbesondere bei Fenstern von entscheidender Bedeutung, um eine rekursive Erstellung von Prozessern zu verhindern.
* Datenfreigabe: Vermeiden Sie es, veränderliche Daten direkt zwischen den Prozessen zu teilen. Verwenden Sie Techniken wie Warteschlangen oder Pfeifen für die Kommunikation zwischen den Prozess, um die Rassenbedingungen zu verhindern.
* Overhead: Das Erstellen und Verwalten von Prozessen hat Overhead. Die parallele Verarbeitung ist für rechenintensive Aufgaben am vorteilhaftesten, bei denen die Verarbeitungszeit den Overhead erheblich überwiegt.
* Anzahl der Prozesse: Die optimale Anzahl von Prozessen entspricht häufig der Anzahl der CPU -Kerne, aber es könnte Experimente erforderlich sein.
Denken Sie daran, `# ... Ihr Code ...` durch Ihre tatsächliche Berechnung zu ersetzen. Wählen Sie die Methode aus, die der Struktur und Komplexität Ihres "For' -Schleifenbetriebs am besten entspricht. Für einfache, parallelfreundliche Operationen ist `pool.map` normalerweise der bevorzugte und effizienteste Ansatz.
