# Kas yra Python daugiaprocesinis apdorojimas ir kaip jį naudoti

Python daugiaprocesinis apdorojimas leidžia paskirstyti **darbo krūvį tarp kelių procesų**, taip sutrumpinant bendrą vykdymo laiką. Tai ypač naudinga atliekant sudėtingus skaičiavimus ar tvarkant didelius duomenų rinkinius.

## Kas yra Python daugiaprocesinis apdorojimas?

Daugiaprocesinis apdorojimas Python kalboje reiškia kelių procesų vykdymą vienu metu, leidžiantį maksimaliai išnaudoti **daugiabrandžių sistemų** galimybes. Skirtingai nuo vienos sriegės metodų, kurie užduotis atlieka po vieną, daugiaprocesinis apdorojimas leidžia įvairioms programos dalims veikti lygiagrečiai, kiekvienai atskirai. Kiekvienas procesas gauna savo atminties erdvę ir gali veikti atskiruose procesoriaus branduoliuose, taip sutrumpindamas sudėtingų ar laiko atžvilgiu jautrių operacijų vykdymo laiką.

Python daugiaprocesinis apdorojimas turi platų taikymo spektrą. Daugiaprocesinis apdorojimas dažnai naudojamas duomenų apdorojimui ir analizei, siekiant greičiau apdoroti didelius duomenų rinkinius ir pagreitinti sudėtingas analizes. Daugiaprocesinis apdorojimas taip pat gali būti naudojamas **simuliacijose ir modeliavimo skaičiavimuose** (pvz., mokslo srityje), siekiant sutrumpinti sudėtingų skaičiavimų vykdymo laiką. Be to, kad jis padeda atlikti žiniatinklio duomenų rinkimą, vienu metu gaunant duomenis iš kelių svetainių, jis taip pat padidina vaizdų apdorojimo ir kompiuterinio matymo efektyvumą, todėl vaizdų analizė atliekama greičiau.

## Kaip įgyvendinti Python daugiaprocesinį apdorojimą

Python siūlo įvairias daugiaprocesinio apdorojimo įgyvendinimo galimybes. Toliau pateiksime tris dažniausiai naudojamas priemones: `multiprocessing` modulį, `concurrent.futures` biblioteką ir `joblib` paketą.

### `multiprocessing` modulis

`multiprocessing` modulis yra **standartinis Python daugiaprocesinio apdorojimo modulis**. Naudodami šį modulį, galite kurti procesus, dalytis duomenimis tarp jų ir sinchronizuoti juos naudodami užraktus, eiles ir kitas priemones.

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

Pateiktame pavyzdyje naudojame `multiprocessing.Process` klasę, kad sukurtume ir paleistume procesus, vykdančius `task()` funkciją, kuri apskaičiuoja duoto skaičiaus kvadratą. Inicijavę procesus, palaukiame, kol jie bus užbaigti, ir tik tada tęsiame pagrindinę programą. Rezultatas rodomas naudojant **f-string**, Python stygos formato metodą, kuris įtraukia išraiškas. Verta paminėti, kad išvesties seka yra atsitiktinė ir nedeterministinė. Taip pat galite sukurti procesų grupę su 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]
```

Su `pool.map()` funkcija `task()` taikoma duomenų sekai, o rezultatai surenkami ir išvedami.

### `concurrent.futures` biblioteka

Šis modulis teikia aukšto lygio sąsają asinchroniniam procesų vykdymui ir lygiagrečiam apdorojimui. Jis naudoja **„Pool Executor“** užduočių vykdymui procesų ar siūlų grupėje. `concurrent.futures` modulis yra paprastesnis būdas apdoroti asinchronines užduotis ir daugeliu atvejų yra lengviau valdomas nei 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
```

Kodas naudoja `concurrent.futures module`, kad užduotis būtų apdorojamos lygiagrečiai su `ProcessPoolExecutor`. Funkcija `task(n)` perduodama skaičiams nuo 1 iki 5. `as_completed()` metodas laukia, kol užduotys bus užbaigtos, ir pateikia **rezultatus bet kokia tvarka**.

### `joblib` paketas

`joblib` yra išorinė Python biblioteka, sukurta siekiant supaprastinti lygiagretų apdorojimą Python kalboje, pavyzdžiui, kartojamoms užduotims, tokioms kaip funkcijų su skirtingais įvesties parametrais vykdymas arba darbas su dideliais duomenų kiekiais. Pagrindinės `joblib` funkcijos yra užduočių lygiagretinimas, **funkcijų rezultatų talpinimas į talpyklą** ir atminties bei skaičiavimo išteklių optimizavimas.

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

Išraiška `Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11))` inicijuoja funkcijos `task()` lygiagretų vykdymą skaičiams nuo 1 iki 10. `Parallel` yra sukonfigūruotas su `n_jobs=4`, o tai reiškia, kad gali būti apdorojami iki keturių lygiagrečių užduočių. Iššaukiant `delayed(task)(i)` sukuriama užduotis, kuri turi būti vykdoma lygiagrečiai kiekvienam skaičiui i intervale nuo 1 iki 10. Tai reiškia, kad funkcija `task()` yra iššaukiama vienu metu kiekvienam iš šių skaičių. Rezultatai skaičiams nuo 1 iki 10 yra saugomi `results` ir išvedami.


This is a markdown version of: [https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/python-daugiaprocesinis-apdorojimas/](https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/python-daugiaprocesinis-apdorojimas/) for AI/LLM consumption.