# Hvad er Python-multiprocessing, og hvordan bruges det?

Python multiprocessing giver dig mulighed for at fordele **arbejdsbyrden på flere processer**, hvilket reducerer den samlede eksekveringstid. Dette er især nyttigt til at udføre tunge beregninger eller håndtere store datasæt.

## Hvad er Python-multiprocessing?

Multiprocessing i Python refererer til at køre flere processer samtidigt, hvilket giver dig mulighed for at få mest muligt ud af **multicore-systemer**. I modsætning til single-threaded metoder, der håndterer opgaver én efter én, lader multiprocessing forskellige dele af programmet køre parallelt, hver for sig. Hver proces får sit eget hukommelsesrum og kan køre på separate processorkerner, hvilket reducerer eksekveringstiden for tunge eller tidskritiske operationer.

Python-multiprocessing har en bred vifte af anvendelsesmuligheder. Multiprocessing bruges ofte i databehandling og analyse til at behandle store datasæt hurtigere og til at fremskynde komplekse analyser. Multiprocessing kan også bruges i **simuleringer og modelleringsberegninger** (f.eks. i videnskabelige applikationer) for at forkorte udførelsestiden for komplekse beregninger. Ud over at understøtte webscraping ved at hente data fra flere websteder samtidigt, øger det også effektiviteten i billedbehandling og computervision, hvilket resulterer i hurtigere billedanalyse.

## Sådan implementeres Python-multiprocessing

Python tilbyder forskellige muligheder for implementering af multiprocessing. I de følgende afsnit vil vi introducere dig til tre almindelige værktøjer: `multiprocessing` modulet, `concurrent.futures` -biblioteket og `joblib` -pakken.

### `multiprocessing` modul

Modulet `multiprocessing` er **standardmodulet til multiprocessing i Python**. Med dette modul kan du oprette processer, dele data mellem dem og synkronisere dem ved hjælp af låse, køer og andre værktøjer.

```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 bruger vi klassen `multiprocessing.Process` til at generere og køre processer, der udfører funktionen `task()`, som beregner kvadratet af et givet tal. Efter initialisering af processerne venter vi på, at de er færdige, før vi fortsætter med hovedprogrammet. Resultatet vises ved hjælp af en **f-streng**, en Python-strengformatmetode, der inkorporerer udtryk. Det er værd at bemærke, at rækkefølgen af output er tilfældig og ikke-deterministisk. Du kan også oprette en procespulje 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()` anvendes funktionen `task()` på en datasequence, og resultaterne indsamles og udlæses.

### `concurrent.futures` bibliotek

Dette modul giver en højniveau-grænseflade til asynkron udførelse og parallel behandling 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.

```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 bruger `concurrent.futures module` til at behandle opgaver parallelt med `ProcessPoolExecutor`. Funktionen `task(n)` overføres for tal fra 1 til 5. Metoden `as_completed()` venter på, at opgaverne bliver afsluttet, og udskriver **resultaterne i vilkårlig rækkefølge**.

### `joblib` pakke

`joblib` er et eksternt Python-bibliotek, der er designet til at forenkle parallel behandling i Python, for eksempel til gentagne opgaver såsom udførelse af funktioner med forskellige inputparametre eller arbejde med store datamængder. De vigtigste funktioner i `joblib` er parallelisering af opgaver, **caching af funktionsresultater** og optimering af hukommelse og beregningsressourcer.

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

Udtrykket `Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11))` initierer parallel udførelse af funktionen `task()` for tallene fra 1 til 10. `Parallel` er konfigureret med `n_jobs=4`, hvilket betyder, at op til fire parallelle jobs kan behandles. Opkald til `delayed(task)(i)` opretter den opgave, der skal udføres parallelt for hvert tal i i intervallet fra 1 til 10. Dette betyder, at funktionen `task()` kaldes samtidigt for hvert af disse tal. Resultaterne for tallene 1 til 10 gemmes i `results` og udlæses.


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-multiprocessing/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/python-multiprocessing/) for AI/LLM consumption.