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.
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:
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.
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 orderKood 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.
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 10Vä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.