Traitement parallèle en Python

Présentation

Dans l’environnement numérique en évolution rapide d’aujourd’hui, il est crucial pour les développeurs et les data scientists d’accomplir efficacement des tâches informatiques difficiles. Heureusement, Python offre de puissantes capacités de traitement parallèle en raison de son adaptabilité et de son vaste écosystème. Nous pouvons obtenir des améliorations substantielles des performances en décomposant les problèmes difficiles en activités plus petites et plus gérables et en travaillant sur celles-ci simultanément.

Les capacités de traitement parallèle de Python nous permettent d'utiliser les ressources informatiques disponibles pour effectuer des activités telles que le web scraping, les simulations scientifiques et l'analyse de données plus rapidement et plus efficacement. Dans cet article, nous allons commencer un voyage à travers le traitement parallèle en Python. Nous examinerons un certain nombre de méthodes, notamment le multitraitement, la programmation asynchrone et le multithreading, et apprendrons comment les utiliser efficacement pour contourner les obstacles aux performances de votre système. Rejoignez-nous pour réaliser toute la puissance du traitement parallèle en Python et atteindre de nouveaux sommets de performances et de productivité.

En savoir plus sur le traitement parallèle

Diviser une tâche en sous-tâches plus petites et les exécuter simultanément sur plusieurs processeurs ou cœurs est appelé traitement parallèle. Le traitement parallèle peut réduire considérablement le temps d'exécution global d'un programme en utilisant efficacement les ressources informatiques disponibles. La programmation asynchrone, le multitraitement et le multithreading ne sont que quelques-unes des méthodes de traitement parallèle proposées par Python.

Threading multiple en Python

Grâce à la méthode multi-threading, de nombreux threads s'exécutent simultanément dans le même processus et partagent la même mémoire. Le multithreading peut être facilement implémenté à l'aide du module de threading de Python. Cependant, l'utilisation du multithreading dans Python peut ne pas avoir d'effet d'accélération sur les opérations gourmandes en CPU, car le Global Interpreter Lock (GIL) ne permet qu'à un seul thread d'exécuter le bytecode Python en même temps. Cependant, le multithreading peut être utile pour les tâches gourmandes en E/S, car il permet aux threads d'exécuter d'autres opérations en attendant la fin des opérations d'E/S.

Voyons un exemple d'utilisation du multithreading pour télécharger plusieurs pages Web :

Exemple

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

Sortie

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

Étant donné que l'extrait de code ci-dessus peut effectuer plusieurs téléchargements en même temps, cet extrait de code télécharge chaque URL dans son propre fil de discussion. La fonction join() garantit que le thread principal attend que chaque thread soit terminé avant de continuer.

Multitraitement en Python

Le multi-processus correspond au multi-threading. En utilisant plusieurs processus, chaque processus possède son propre espace mémoire, offrant un véritable parallélisme. Le module multitraitement de Python fournit une interface de haut niveau pour implémenter plusieurs processus. Le multitraitement convient aux tâches gourmandes en CPU car chaque processus s'exécute dans un interpréteur Python indépendant, évitant ainsi les limitations du multithreading GIL.

Plusieurs processus sont utilisés dans le code ci-dessous. Une fois que la classe pool a généré un ensemble de processus de travail, la méthode map() répartit la charge entre les processus disponibles. Une liste de résultats est une collection de résultats.

Considérons l'exemple suivant, où nous utilisons plusieurs processus pour calculer le carré de chaque entier dans une liste :

Exemple

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) 

Sortie

[1, 4, 9, 16, 25] 

Programmation asynchrone Python

En tirant parti des opérations non bloquantes, la programmation asynchrone permet une exécution efficace des processus gourmands en E/S. Grâce au package asyncio, Python peut créer du code asynchrone à l'aide de coroutines, de boucles d'événements et de futurs. À mesure que les applications et les API en ligne deviennent plus populaires, la programmation asynchrone devient de plus en plus importante.

La coroutine fetch_page() dans l'exemple de code ci-dessous utilise aiohttp pour obtenir des pages Web de manière asynchrone. La méthode main() génère une liste de tâches puis utilise asyncio.gather() pour exécuter ces tâches simultanément. Pour attendre la fin d'une tâche et recevoir les résultats, utilisez le mot-clé wait.

Voyons un exemple de récupération asynchrone de plusieurs pages Web à l'aide de asyncio et aiohttp :

Exemple

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

Sortie

['<!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 '

Choisissez la bonne méthode

Les techniques de traitement parallèle de Python varient en fonction des circonstances spécifiques de la tâche. Voici quelques lignes directrices pour vous aider à prendre des décisions éclairées :

Pour les activités gourmandes en E/S, où la majeure partie du temps d'exécution est passée à attendre les opérations d'entrée/sortie, le multithreading est approprié. Il convient aux tâches telles que le téléchargement de fichiers, l'utilisation d'API et la manipulation de fichiers. En raison du Global Interpreter Lock (GIL) de Python, le multithreading peut ne pas accélérer de manière significative les activités gourmandes en CPU.

En revanche, le multi-traitement convient aux tâches gourmandes en ressources CPU et impliquant des calculs intensifs. Il atteint un véritable parallélisme en utilisant plusieurs processus, chacun avec son propre espace mémoire, contournant les limitations du GIL. Cependant, cela entraîne une surcharge supplémentaire en termes de consommation de mémoire et de communication inter-processus.

La programmation asynchrone effectuée à l'aide de bibliothèques telles que asyncio est utile pour les activités gourmandes en E/S impliquant des opérations réseau. Il utilise des opérations d'E/S non bloquantes afin que les tâches puissent se poursuivre sans attendre la fin de chaque opération. Cette approche gère efficacement plusieurs connexions simultanées, ce qui la rend adaptée au développement de serveurs Web, aux interactions d'API Web et au web scraping. La programmation asynchrone minimise les temps d'attente pour les opérations d'E/S, garantissant ainsi réactivité et évolutivité.

Conclusion

Les capacités de traitement parallèle de Python offrent la possibilité d'augmenter l'efficacité des tâches nécessitant des calculs complexes. Que vous choisissiez d'utiliser le multithreading, le multitraitement ou la programmation asynchrone, Python fournit les outils et modules nécessaires pour tirer efficacement parti de la concurrence. En comprenant la nature de l'activité et en choisissant la technologie appropriée, vous pouvez maximiser les avantages du traitement parallèle et réduire le temps d'exécution. Alors continuez à explorer et à tirer pleinement parti du parallélisme de Python pour créer des applications plus rapides et plus efficaces.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!