Hvad er Python-mul­ti­pro­ces­sing, og hvordan bruges det?

Python mul­ti­pro­ces­sing giver dig mulighed for at fordele ar­bejds­byr­den på flere processer, hvilket reducerer den samlede ek­se­kve­rings­tid. Dette er især nyttigt til at udføre tunge be­reg­nin­ger eller håndtere store datasæt.

Hvad er Python-mul­ti­pro­ces­sing?

Mul­ti­pro­ces­sing i Python refererer til at køre flere processer samtidigt, hvilket giver dig mulighed for at få mest muligt ud af multicore-systemer. I mod­sæt­ning til single-threaded metoder, der håndterer opgaver én efter én, lader mul­ti­pro­ces­sing for­skel­li­ge dele af pro­gram­met køre parallelt, hver for sig. Hver proces får sit eget hukom­mel­ses­rum og kan køre på separate pro­ces­sor­ker­ner, hvilket reducerer ek­se­kve­ring­sti­den for tunge eller tids­kri­ti­ske ope­ra­tio­ner.

Python-mul­ti­pro­ces­sing har en bred vifte af an­ven­del­ses­mu­lig­he­der. Mul­ti­pro­ces­sing bruges ofte i da­ta­be­hand­ling og analyse til at behandle store datasæt hurtigere og til at frem­skyn­de komplekse analyser. Mul­ti­pro­ces­sing kan også bruges i si­mu­le­rin­ger og mo­del­le­rings­be­reg­nin­ger (f.eks. i vi­den­ska­be­li­ge ap­pli­ka­tio­ner) for at forkorte ud­fø­rel­ses­ti­den for komplekse be­reg­nin­ger. Ud over at un­der­støt­te webs­cra­ping ved at hente data fra flere websteder samtidigt, øger det også ef­fek­ti­vi­te­ten i bil­led­be­hand­ling og com­pu­ter­vi­sion, hvilket re­sul­te­rer i hurtigere bil­le­d­a­na­ly­se.

Sådan im­ple­men­te­res Python-mul­ti­pro­ces­sing

Python tilbyder for­skel­li­ge mu­lig­he­der for im­ple­men­te­ring af mul­ti­pro­ces­sing. I de følgende afsnit vil vi in­tro­du­ce­re dig til tre al­min­de­li­ge værktøjer: multiprocessing modulet, concurrent.futures -bi­bli­o­te­ket og joblib -pakken.

multiprocessing modul

Modulet multiprocessing er stan­dard­mo­du­let til mul­ti­pro­ces­sing i Python. Med dette modul kan du oprette processer, dele data mellem dem og syn­kro­ni­se­re dem ved hjælp af låse, køer og andre værktøjer.

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 eksemplet ovenfor bruger vi klassen multiprocessing.Process til at generere og køre processer, der udfører funk­tio­nen task(), som beregner kvadratet af et givet tal. Efter ini­ti­a­li­se­ring af pro­ces­ser­ne venter vi på, at de er færdige, før vi fort­sæt­ter med ho­ved­pro­gram­met. Re­sul­ta­tet vises ved hjælp af en f-streng, en Python-streng­for­mat­me­to­de, der in­korpo­re­rer udtryk. Det er værd at bemærke, at ræk­ke­føl­gen af output er tilfældig og ikke-de­ter­mi­ni­stisk. Du kan også oprette en pro­ces­pul­je 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() anvendes funk­tio­nen task() på en da­ta­sequen­ce, og re­sul­ta­ter­ne indsamles og udlæses.

concurrent.futures bibliotek

Dette modul giver en højniveau-græn­se­fla­de til asynkron udførelse og parallel be­hand­ling af processer. Det bruger Pool Executor til at udføre opgaver på en pulje af processer eller tråde. Modulet concurrent.futures er en enklere måde at behandle asynkrone opgaver på og er i mange tilfælde nemmere at håndtere end multiprocessing -modulet.

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

Koden bruger concurrent.futures module til at behandle opgaver parallelt med ProcessPoolExecutor. Funk­tio­nen task(n) overføres for tal fra 1 til 5. Metoden as_completed() venter på, at opgaverne bliver afsluttet, og udskriver re­sul­ta­ter­ne i vilkårlig ræk­ke­føl­ge.

joblib pakke

joblib er et eksternt Python-bibliotek, der er designet til at forenkle parallel be­hand­ling i Python, for eksempel til gentagne opgaver såsom udførelse af funk­tio­ner med for­skel­li­ge in­put­pa­ra­me­tre eller arbejde med store da­ta­mæng­der. De vigtigste funk­tio­ner i joblib er pa­ral­le­li­se­ring af opgaver, caching af funk­tions­re­sul­ta­ter og op­ti­me­ring af hukom­mel­se og be­reg­nings­res­sour­cer.

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

Udtrykket Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11)) initierer parallel udførelse af funk­tio­nen task() for tallene fra 1 til 10. Parallel er kon­fi­gu­re­ret med n_jobs=4, hvilket betyder, at op til fire pa­ral­lel­le jobs kan behandles. Opkald til delayed(task)(i) opretter den opgave, der skal udføres parallelt for hvert tal i i in­ter­val­let fra 1 til 10. Dette betyder, at funk­tio­nen task() kaldes samtidigt for hvert af disse tal. Re­sul­ta­ter­ne for tallene 1 til 10 gemmes i results og udlæses.