# Mis on Python multiprocessing ja kuidas seda kasutada?

Pythoni mitmeprotsessiline töötlemine võimaldab jagada **töökoormuse mitme protsessi vahel**, vähendades sellega üldist täitmisaega. See on eriti kasulik keeruliste arvutuste tegemisel või suurte andmekogumite töötlemisel.

## Mis on Python multiprocessing?

Mitmeprotsessiline töötlemine Pythonis tähendab mitme protsessi samaaegset käivitamist, mis võimaldab **mitmetuumalisi süsteeme** maksimaalselt ära kasutada. Erinevalt üheprotsessilistest meetoditest, mis töötlevad ülesandeid ükshaaval, võimaldab mitmeprotsessiline töötlemine programmi erinevaid osi paralleelselt käivitada, igaüht eraldi. Iga protsess saab oma mäluruumi ja võib töötada eraldi protsessorituumadel, mis vähendab oluliselt raske või ajakriitiliste operatsioonide täitmise aega.

Python multiprocessingul on lai rakendusvaldkond. Multiprocessingut kasutatakse sageli andmete töötlemisel ja analüüsimisel, et töödelda suuri andmekogumeid kiiremini ja kiirendada keerukaid analüüse. Multiprotsessimist saab kasutada ka **simulatsioonides ja modelleerimise arvutustes** (nt teaduslikes rakendustes), et lühendada keeruliste arvutuste täitmise aega. Lisaks veebikogumise võimsuse suurendamisele, hankides andmeid mitmest saidist korraga, suurendab see ka pilditöötluse ja arvutinägemise efektiivsust, mis kiirendab pildianalüüsi.

## Kuidas rakendada Python multiprocessingut

Python pakub mitmeid võimalusi mitmeprotsessilise töötlemise rakendamiseks. Järgmistes jaotistes tutvustame teile kolme levinud vahendit: moodulit `multiprocessing`, raamatukogu `concurrent.futures` ja paketti `joblib`.

### `multiprocessing` moodul

`multiprocessing` moodul on **Python multiprocessingu standardmoodul**. Selle mooduli abil saate luua protsesse, jagada nende vahel andmeid ja neid lukkude, järjekordade ja muude vahendite abil sünkroniseerida.

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

Eespool toodud näites kasutame klassi `multiprocessing.Process` protsesside loomiseks ja käivitamiseks, mis täidavad funktsiooni `task()`, mis arvutab antud arvu ruudu. Pärast protsesside algatamist ootame, kuni need lõpetavad töö, enne kui jätkame põhiprogrammiga. Tulemus kuvatakse **f-stringi** abil, mis on Pythonis kasutatav stringi vormingumeetod, mis sisaldab väljendeid. Tuleb märkida, et väljundi järjekord on juhuslik ja mittedeterministlik. `multiprocessing` 11-ga saab luua ka protsesside kogu:

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

Funktsioon `task()` rakendatakse `pool.map()` andmete jada suhtes ning tulemused kogutakse ja väljastatakse.

### `concurrent.futures` raamatukogu

See moodul pakub kõrgetasemelist liidest protsesside asünkroonseks täitmiseks ja paralleelseks töötlemiseks. See kasutab **Pool Executorit** ülesannete täitmiseks protsesside või niitide kogumis. Moodul `concurrent.futures` on lihtsam viis asünkroonsete ülesannete töötlemiseks ja on paljudel juhtudel lihtsam käsitseda kui moodul Python `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
```

Kood kasutab `concurrent.futures module`, et töödelda ülesandeid paralleelselt `ProcessPoolExecutor`. Funktsioon `task(n)` edastatakse numbritele 1 kuni 5. Meetod `as_completed()` ootab ülesannete lõpetamist ja väljastab **tulemused mis tahes järjekorras**.

### `joblib` pakett

`joblib` on väliseks Python-teegiks, mis on loodud Pythonis paralleelse töötlemise lihtsustamiseks, näiteks korduvate ülesannete jaoks, nagu erinevate sisendparameetritega funktsioonide täitmine või suurte andmehulkade töötlemine. `joblib` peamised funktsioonid on ülesannete paralleelsus, **funktsioonide tulemuste vahemällu salvestamine** ning mälu ja arvutusressursside optimeerimine.

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

Väljend `Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11))` käivitab funktsiooni `task()` paralleelse täitmise numbritele 1 kuni 10. `Parallel` on konfigureeritud koos `n_jobs=4`, mis tähendab, et tööd saab töödelda kuni neljas paralleelses režiimis. Kõne `delayed(task)(i)` loob ülesande, mis tuleb täita paralleelselt iga numbri i jaoks vahemikus 1 kuni 10. See tähendab, et funktsiooni `task()` kutsutakse samaaegselt igaühe jaoks neist numbritest. Numbritele 1 kuni 10 vastavad tulemused salvestatakse `results` ja väljastatakse.


This is a markdown version of: [https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/pythoni-mitmeprotsessiline-toeoetlemine/](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/pythoni-mitmeprotsessiline-toeoetlemine/) for AI/LLM consumption.