Več­pro­ce­sno delovanje v Pythonu omogoča raz­de­li­tev delovne obre­me­ni­tve med več procesov, kar skrajša skupni čas izvedbe. To je še posebej koristno pri zahtevnih izračunih ali obdelavi velikih po­dat­kov­nih nizov.

Kaj je več­pro­ce­sno delovanje v Pythonu?

Več­pro­ce­sno ob­de­lo­va­nje v Pythonu se nanaša na hkratno izvajanje več procesov, kar vam omogoča, da iz­ko­ri­sti­te večjedrne sisteme. Za razliko od enonitnih metod, ki opra­vlja­jo naloge eno po eno, več­pro­ce­sno ob­de­lo­va­nje omogoča, da različne dele programa izvajate vzporedno, vsak zase. Vsak proces dobi svoj po­mnil­ni­ški prostor in lahko teče na ločenih pro­ce­sor­skih jedrih, kar skrajša čas izvajanja za zahtevne ali časovno ob­ču­tlji­ve operacije.

Več­pro­ce­sno ob­de­lo­va­nje v Pythonu ima široko paleto uporab. Več­pro­ce­sno ob­de­lo­va­nje se pogosto uporablja pri obdelavi in analizi podatkov, da se hitreje ob­de­lu­je­jo veliki nizi podatkov in pospešijo zapletene analize. Več­pro­ce­si­ra­nje se lahko uporablja tudi v si­mu­la­ci­jah in mo­de­li­ra­nju izračunov (npr. v znan­stve­nih apli­ka­ci­jah) za skraj­ša­nje iz­ved­be­nih časov kom­ple­ksnih izračunov. Poleg podpore spletnemu iz­pi­so­va­nju podatkov s hkratnim pri­do­bi­va­njem podatkov z več spletnih strani, poveča tudi učin­ko­vi­tost pri obdelavi slik in ra­ču­nal­ni­škem vidu, kar omogoča hitrejšo analizo slik.

Kako im­ple­men­ti­ra­ti več­pro­ce­sno obdelavo v Pythonu

Python ponuja različne možnosti za izvajanje več­pro­ce­sne­ga ob­de­lo­va­nja. V na­sle­dnjih poglavjih vam bomo pred­sta­vi­li tri pogosta orodja: modul multiprocessing, knjižnico concurrent.futures in paket joblib.

multiprocessing modulov

Modul multiprocessing je stan­dar­dni modul za več­pro­ce­sno obdelavo v Pythonu. S tem modulom lahko ustvar­ja­te procese, med njimi iz­me­nju­je­te podatke in jih sin­hro­ni­zi­ra­te z uporabo zaklepov, čakalnih vrst in drugih orodij.

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

V zgornjem primeru uporabimo razred multiprocessing.Process za ustvar­ja­nje in izvajanje procesov, ki izvajajo funkcijo task(), ki izračuna kvadrat danega števila. Po ini­ci­a­li­za­ci­ji procesov počakamo, da se za­klju­či­jo, preden na­da­lju­je­mo 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 ne­de­ter­mi­ni­stič­no. Z Python multiprocessing lahko ustvarite tudi zbirko procesov:

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

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

concurrent.futures knjižnica

Ta modul za­go­ta­vlja 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 eno­stav­nej­ši način za obdelavo asin­hro­nih nalog in je v mnogih primerih lažji za uporabo kot modul Python multiprocessing.

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
python

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 za­klju­či­jo, in izpiše rezultate v poljubnem vrstnem redu.

joblib paket

joblib je zunanja knjižnica Python, zasnovana za po­e­no­sta­vi­tev vzpo­re­dne­ga ob­de­lo­va­nja v Pythonu, na primer za po­na­vlja­jo­če se naloge, kot so izvajanje funkcij z raz­lič­ni­mi vhodnimi parametri ali delo z velikimi ko­li­či­na­mi podatkov. Glavne funkcije joblib so vzporedno izvajanje nalog, shra­nje­va­nje re­zul­ta­tov funkcij v pred­po­mnil­ni­ku in op­ti­mi­za­ci­ja po­mnil­ni­ka in ra­ču­nal­ni­ških virov.

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
python

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 kon­fi­gu­ri­ran 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.

Go to Main Menu