Python multiprocessing lar deg dele arbeidsbelastningen mellom flere prosesser, noe som reduserer den totale kjøretiden. Dette er spesielt nyttig for å utføre tunge beregninger eller håndtere store datasett.

Hva er Python-multiprosessering?

Multiprocessing i Python refererer til å kjøre flere prosesser samtidig, slik at du kan utnytte flerkjernersystemer optimalt. I motsetning til enkeltrådede metoder som håndterer oppgaver én etter én, lar multiprocessing ulike deler av programmet kjøre parallelt, hver for seg. Hver prosess får sitt eget minneområde og kan kjøre på separate prosessorkjerner, noe som reduserer kjøretiden for krevende eller tidssensitive operasjoner.

Python-multiprocessing har et bredt spekter av bruksområder. Multiprocessing brukes ofte i databehandling og analyse for å behandle store datasett raskere og for å akselerere komplekse analyser. Multiprocessing kan også brukes i simuleringer og modellberegninger (f.eks. i vitenskapelige applikasjoner) for å forkorte kjøretiden for komplekse beregninger. I tillegg til å drive webscraping ved å hente data fra flere nettsteder samtidig, øker det også effektiviteten i bildebehandling og datasyn, noe som resulterer i raskere bildeanalyse.

Hvordan implementere Python-multiprosessering

Python tilbyr ulike alternativer for implementering av flerprosessering. I de følgende avsnittene vil vi introdusere deg for tre vanlige verktøy: multiprocessing, concurrent.futures og joblib -pakken.

multiprocessing moduler

Modul multiprocessing er standardmodulen for Python-multiprosessering. Med denne modulen kan du opprette prosesser, dele data mellom dem og synkronisere dem ved hjelp av låser, køer og andre verktøy.

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()
python

I eksemplet ovenfor bruker vi klassen multiprocessing.Process til å starte og kjøre prosesser som utfører funksjonen task(), som beregner kvadratet av et gitt tall. Etter å ha initialisert prosessene, venter vi på at de skal fullføres før vi fortsetter med hovedprogrammet. Resultatet vises ved hjelp av en f-streng, en Python-strengformatmetode som inneholder uttrykk. Det er verdt å merke seg at rekkefølgen på utdataene er tilfeldig og ikke-deterministisk. Du kan også opprette en prosesspool 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]
python

Med pool.map() blir funksjonen task() brukt på en sekvens av data, og resultatene blir samlet og sendt ut.

concurrent.futures bibliotek

Denne modulen gir et høynivågrensesnitt for asynkron utførelse og parallell behandling av prosesser. Den bruker Pool Executor til å utføre oppgaver på en pool av prosesser eller tråder. Modulen concurrent.futures er en enklere måte å behandle asynkrone oppgaver på, og er i mange tilfeller enklere å håndtere enn 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 order
python

Koden bruker concurrent.futures module til å behandle oppgaver parallelt med ProcessPoolExecutor. Funksjonen task(n) overføres for tall fra 1 til 5. Metoden as_completed() venter på at oppgavene skal fullføres og viser resultatene i vilkårlig rekkefølge.

joblib pakke

joblib er et eksternt Python-bibliotek utviklet for å forenkle parallellbehandling i Python, for eksempel for repeterbare oppgaver som å utføre funksjoner med forskjellige inndataparametere eller arbeide med store datamengder. Hovedfunksjonene til joblib er parallellisering av oppgaver, caching av funksjonsresultater og optimalisering av minne- og databehandlingsressurser.

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 10
python

Uttrykket Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11)) starter parallell kjøring av funksjonen task() for tallene fra 1 til 10. Parallel er konfigurert med n_jobs=4, noe som betyr at opptil fire parallelle jobber kan behandles. Oppkallingen delayed(task)(i) oppretter oppgaven som skal kjøres parallelt for hvert tall i i området fra 1 til 10. Dette betyr at funksjonen task() kalles samtidig for hvert av disse tallene. Resultatene for tallene 1 til 10 lagres i results og sendes ut.

Go to Main Menu