# Kaj je večprocesno delovanje v Pythonu in kako ga uporabljati

Večprocesno delovanje v Pythonu omogoča razdelitev **delovne obremenitve med več procesov**, kar skrajša skupni čas izvedbe. To je še posebej koristno pri zahtevnih izračunih ali obdelavi velikih podatkovnih nizov.

## Kaj je večprocesno delovanje v Pythonu?

Večprocesno obdelovanje v Pythonu se nanaša na hkratno izvajanje več procesov, kar vam omogoča, da izkoristite **večjedrne sisteme**. Za razliko od enonitnih metod, ki opravljajo naloge eno po eno, večprocesno obdelovanje omogoča, da različne dele programa izvajate vzporedno, vsak zase. Vsak proces dobi svoj pomnilniški prostor in lahko teče na ločenih procesorskih jedrih, kar skrajša čas izvajanja za zahtevne ali časovno občutljive operacije.

Večprocesno obdelovanje v Pythonu ima široko paleto uporab. Večprocesno obdelovanje se pogosto uporablja pri obdelavi in analizi podatkov, da se hitreje obdelujejo veliki nizi podatkov in pospešijo zapletene analize. Večprocesiranje se lahko uporablja tudi v **simulacijah in modeliranju izračunov** (npr. v znanstvenih aplikacijah) za skrajšanje izvedbenih časov kompleksnih izračunov. Poleg podpore spletnemu izpisovanju podatkov s hkratnim pridobivanjem podatkov z več spletnih strani, poveča tudi učinkovitost pri obdelavi slik in računalniškem vidu, kar omogoča hitrejšo analizo slik.

## Kako implementirati večprocesno obdelavo v Pythonu

Python ponuja različne možnosti za izvajanje večprocesnega obdelovanja. V naslednjih poglavjih vam bomo predstavili tri pogosta orodja: modul `multiprocessing`, knjižnico `concurrent.futures` in paket `joblib`.

### `multiprocessing` modulov

Modul `multiprocessing` je **standardni modul za večprocesno obdelavo v Pythonu**. S tem modulom lahko ustvarjate procese, med njimi izmenjujete podatke in jih sinhronizirate z uporabo zaklepov, čakalnih vrst in drugih orodij.

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

V zgornjem primeru uporabimo razred `multiprocessing.Process` za ustvarjanje in izvajanje procesov, ki izvajajo funkcijo `task()`, ki izračuna kvadrat danega števila. Po inicializaciji procesov počakamo, da se zaključijo, preden nadaljujemo z glavnim programom. Rezultat se prikaže z uporabo **f-niza**, metode formata niza v Pythonu, ki vključuje izraze. Treba je omeniti, da je zaporedje izhodnih podatkov naključno in nedeterministično. Z Python `multiprocessing` lahko ustvarite tudi zbirko procesov:

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

Pri `pool.map()` se funkcija `task()` uporabi na zaporedje podatkov, rezultati pa se zberejo in izpišejo.

### `concurrent.futures` knjižnica

Ta modul zagotavlja visoko ravni vmesnik za asinhrono izvajanje in vzporedno obdelavo procesov. Uporablja **Pool Executor** za izvajanje nalog na sklopu procesov ali niti. Modul `concurrent.futures` je enostavnejši način za obdelavo asinhronih nalog in je v mnogih primerih lažji za uporabo kot modul 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
```

Koda uporablja `concurrent.futures module` za vzporedno obdelavo nalog s `ProcessPoolExecutor`. Funkcija `task(n)` se prenese za številke od 1 do 5. Metoda `as_completed()` počaka, da se naloge zaključijo, in izpiše **rezultate v poljubnem vrstnem redu**.

### `joblib` paket

`joblib` je zunanja knjižnica Python, zasnovana za poenostavitev vzporednega obdelovanja v Pythonu, na primer za ponavljajoče se naloge, kot so izvajanje funkcij z različnimi vhodnimi parametri ali delo z velikimi količinami podatkov. Glavne funkcije `joblib` so vzporedno izvajanje nalog, **shranjevanje rezultatov funkcij v predpomnilniku** in optimizacija pomnilnika in računalniških virov.

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

Izraz `Parallel(n_jobs=4)(delayed(task)(i) for i in range(1, 11))` sproži vzporedno izvajanje funkcije `task()` za številke od 1 do 10. `Parallel` je konfiguriran z `n_jobs=4`, kar pomeni, da se lahko obdelajo do štiri vzporedna opravila. Klic `delayed(task)(i)` ustvari nalogo, ki se izvede vzporedno za vsako številko i v območju od 1 do 10. To pomeni, da se funkcija `task()` pokliče hkrati za vsako od teh številk. Rezultati za številke od 1 do 10 so shranjeni v `results` in izpisani.


This is a markdown version of: [https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/vecprocesno-delovanje-v-pythonu/](https://www.ionos.com/sl-si/digitalguide/spletne-strani/razvoj-spletnih-strani/vecprocesno-delovanje-v-pythonu/) for AI/LLM consumption.