Pemprosesan selari dalam Python

Pengenalan

Dalam persekitaran digital yang serba pantas hari ini, adalah penting bagi pembangun dan saintis data untuk menyelesaikan tugasan yang sukar secara pengiraan dengan cekap. Nasib baik, Python menawarkan keupayaan pemprosesan selari yang berkuasa kerana kebolehsuaian dan ekosistemnya yang luas. Kita boleh mencapai peningkatan prestasi yang ketara dengan memecahkan masalah yang sukar kepada aktiviti yang lebih kecil, lebih terurus dan menyelesaikannya secara serentak.

Keupayaan pemprosesan selari Python membolehkan kami menggunakan sumber komputer yang tersedia untuk melaksanakan aktiviti seperti mengikis web, simulasi saintifik dan analisis data dengan lebih pantas dan cekap. Dalam artikel ini, kami akan memulakan perjalanan melalui pemprosesan selari dalam Python. Kami akan memeriksa beberapa kaedah, termasuk berbilang pemprosesan, pengaturcaraan tak segerak dan berbilang benang, dan mempelajari cara menggunakannya dengan berkesan untuk memintas sekatan jalan prestasi dalam sistem anda. Sertai kami kerana kami menyedari kuasa penuh pemprosesan selari dalam Python dan mencapai tahap prestasi dan produktiviti yang baharu.

Ketahui tentang pemprosesan selari

Membahagikan kerja kepada subtugas yang lebih kecil dan menjalankannya serentak pada berbilang pemproses atau teras dipanggil pemprosesan selari. Pemprosesan selari boleh mengurangkan masa pelaksanaan keseluruhan program dengan ketara dengan menggunakan sumber pengkomputeran yang tersedia dengan cekap. Pengaturcaraan asynchronous, multiprocessing, dan multithreading hanyalah beberapa kaedah pemprosesan selari yang ditawarkan Python.

Benang Berbilang dalam Python

Menggunakan kaedah berbilang benang, banyak benang berjalan serentak dalam proses yang sama dan berkongsi memori yang sama. Multithreading boleh dilaksanakan dengan mudah menggunakan modul threading Python. Walau bagaimanapun, menggunakan multithreading dalam Python mungkin tidak mempunyai kesan mempercepatkan pada operasi intensif CPU kerana Global Interpreter Lock (GIL) hanya membenarkan satu thread untuk melaksanakan kod bait Python pada masa yang sama. Walau bagaimanapun, multithreading boleh berguna untuk tugas intensif I/O kerana ia membenarkan utas menjalankan operasi lain sementara menunggu operasi I/O selesai.

Mari lihat contoh menggunakan multi-threading untuk memuat turun berbilang halaman web:

Contoh

import threading import requests 
 
def download_page(url): 
    response = requests.get(url)    
print(f"Downloaded {url}") 
 
urls = [ 
    "https://example.com", 
    "https://google.com", 
    "https://openai.com" 
] 
 
threads = [] 
 for url in 
 urls: 
    thread = threading.Thread(target=download_page,
args=(url,))     thread.start()    threads.append(thread) 
 
for thread in threads: 
    thread.join() 

Output

Downloaded https://example.com 
Downloaded https://google.com 
Downloaded https://openai.com 

Memandangkan coretan kod di atas boleh melakukan berbilang muat turun pada masa yang sama, coretan kod ini memuat turun setiap URL dalam urutannya sendiri. Fungsi join() memastikan bahawa utas utama menunggu setiap utas selesai sebelum meneruskan.

Pemprosesan berbilang dalam Python

Berbilang proses sepadan dengan berbilang benang Dengan menggunakan berbilang proses, setiap proses mempunyai ruang ingatan sendiri, memberikan keselarian sebenar. Modul berbilang pemprosesan Python menyediakan antara muka peringkat tinggi untuk melaksanakan pelbagai proses. Multiprocessing sesuai untuk tugas intensif CPU kerana setiap proses berjalan dalam penterjemah Python bebas, mengelakkan batasan multithreading GIL.

Berbilang proses digunakan dalam kod di bawah. Setelah kelas kumpulan telah menghasilkan satu set proses pekerja, kaedah map() mengagihkan beban kepada proses yang tersedia. Senarai keputusan ialah koleksi hasil.

Pertimbangkan contoh berikut, di mana kami menggunakan berbilang proses untuk mengira kuasa dua setiap integer dalam senarai:

Contoh

import multiprocessing 
 
def square(number):    
return number ** 2 
 
numbers = [1, 2, 3, 4, 5] 
 
with multiprocessing.Pool() as pool: 
    results = pool.map(square, numbers) 
 
print(results) 

Output

[1, 4, 9, 16, 25] 

Python pengaturcaraan tak segerak

Dengan memanfaatkan operasi tanpa sekatan, pengaturcaraan tak segerak membolehkan pelaksanaan proses intensif I/O yang cekap. Terima kasih kepada pakej asyncio, Python boleh mencipta kod tak segerak menggunakan coroutine, gelung acara dan niaga hadapan. Apabila aplikasi dalam talian dan API menjadi lebih popular, pengaturcaraan tak segerak menjadi semakin penting.

Coroutine fetch_page() dalam contoh kod di bawah menggunakan aiohttp untuk mendapatkan halaman web secara tidak segerak. Kaedah main() menjana senarai kerja dan kemudian menggunakan asyncio.gather() untuk melaksanakan kerja ini secara serentak. Untuk menunggu tugasan selesai dan menerima keputusan, gunakan kata kunci await.

Mari lihat contoh pengambilan berbilang halaman web secara tidak segerak menggunakan asyncio dan aiohttp:

Contoh

import asyncio 
import aiohttp 
 
async def fetch_page(url):     async with aiohttp.ClientSession() as session:         async with session.get(url) as response: 
            return await response.text() 
 
async def main(): 
    urls = [ 
        "https://example.com", 
        "https://google.com", 
        "https://openai.com" 
    ] 
 
    tasks = [fetch_page(url) for url in urls]     pages = await asyncio.gather(*tasks)     
print(pages) 
 
asyncio.run(main()) 

Output

['<!doctype html>\n<html>\n<head>\n    <title>Example Domain</title>\n\n    <meta 
charset="utf-8" />\n    <meta http-equiv="Content-type"content="text/html; charset=utf-8" />\n    <meta name="viewport" content="width=device-width, initialscale=1" />\n    <style type="text/css">\n    body {\n        background-color: #f0f0f2;\n  margin: 0;\n        padding: 0;\n        font-family: "Open Sans", "Helvetica Neue", Helvetica, Arial, sans-serif;\n        \n    }\n    div {\n        width: 600px;\n        margin: 5em auto;\n  padding: 50px;\n        background-color: #fff;\n        border-radius: 1em;\n    }\n    a:link, a:visited {\n        color: #38488f;\n        text-decoration: none;\n    }\n    @media (maxwidth: 700px) {\n        body {\n            background-color: #fff;\n        }\n        div {\n  width: auto;\n            margin: 0 auto;\n            border-radius: 0;\n            padding: 1em;\n        }\n    }\n    </style>    \n</head>\n\n<body>\n<div>\n    <h1>Example Domain</h1>\n    <p>This domain is for use in illustrative examples in documents. You may use this\n    domain in literature without prior coordination or asking for permission.</p>\n    <p><a href="https://www.iana.org/domains/example">More information...</a></p>\n</div>\n</body>\n</html>', '<!doctype html><html itemscope="" itemtype="http://schema.org/WebPage" lang="en"><head><meta content="Search the world's information, including webpages, images, videos and more. Google has many special features to help you find exactly what you're looking for." name="description"><meta content="noodp" name="robots"><meta content="text/html; charset=UTF-8" http-equiv="Content-Type"><meta content="/logos/doodles/2021/mom-
and-dad-6116550989716480.2-law.gif" itemprop="image"><link href="/logos/doodles/2021/mom-and-dad-6116550989716480.2-law.gif" rel="icon" type="image/gif"><title>Google</title><script nonce="sJwM0Ptp5a/whzxPtTD8Yw==">(function(){window.google={kEI:'cmKgYY37A7 K09QPhzKuACw',kEXPI:'1354557,1354612,1354620,1354954,1355090,1355493,13556
83,3700267,4029815,4031109,4032677,4036527,4038022,4043492,4045841,4048347,4
048490,4052469,4055589,4056520,4057177,4057696,4060329,4060798,4061854,4062 531,4064696,406 '

Pilih kaedah yang betul

Teknik pemprosesan selari Python berbeza-beza bergantung pada keadaan khusus tugas. Berikut ialah beberapa garis panduan untuk membantu anda membuat keputusan termaklum:

Untuk aktiviti I/O-intensif, di mana kebanyakan masa pelaksanaan dihabiskan untuk menunggu operasi input/output, multi-threading adalah sesuai. Ia sesuai untuk tugas seperti memuat turun fail, menggunakan API dan memanipulasi fail. Disebabkan oleh Global Interpreter Lock (GIL) Python, multithreading mungkin tidak mempercepatkan aktiviti intensif CPU dengan ketara.

Sebaliknya, pemprosesan berbilang sesuai untuk tugas terikat CPU yang melibatkan pengiraan intensif. Ia mencapai keselarian sebenar dengan menggunakan pelbagai proses, setiap satu dengan ruang ingatannya sendiri, memintas batasan GIL. Walau bagaimanapun, ia menanggung overhed tambahan dari segi penggunaan memori dan komunikasi antara proses.

Pengaturcaraan tak segerak yang dilakukan menggunakan perpustakaan seperti asyncio berguna untuk aktiviti intensif I/O yang melibatkan operasi rangkaian. Ia menggunakan operasi I/O tanpa sekatan supaya kerja boleh diteruskan tanpa menunggu setiap operasi selesai. Pendekatan ini menguruskan berbilang sambungan serentak dengan cekap, menjadikannya sesuai untuk pembangunan pelayan web, interaksi API Web dan pengikisan web. Pengaturcaraan tak segerak meminimumkan masa menunggu untuk operasi I/O, memastikan responsif dan kebolehskalaan.

Kesimpulan

Keupayaan pemprosesan selari Python memberi peluang untuk meningkatkan kecekapan dalam tugas yang memerlukan pengiraan yang rumit. Sama ada anda memilih untuk menggunakan pengaturcaraan multithreading, multiprocessing atau tak segerak, Python menyediakan alatan dan modul yang diperlukan untuk memanfaatkan concurrency dengan berkesan. Dengan memahami sifat aktiviti dan memilih teknologi yang sesuai, anda boleh memaksimumkan faedah pemprosesan selari dan mengurangkan masa pelaksanaan. Jadi, teruskan meneroka dan memanfaatkan sepenuhnya keselarian Python untuk mencipta aplikasi yang lebih pantas dan cekap.

Atas ialah kandungan terperinci Pemprosesan selari dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!