Vad är Python-multiprocessing och hur använder man det?
Python multiprocessing låter dig dela upp arbetsbelastningen mellan flera processer, vilket minskar den totala exekveringstiden. Detta är särskilt användbart för att göra tunga beräkningar eller hantera stora datamängder.
Vad är Python-multiprocessing?
Multiprocessing i Python innebär att flera processer körs samtidigt, vilket gör att du kan utnyttja multicore-system maximalt. Till skillnad från enkelsträngade metoder som hanterar uppgifter en efter en, låter multiprocessing olika delar av programmet köras parallellt, var och en för sig. Varje process får sitt eget minnesutrymme och kan köras på separata processorkärnor, vilket minskar exekveringstiden för tunga eller tidskänsliga operationer.
Python-multiprocessing har ett brett spektrum av tillämpningar. Multiprocessing används ofta inom databehandling och analys för att bearbeta stora datamängder snabbare och påskynda komplexa analyser. Multiprocessing kan också användas i simuleringar och modellberäkningar (t.ex. i vetenskapliga tillämpningar) för att förkorta exekveringstiderna för komplexa beräkningar. Förutom att driva webbskrapning genom att hämta data från flera webbplatser samtidigt, ökar det också effektiviteten i bildbehandling och datorseende, vilket resulterar i snabbare bildanalys.
Hur man implementerar Python-multiprocessing
Python erbjuder olika alternativ för att implementera multiprocessing. I följande avsnitt presenterar vi tre vanliga verktyg: modulen multiprocessing, biblioteket concurrent.futures och paketet joblib.
multiprocessing moduler
Modul multiprocessing är standardmodulen för multiprocessing i Python. Med denna modul kan du skapa processer, dela data mellan dem och synkronisera dem med hjälp av lås, köer och andra verktyg.
import multiprocessing
def task(n):
result = n * n
print(f"Result: {result}")
if __name__ == "__main__":
processes = []
for i in range(1, 6):
process = multiprocessing.Process(target=task, args=(i,))
processes.append(process)
process.start()
for process in processes:
process.join()I exemplet ovan använder vi klassen multiprocessing.Process för att skapa och köra processer som exekverar funktionen task(), som beräknar kvadraten på ett givet tal. Efter att ha initialiserat processerna väntar vi på att de ska slutföras innan vi fortsätter med huvudprogrammet. Resultatet visas med hjälp av en f-sträng, en Python-strängformatmetod som innehåller uttryck. Det är värt att notera att utdatasekvensen är slumpmässig och icke-deterministisk. Du kan också skapa en processpool med Python multiprocessing:
import multiprocessing
def task(n):
return n * n
if __name__ == "__main__":
with multiprocessing.Pool() as pool:
results = pool.map(task, range(1, 6))
print(results) # Output: [1, 4, 9, 16, 25]Med pool.map() tillämpas funktionen task() på en sekvens av data, och resultaten samlas in och matas ut.
concurrent.futures bibliotek
Denna modul tillhandahåller ett högnivågränssnitt för asynkron exekvering och parallell bearbetning av processer. Den använder Pool Executor för att exekvera uppgifter på en pool av processer eller trådar. Modulen concurrent.futures är ett enklare sätt att bearbeta asynkrona uppgifter och är i många fall lättare att hantera än Python-modulen multiprocessing.
import concurrent.futures
def task(n):
return n * n
with concurrent.futures.ProcessPoolExecutor() as executor:
futures = [executor.submit(task, i) for i in range(1, 6)]
for future in concurrent.futures.as_completed(futures):
print(future.result()) # result in random orderKoden använder concurrent.futures module för att bearbeta uppgifter parallellt med ProcessPoolExecutor. Funktionen task(n) skickas för siffrorna 1 till 5. Metoden as_completed() väntar på att uppgifterna ska slutföras och visar resultaten i valfri ordning.
joblib paket
joblib är ett externt Python-bibliotek som är utformat för att förenkla parallellbearbetning i Python, till exempel för repeterbara uppgifter som att exekvera funktioner med olika inparametrar eller arbeta med stora datamängder. De viktigaste funktionerna i joblib är parallellisering av uppgifter, cachelagring av funktionsresultat och optimering av minnes- och beräkningsresurser.
from joblib import Parallel, delayed
def task(n):
return n * n
results = Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11))
print(results) # Output: Results of the function for numbers from 1 to 10Uttrycket Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11)) initierar parallellkörning av funktionen task() för siffrorna 1 till 10. Parallel är konfigurerat med n_jobs=4, vilket innebär att upp till fyra parallella jobb kan bearbetas. Anropet delayed(task)(i) skapar uppgiften som ska köras parallellt för varje siffra i i intervallet 1 till 10. Detta innebär att funktionen task() anropas samtidigt för var och en av dessa siffror. Resultaten för siffrorna 1 till 10 lagras i results och matas ut.