Du kan inte direkt parallellisera en standard "för" -slinga i python med bara den inbyggda "för" slingkonstruktionen. Pythons globala tolklås (GIL) förhindrar flera trådar från att utföra Python -bytekoder samtidigt inom en enda process. Detta innebär att verklig parallellism för CPU-bundna uppgifter inom en "för" -slinga är omöjligt med bara gängning.
Du kan emellertid uppnå parallellitet med multiprocessing, vilket kringgår GIL genom att skapa flera processer. Så här kan du implementera parallellbearbetning i Python med en "för" -slinga och "multiprocessing" -biblioteket:
Metod 1:Använda `multiprocessing.pool.map` (enklast för många identiska operationer)
Detta är det enklaste tillvägagångssättet om varje iteration av din slinga utför samma operation på olika data. `Pool.map` distribuerar effektivt arbetet över flera processer.
`` `python
importera multiprocessing
DEF Process_Item (artikel):
"" "Funktionen som ska köras parallellt för varje objekt." ""
# Din kod för att behandla ett enda objekt går här
# ... lite beräkning ...
Returresultat # Returnera resultatet av beräkningen
om __name__ =='__main__':# viktigt för Windows -kompatibilitet
Data =[1, 2, 3, 4, 5, 6, 7, 8, 9, 10] # Dina data
med multiprocessing.pool (processer =multiprocessing.cpu_count ()) som pool:
resultat =pool.map (process_item, data)
utskrift (resultat)
`` `
Den här koden skapar en pool av arbetarprocesser (lika med antalet CPU -kärnor som standard). `Pool.map` tillämpar` Process_Item` för varje element i `data 'samtidigt och returnerar en lista över resultaten i samma ordning som ingången.
Metod 2:Använda `multiprocessing.pool.apply_async` (för mer komplexa scenarier eller asynkrona operationer)
Om din slinga involverar mer komplexa logik eller asynkrona operationer, erbjuder `Apply_Async` mer kontroll.
`` `python
importera multiprocessing
DEF Process_Item (artikel):
# ... din kod ...
avkastningsresultat
om __name__ =='__main__':
Data =[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
resultat =[]
med multiprocessing.pool (processer =multiprocessing.cpu_count ()) som pool:
# Apply_Async Returnerar ett Asyncresult -objekt
async_results =[pool.apply_async (process_item, (artikel,)) för objekt i data]
# Få resultaten (blockering tills alla processer är kompletta)
för async_result i async_results:
resultat.append (async_result.get ())
utskrift (resultat)
`` `
`Apply_Async` låter dig skicka uppgifter individuellt och hämta resultat senare. Detta är användbart om behandlingstiden för varje objekt varierar betydligt.
Viktiga överväganden:
* `om __Name__ =='__main __':`: Detta är avgörande, särskilt på Windows, för att förhindra rekursiv processskapande.
* Datadelning: Undvik att dela muterbara data direkt mellan processer. Använd tekniker som köer eller rör för kommunikation mellan processer för att förhindra rasförhållanden.
* overhead: Att skapa och hantera processer har omkostnader. Parallell bearbetning är mest fördelaktigt för beräkningsintensiva uppgifter där behandlingstiden avsevärt överväger omkostnaden.
* Antal processer: Det optimala antalet processer är ofta lika med antalet CPU -kärnor, men experiment kan behövas.
Kom ihåg att ersätta `# ... din kod ...` med din faktiska beräkning. Välj den metod som bäst passar strukturen och komplexiteten i din "för" loops verksamhet. För enkla, parallellvänliga operationer är "Pool.map" vanligtvis det föredragna och mest effektiva tillvägagångssättet.
