Python har inte en inbyggd "parfor" som Matlab. De närmaste ekvivalenterna involverar att använda multiprocessingbibliotek för att uppnå parallella "för" slingbeteende. Det bästa tillvägagångssättet beror på arten av din uppgift:
1. `multiprocessing.pool` för CPU-bundna uppgifter:
Detta är lämpligt när dina loop-iterationer är oberoende och beräkningsintensiva (CPU-bundna). Det är effektivt för att distribuera arbete över flera CPU -kärnor.
`` `python
importera multiprocessing
def my_function (i):
"" "Den funktion som ska köras parallellt." ""
# Din kod här ...
resultat =i * 2 # exempel
avkastningsresultat
om __name__ =='__main__':
med multiprocessing.pool (processer =multiprocessing.cpu_count ()) som pool:
resultat =pool.map (my_function, intervall (10)) # intervall (10) är ditt "för" loop range
Tryck (resultat) # Output:[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
`` `
`multiprocessing.pool.map` gäller` my_function 'för varje element i `intervall (10)' parallellt. `multiprocessing.cpu_count ()` bestämmer det optimala antalet processer. Justera detta baserat på ditt system och antalet tillgängliga kärnor. Kom ihåg `om __Name__ =='__Main __':'Blocket är avgörande för korrekt multiprocessing på Windows.
2. `Concurrent.futures.processpoolexecutor` (mer flexibel):
Detta erbjuder mer kontroll och flexibilitet än "multiprocessing.pool", särskilt om du behöver mer finkornig kontroll eller felhantering.
`` `python
importera samtidiga.
def my_function (i):
# Din kod här ...
resultat =i * 2
Return I, resultat #återvänd det ursprungliga indexet och resultatet är till hjälp för att hålla reda på
om __name__ =='__main__':
med samtidiga.futures.processpoolExecutor () som exekutiv:
resultat =exekutor.map (my_function, intervall (10))
För jag, resultera i resultat:
utskrift (f "input:{i}, output:{result}")
`` `
`Executor.map 'liknar` pool.map', men gör det möjligt att höja och hanteras undantag. Du kan också använda "executor.submit" för mer asynkron kontroll.
3. `Joblib` för enklare syntax (ofta snabbare):
`Joblib` förenklar parallellbehandling, särskilt för numpy -matriser. Det fungerar ofta bättre än "multiprocessing" för specifika numeriska operationer.
`` `python
Från joblib importera parallell, försenad
def my_function (i):
# Din kod här ...
resultat =i * 2
avkastningsresultat
om __name__ =='__main__':
resultat =parallell (n_jobs =multiprocessing.cpu_count ()) (försenad (my_function) (i) för i inom räckvidd (10))
utskrift (resultat)
`` `
`Joblib` hanterar automatiskt uppgiftsdistributionen och resultattaggregeringen. `n_jobs` anger antalet parallella processer.
Viktiga överväganden:
* overhead: Parallell bearbetning introducerar omkostnader från process skapande och kommunikation. För mycket små uppgifter kan omkostnaderna uppväga fördelarna.
* Datadelning: Undvik att dela muterbara data direkt mellan processer; Passera istället kopior eller använd kommunikationsmekanismer mellan processer (köer, rör) vid behov.
* Beroenden: Se till att dina funktioner och deras beroenden är korrekt förpackade och tillgängliga för varje arbetarprocess.
* i/o-bundna uppgifter: Om din slinga involverar betydande I/O -operationer (t.ex. nätverksförfrågningar, filläsningar), kan du använda "multiprocessing" inte ge betydande hastighet. Tänk på `Asyncio 'eller` gängning' istället (även om 'gängning' begränsas av den globala tolklåset (GIL) i CPython).
Välj den metod som bäst passar dina behov och egenskaperna för din uppgift. För enkla fall ger "Joblib" ofta den enklaste och mest effektiva lösningen. För mer komplexa scenarier med asynkrona operationer eller finkornig kontroll är `samtidig.Futures" mer kraftfull. Kom ihåg att alltid profilera din kod för att bestämma de faktiska prestandavinsterna.
