Python hat keinen eingebauten "parfor" wie Matlab. Die nächsten Äquivalente umfassen die Verwendung von Multiprozessungsbibliotheken, um paralleles "für das Schleifenverhalten" zu erreichen. Der beste Ansatz hängt von der Art Ihrer Aufgabe ab:
1. `multiprocessing.pool` Für CPU-gebundene Aufgaben:
Dies ist geeignet, wenn Ihre Schleifen-Iterationen unabhängig und rechenintensiv sind (CPU-gebunden). Es ist effizient für die Verteilung von Arbeiten über mehrere CPU -Kerne hinweg.
`` `Python
Multiprozessierung importieren
def my_function (i):
"" Die Funktion, die parallel ausgeführt wird. "" ""
# Dein Code hier ...
Ergebnis =I * 2 # Beispiel
Rückgabeergebnis
Wenn __name__ =='__main__':
mit Multiprocessing.pool (processes =multiprocessing.cpu_count ()) als Pool:
Ergebnisse =Pool.Map (my_function, Bereich (10)) # Bereich (10) ist Ihr 'for' Loop -Bereich
Druck (Ergebnisse) # Ausgabe:[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
`` `
`multiprocessing.pool.map` wendet` my_function` auf jedes Element in `Bereich (10)` parallel an. `multiprocessing.cpu_count ()` bestimmt die optimale Anzahl von Prozessen. Passen Sie dies anhand Ihres Systems und der Anzahl der verfügbaren Kerne an. Denken Sie an das "If __name__ ==" __main __ ":" Block ist entscheidend für die richtige Multiprozessierung unter Fenstern.
2. `concurrent.futures.Processpoolexecutor` (flexibler):
Dies bietet mehr Kontrolle und Flexibilität als "multiprocessing.pool", insbesondere wenn Sie eine feinkörnige Steuerung oder Fehlerbehandlung benötigen.
`` `Python
importieren
def my_function (i):
# Dein Code hier ...
Ergebnis =i * 2
Return I, Ergebnis #Returning des ursprünglichen Index und das Ergebnis ist hilfreich, um den Überblick zu behalten
Wenn __name__ =='__main__':
mit Concurrent.futures.Processpoolexecutor () als Testamentsvollstrecker:
results =Executor.map (my_function, Bereich (10))
Für mich führen Sie zu Ergebnissen:
print (f "Eingabe:{i}, Ausgabe:{Ergebnis}")
`` `
`Executor.Map` ähnelt` pool.map`, ermöglicht es jedoch, Ausnahmen zu erheben und zu behandeln. Sie können auch "Executor.Submit" verwenden, um eine asynchrone Kontrolle zu erhalten.
3. `jublib` für einfachere Syntax (oft schneller):
`jelbib` vereinfacht die parallele Verarbeitung, insbesondere für Numpy -Arrays. Es funktioniert oft besser als "Multiprocessing" für bestimmte numerische Operationen.
`` `Python
aus dem junger Import parallel, verzögert
def my_function (i):
# Dein Code hier ...
Ergebnis =i * 2
Rückgabeergebnis
Wenn __name__ =='__main__':
Ergebnisse =parallel (n_jobs =multiprocessing.cpu_count ()) (verzögert (my_function) (i) für i in Bereich (10))
Druck (Ergebnisse)
`` `
`jelbib` behandelt automatisch die Aufgabenverteilung und die Ergebnisaggregation. `n_jobs` Gibt die Anzahl der parallelen Prozesse an.
Wichtige Überlegungen:
* Overhead: Die parallele Verarbeitung führt dazu, dass Overhead aus der Erstellung und Kommunikation von Prozessen führt. Bei sehr kleinen Aufgaben könnte der Overhead die Vorteile überwiegen.
* Datenfreigabe: Vermeiden Sie es, veränderliche Daten direkt zwischen den Prozessen zu teilen. Gehen Sie stattdessen Kopien oder verwenden Sie die Kommunikationsmechanismen (Inter-Process) bei Bedarf.
* Abhängigkeiten: Stellen Sie sicher, dass Ihre Funktionen und ihre Abhängigkeiten für jeden Arbeitsprozess ordnungsgemäß verpackt und zur Verfügung stehen.
* I/O-gebundene Aufgaben: Wenn Ihre Schleife signifikante E/A -Vorgänge (z. B. Netzwerkanforderungen, Dateilesungen) umfasst, liefert die Verwendung von "Multiprocessing" möglicherweise keine signifikanten Beschleunigungen. Betrachten Sie stattdessen "Asyncio" oder "Threading" (obwohl "Threading" durch die globale Interpreter -Sperre (GIL) in CPython begrenzt ist).
Wählen Sie den Ansatz aus, der Ihren Bedürfnissen und den Eigenschaften Ihrer Aufgabe am besten entspricht. In einfachen Fällen bietet "JoBlib" häufig die einfachste und effizienteste Lösung. Für komplexere Szenarien mit asynchronen Operationen oder feinkörniger Kontrolle ist "Concurrent.futures" leistungsfähiger. Denken Sie daran, Ihren Code immer zu profilieren, um die tatsächlichen Leistungsgewinne zu ermitteln.
