Remerciez-le!

Remerciez @Admin pour avoir partagé cet document gratuitement, de la manière la plus simple, en partageant sur les réseaux sociaux.

Tutoriel pour apprendre la programmation parallèle en Python Par Gabor Laszlo H

Tutoriel pour apprendre la programmation parallèle en Python Par Gabor Laszlo Hajba - Christophe LOUVET (traducteur) Date de publication : 8 mars 2017 Dans ce tutoriel , je vais vous présenter le traitement parallèle en Python avec des threads (appelés aussi processus légers en français) en se concentrant sur Python 3.5. Commentez Tutoriel pour apprendre la programmation parallèle en Python par Gabor Laszlo Hajba 1 - Pourquoi le parallélisme ?......................................................................................................................................3 2 - Quelques exemples............................................................................................................................................... 3 2-1 - Téléchargement des images depuis imgur.com............................................................................................3 2-2 - Décomposition en facteurs premiers.............................................................................................................4 3 - Comment faire ?.....................................................................................................................................................5 3-1 - Partage de données entre threads............................................................................................................... 5 4 - Exemples parallélisés............................................................................................................................................ 6 4-1 - Téléchargeur d'image....................................................................................................................................6 4-2 - Décomposition en facteurs premiers.............................................................................................................7 4-3 - Facteurs premiers avec expressions lambda............................................................................................... 8 5 - Conclusion..............................................................................................................................................................9 6 - Remerciements...................................................................................................................................................... 9 - 2 - Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2016 DiscoverSDK. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://ghajba.developpez.com/tutoriels/python/programmation-parallele-python/ Tutoriel pour apprendre la programmation parallèle en Python par Gabor Laszlo Hajba 1 - Pourquoi le parallélisme ? Nous avons besoin très souvent d'appeler un service externe (serveur Web, serveur de bases de données, fichiers, etc.) et comme le résultat dépend de la réponse, nous nous retrouvons dans un mode bloquant tant que le résultat n'est pas disponible. Dans ce genre de cas, si nous répartissons notre programme en tâches parallèles, nous pouvons utiliser le temps processeur plus efficacement. Comme de nos jours il y a des processeurs multicœurs sur la plupart des machines, cela signifie que nous avons le parallélisme disponible au niveau matériel. Il est important d'être familier avec les fonctionnalités de parallélisme de n'importe quel langage pour écrire du code plus efficace. Python est utilisé sur les applications Web ; quand nous dépendons du temps de réponse du serveur ainsi que de la base de données et d'autres composants, et, plus généralement, si nous écrivons du code autre qu'un script simple, nous pouvons utiliser des threads pour faire fonctionner les choses en parallèle. Dans ces conditions, nous devons être également familiers avec certains problèmes connus tels que les situations de compétition et l'utilisation d'objets de synchronisation pour les éviter. 2 - Quelques exemples Dans ce tutoriel, nous regarderons deux exemples de base : • le téléchargement d'images depuis ingur.com ; • le calcul de factorisation. Les deux exemples auront une version de base, où j'introduirai simplement le problème et le code pour le résoudre. Ensuite, j'ajouterai du parallélisme dans les deux exemples et nous verrons ce que nous obtenons : avons-nous obtenu des résultats plus rapides ou plus lents en raison du traitement parallélisé ? 2-1 - Téléchargement des images depuis imgur.com Pour cela, j'ai préparé un ensemble d'URL pour les images à télécharger, ceci permettant des tests plus stables pour ce tutoriel (si nous ne tenons pas compte de la mise en cache du routeur Web). Cependant, je vais vous montrer les sources vous permettant de manipuler le code. Regardons maintenant le code : 1. __author__ = 'GHajba' 2. 3. from urllib.request import urlopen, Request 4. import json 5. import os 6. 7. 8. def get_image_urls(client_id): 9. headers = {'Authorization': 'Client-ID {0}'.format(client_id)} 10. with urlopen(Request('https://api.imgur.com/3/g/memes/', headers=headers)) as response: 11. data = json.loads(response.read().decode('utf-8')) 12. return map(lambda image: image['link'], data['data']) 13. 14. 15. def download_images(target_dir, url): 16. path = target_dir + '/' + os.path.basename(url) 17. 18. with open(path, 'wb') as file: 19. file.write(urlopen(url).read()) - 3 - Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2016 DiscoverSDK. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://ghajba.developpez.com/tutoriels/python/programmation-parallele-python/ Tutoriel pour apprendre la programmation parallèle en Python par Gabor Laszlo Hajba Ce code télécharge les derniers éléments de la page « memes » de imgur.com dont les liens pointent vers des fichiers .png ou jpg. Je vais éviter d'entrer dans les détails sur la façon d'obtenir votre « IMGUR_CLIENT_ID », mais cela doit être spécifié dans l'environnement, car l'API imgur requiert une authentification qui est fournie à travers un id client. Néanmoins, ce code télécharge les images une à une. Sur mon Mac, l'exécution du code donne les résultats suivants : 1. 52 images téléchargées en 13.790853023529053 secondes avec Python 3 2. 52 images téléchargées en 15.189190864562988 secondes avec Python 3 3. 52 images téléchargées en 13.965453863143921 secondes avec Python 3 4. 52 images téléchargées en 13.087532997131348 secondes avec Python 3 5. 52 images téléchargées en in 14.43852710723877 secondes avec Python 3 Comme vous pouvez le voir, cela prend en moyenne 14 secondes pour télécharger 52 images depuis imgur en utilisant seulement un des huit cœurs dont je dispose. 2-2 - Décomposition en facteurs premiers Dans cet exemple, je vais utiliser une version pas vraiment optimisée de décomposition en facteurs premiers. Ce calcul est très intensif au niveau CPU. Cela signifie qu'il requiert plus de puissance de calcul de la part de l'ordinateur que l'exemple précédent, où nous passions pas mal de temps à attendre du réseau toutes les données requises. Le code de calcul des facteurs premiers ressemble à celui-ci : 1. def factors(result, n): 2. if n <= 1: 3. return result 4. for i in range(2, n + 1): 5. if n % i == 0: 6. result.append(i) 7. return factors(result, n // i) Comme vous pouvez le voir, nous recevons comme arguments de la fonction un nombre n et une liste partielle de résultats nommée « result ». Pour chaque nombre compris entre 2 et n, nous testons si n est divisible par ce nombre. Si oui, nous ajoutons ce nombre à la liste de résultat et appelons récursivement la fonction factors en lui passant en paramètres la nouvelle liste partielle des résultats et le résultat de la division entière de n (n//i). Ce n'est pas optimisé, car nous parcourons chaque nombre entre 2 et n fois, et calculons le reste de la division n de chacun de ces nombres, au lieu d'utiliser une liste de nombres premiers (ou un générateur pour le faire plus efficacement). Mais c'est parfait pour cet exemple, car ces tâches nécessitent beaucoup de calculs de la part du processeur. Lançons maintenant ce code avec une liste de 50 000 nombres et voyons ce qu'il se passe : 1. La factorisation de 50000 nombres a pris 25,89749503135681 secondes avec l'approche série récursive et Python 3.5.0 2. La factorisation de 50000 nombres a pris 26,277130842208862 secondes avec l'approche série récursive et Python 3.5.0 3. La factorisation de 50000 nombres a pris 26,53605008125305 secondes avec l'approche série récursive et Python 3.5.0 4. La factorisation de 50000 nombres a pris 25,725329160690308 secondes avec l'approche série récursive et Python 3.5.0 5. La factorisation de 50000 nombres a pris 25,732399940490723 secondes avec l'approche série récursive et Python 3.5.0 - 4 - Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright ® 2016 DiscoverSDK. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts. http://ghajba.developpez.com/tutoriels/python/programmation-parallele-python/ Tutoriel pour apprendre la programmation parallèle en Python par Gabor Laszlo Hajba Cela paraît pas mal, mais si vous augmentez le nombre de calculs, nous aurons des temps de calcul plus longs : 1. La factorisation de 55000 nombres a pris 33.56754684448242 secondes avec l'approche série récursive et Python 3.5.0 2. La factorisation de 60000 nombres a pris 37.03928780555725 secondes avec l'approche série récursive et Python 3.5.0 3. La factorisation de 65000 nombres a pris 41.349984884262085 secondes avec l'approche série récursive et Python 3.5.0 4. La factorisation de 75000 nombres a pris 56.48437809944153 secondes avec l'approche série récursive et Python 3.5.0 5. La factorisation de 100000 nombres a pris 100.21058487892151 secondes avec l'approche série récursive et Python 3.5.0 À la fin, nous atteignons la moyenne de 1 seconde pour 1000 nombres. Et ce n'est pas bon si nous voulons traiter plus de nombres. 3 - Comment faire ? Après avoir étudié les exemples ci-dessus, il est temps d'en dire plus sur comment réaliser la parallélisation en Python 3. On réalise un traitement parallèle avec des threads en utilisant uploads/S4/ programmation-parallele-python.pdf