Nalutas: multiprocessing na mapa

Ang multiprocessing ay isang tanyag na pamamaraan sa Python programming na nagbibigay-daan sa iyong magpatakbo ng maraming proseso nang sabay-sabay, kadalasang nagreresulta sa mga pagpapabuti ng pagganap at mas mahusay na paggamit ng mga mapagkukunan ng system. Ang artikulong ito ay sumisid sa paggamit ng multiprocessing library sa Python, partikular na nakatuon sa mapa function. Hinahayaan ka ng function ng mapa na maglapat ng function sa bawat item sa isang iterable, tulad ng isang listahan, at magbalik ng bagong listahan kasama ang mga resulta. Sa pamamagitan ng paggamit ng multiprocessing, maaari nating iparallelize ang prosesong ito para sa higit na kahusayan at scalability.

Sa artikulong ito, tutuklasin natin ang problema kung saan ang multiprocessing gamit ang mapa function ay maaaring maging isang mahusay na solusyon, talakayin ang mga nauugnay na library at function, magbigay ng sunud-sunod na paliwanag ng code, at suriin ang mga kaugnay na paksa na binuo sa backbone ng multiprocessing at ang function ng mapa.

Multiprocessing Map: Ang Problema at Solusyon

Ang problemang nilalayon naming lutasin ay pahusayin ang pagganap at kahusayan ng paglalapat ng isang function sa bawat item sa isang malaking iterable, tulad ng isang listahan, tuple, o anumang iba pang bagay na sumusuporta sa pag-ulit. Kapag nahaharap sa ganitong mga gawain, ang paggamit ng built-in na function ng mapa o mga pag-unawa sa listahan ay maaaring maging mabagal at hindi epektibo.

Ang solusyon ay ang paggamit ng multiprocessing library sa Python, partikular, ang Pul klase at nito mapa paraan. Sa pamamagitan ng paggamit ng multiprocessing Pool.map() function, maaari naming ipamahagi ang pagpapatupad ng aming function sa maraming proseso.

Hakbang-hakbang na Pagpapaliwanag ng Kodigo

Hatiin natin ang code at ilarawan kung paano epektibong gamitin ang multiprocessing map function:

import multiprocessing
import time

def square(n):
    time.sleep(0.5)
    return n * n

# Create the list of numbers
numbers = list(range(10))

# Initialize the multiprocessing Pool
pool = multiprocessing.Pool()

# Use the map function with multiple processes
squared_numbers = pool.map(square, numbers)

print(squared_numbers)
  1. Una, i-import ang multiprocessing module, na naglalaman ng mga tool na kinakailangan upang magamit ang parallel processing sa Python.
  2. Lumikha ng isang function na tinatawag parisukat na natutulog lamang ng kalahating segundo at pagkatapos ay ibabalik ang parisukat ng input argument nito. Ginagaya ng function na ito ang isang kalkulasyon na tumatagal ng makatwirang tagal ng oras upang makumpleto.
  3. Bumuo ng isang listahan na tinatawag numero, na naglalaman ng mga integer mula 0 hanggang 9 (kasama).
  4. Pinasimulan ang a Pul object mula sa multiprocessing module. Ang bagay na Pool ay nagsisilbing isang paraan upang pamahalaan ang mga proseso ng manggagawa na iyong gagamitin upang iparallelize ang iyong mga gawain.
  5. Tawagan ang mapa paraan sa pool object, at ipasa ang parisukat function at ang numero listahan. Ang paraan ng mapa pagkatapos ay inilalapat ang square function sa bawat item sa listahan ng mga numero nang sabay-sabay, gamit ang mga available na proseso ng manggagawa sa pool.
  6. I-print ang resultang listahan ng squared_numbers, na dapat maglaman ng mga squared value mula sa listahan ng mga numero.

Python Multiprocessing Library

Ang sawa multiprocessing Ang library ay nagbibigay ng intuitive na paraan ng pagpapatupad ng parallelism sa iyong programa. Tinatakpan nito ang ilan sa mga kumplikadong karaniwang nauugnay sa parallel programming sa pamamagitan ng pag-aalok ng mga high-level abstraction tulad ng Pul. Pinapasimple ng klase ng Pool ang pamamahagi ng trabaho sa maraming proseso, na nagbibigay-daan sa user na maranasan ang mga benepisyo ng parallel processing na may kaunting abala.

Python Itertools Module at Mga Kaugnay na Function

Habang ang multiprocessing ay isang mahusay na solusyon para sa maraming magkakatulad na gawain, ito ay nagkakahalaga ng pagbanggit na ang Python ay nagbibigay din ng iba pang mga aklatan at tool na tumutugon sa mga katulad na pangangailangan. Ang module ng itertools, halimbawa, ay nag-aalok ng maraming function na gumagana sa mga iterable, kadalasang may pinahusay na kahusayan. Ang ilang mga itertool ay gumagana tulad ng imap() at imap_unordered() maaaring parallelize ang proseso ng paglalapat ng isang function sa isang iterable. Gayunpaman, mahalagang tandaan na ang itertools ay pangunahing nakatuon sa mga solusyon na nakabatay sa iterator, samantalang ang multiprocessing library ay nag-aalok ng mas komprehensibong diskarte sa parallelism, na nagbibigay ng mga karagdagang tool at kakayahan na lampas sa mga function na tulad ng mapa.

Kaugnay na mga post:

Mag-iwan ng komento