# Hva er Python-multiprosessering og hvordan bruker man det?

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.

```python
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 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`:

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

```python
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 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.

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

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.


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/python-multiprosessering/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/python-multiprosessering/) for AI/LLM consumption.