# Kas ir Python multiprocessing un kā to lietot

Python multiprocessing ļauj sadalīt **darba slodzi starp vairākiem procesiem**, samazinot kopējo izpildes laiku. Tas ir īpaši noderīgi, veicot apjomīgus aprēķinus vai apstrādājot lielus datu kopumus.

## Kas ir Python daudzprocesu apstrāde?

Daudzprocesu apstrāde Python valodā nozīmē vairāku procesu vienlaicīgu izpildi, kas ļauj maksimāli izmantot **daudzkodolu sistēmu** iespējas. Atšķirībā no vienkodolu metodēm, kas apstrādā uzdevumus vienu pēc otra, daudzprocesu apstrāde ļauj programmas dažādām daļām darboties paralēli, katrai atsevišķi. Katram procesam ir sava atmiņas telpa, un tas var darboties atsevišķos procesoru kodolos, ievērojami samazinot smagu vai laika ziņā jutīgu operāciju izpildes laiku.

Python multiprocessing ir plašs pielietojumu klāsts. Multiprocessing bieži tiek izmantots datu apstrādē un analīzē, lai ātrāk apstrādātu lielus datu kopumus un paātrinātu sarežģītas analīzes. Daudzprocesu apstrāde var tikt izmantota arī **simulācijās un modelēšanas aprēķinos** (piemēram, zinātniskās lietojumprogrammās), lai saīsinātu sarežģītu aprēķinu izpildes laiku. Papildus tīmekļa satura ieguvei, vienlaikus iegūstot datus no vairākām vietnēm, tā arī palielina efektivitāti attēlu apstrādē un datorredzēšanā, rezultātā paātrinot attēlu analīzi.

## Kā īstenot Python daudzprocesu apstrādi

Python piedāvā dažādas iespējas daudzprocesu apstrādes īstenošanai. Turpmākajās sadaļās iepazīstināsim jūs ar trim izplatītākajiem rīkiem: `multiprocessing` moduli, `concurrent.futures` bibliotēku un `joblib` paketi.

### `multiprocessing` modulis

`multiprocessing` modulis ir **standarta modulis Python daudzprocesu apstrādei**. Ar šo moduli varat izveidot procesus, dalīties ar datiem starp tiem un sinhronizēt tos, izmantojot bloķējumus, rindas un citus rīkus.

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

Iepriekš minētajā piemērā mēs izmantojam `multiprocessing.Process` klasi, lai radītu un palaistu procesus, kas izpilda `task()` funkciju, kura aprēķina dotā skaitļa kvadrātu. Pēc procesu inicializēšanas mēs gaidām, līdz tie tiek pabeigti, pirms turpinām galveno programmu. Rezultāts tiek parādīts, izmantojot **f-string**, Python string formāta metodi, kas ietver izteiksmes. Ir vērts atzīmēt, ka izvades secība ir nejauša un nedeterministiska. Ar Python `multiprocessing` varat arī izveidot procesu kopu:

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

Ar `pool.map()` funkcija `task()` tiek piemērota datu secībai, un rezultāti tiek apkopoti un izvadīti.

### `concurrent.futures` bibliotēka

Šis modulis nodrošina augsta līmeņa saskarni asinhronai izpildei un paralēlai procesu apstrādei. Tas izmanto **Pool Executor**, lai izpildītu uzdevumus procesu vai pavedienu kopumā. `concurrent.futures` modulis ir vienkāršāks veids, kā apstrādāt asinhronus uzdevumus, un daudzos gadījumos tas ir vieglāk lietojams nekā Python `multiprocessing` modulis.

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

Kods izmanto `concurrent.futures module`, lai apstrādātu uzdevumus paralēli ar `ProcessPoolExecutor`. Funkcija `task(n)` tiek nodota skaitļiem no 1 līdz 5. Metode `as_completed()` gaida, līdz uzdevumi tiek pabeigti, un izvada **rezultātus jebkurā secībā**.

### `joblib` pakete

`joblib` ir ārēja Python bibliotēka, kas izstrādāta, lai vienkāršotu paralēlo apstrādi Python, piemēram, atkārtojamiem uzdevumiem, tādiem kā funkciju izpilde ar dažādiem ievades parametriem vai darbs ar lieliem datu apjomiem. `joblib` galvenās funkcijas ir uzdevumu paralēlizācija, **funkciju rezultātu kešēšana** un atmiņas un skaitļošanas resursu optimizācija.

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

Izteiksme `Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11))` iniciē funkcijas `task()` paralēlu izpildi skaitļiem no 1 līdz 10. `Parallel` ir konfigurēts ar `n_jobs=4`, kas nozīmē, ka var apstrādāt līdz četriem paralēliem uzdevumiem. Izsaukums `delayed(task)(i)` izveido uzdevumu, kas jāizpilda paralēli katram skaitlim i diapazonā no 1 līdz 10. Tas nozīmē, ka funkcija `task()` tiek izsaukta vienlaikus katram no šiem skaitļiem. Rezultāti skaitļiem no 1 līdz 10 tiek saglabāti `results` un izvadīti.


This is a markdown version of: [https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/python-daudzprocesu-apstrade/](https://www.ionos.com/lv-lv/digitalguide/timekla-vietnes/timekla-izstrade/python-daudzprocesu-apstrade/) for AI/LLM consumption.