Python 3 - fnac-static.com

ISBN

: 978

-2-40

9-022

92-0

39 €

Python 3Traitement de données et techniques de programmation

Expert technique Python/Django et Web Backend/Frontend, Sébastien CHAZALLET intervient en tant qu’in-dépendant sur de longues missions de développement, d’audit, d’exper-tise et de formation (www.formation-python.com, www.inspyration.fr). Ses réalisations portent sur des dévelop-pements autour de Python sur des projets de grande envergure, essen-tiellement des applications intranet sur mesure avec Django, mais égale-ment sur des applications de bureau, des scripts système, la création de sites web ou de e-commerce. À tra-vers ce livre, il a su faire profiter le lecteur de sa parfaite maîtrise du lan-gage Python dans sa dernière version et de l’expérience terrain acquise sur ses différentes missions.

Ce livre sur le langage Python 3 (en version 3.8 beta au moment de l’écriture) s’adresse à tout professionnel de l’informatique, ingé-nieur, étudiant, enseignant ou même autodidacte qui souhaite maîtriser ce langage très abouti. L’objectif de ce livre est de montrer au lecteur ce que l’on peut faire avec le langage, du traitement de données à la création d’un site web, en passant par la gestion du système et du réseau. Pour bien appréhender son contenu, la lecture du livre dont il est la suite, Python 3 - Les fondamentaux du langage chez le même éditeur, est recommandée.

La première partie couvre le traitement de données avec la manipulation de fichiers, les fichiers de configuration, les formats d’import/export, la gestion de la compression ou encore les flux XML ou la génération de documents.

La seconde partie présente la programmation système, la pro-grammation réseau, la programmation web et la programmation scientifique, qui sont autant de niches dans lesquelles le langage Python excelle par sa simplicité d’utilisation autant que par sa cou-verture fonctionnelle exceptionnelle.

La troisième partie présente tous les outils de programmation concurrente, qu’il s’agisse de programmation asynchrone, paral-lèle ou distribuée. On notera que l’accent est mis sur de nom-breuses techniques asynchrones, car il s’agit de l’un des points majeurs de l’évolution récente du langage Python.

Le code source des exemples du livre est intégralement télé-chargeable sur www.editions-eni.fr pour permettre au lecteur de tester le programme et de le modifier à sa guise de manière à faire ses propres expériences.

Pour plus d’informations :

Pyt

hon

3Tr

aite

men

t de

donn

ées

et te

chni

ques

de

prog

ram

mat

ion

Téléchargementwww.editions-eni.fr.fr

Sur www.editions-eni.fr :b Le code source des exemples.

Sébastien CHAZALLET

Python 3Traitement de données et techniques de programmation

En téléchargement Code source des exemples

+ QUIZ

Version en ligne

OFFERTE !pendant 1 an

1Table des matières

Avant-propos

Partie1Traitement des données

Chapitre 1.1Motifs de conception

1. Définition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151.1 Positionnement par rapport à la notion d’objet . . . . . . . . . . . . . . . . . . 151.2 Organisation du chapitre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161.3 Positionnement par rapport à d’autres concepts . . . . . . . . . . . . . . . . . 16

2. Motifs de création . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172.1 Singleton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

Les éléments à télécharger sont disponibles à l'adresse suivante :http://www.editions-eni.fr

Saisissez la référence de l'ouvrage EI3PYT dans la zone de recherche et validez. Cliquez sur le titre du livre puis sur le bouton de téléchargement.

2.2 Fabrique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172.3 Fabrique abstraite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202.4 Monteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212.5 Prototype. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3. Motifs de structuration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263.1 Adaptateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 263.2 Pont . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293.3 Composite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323.4 Décorateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343.5 Façade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363.6 Poids-mouche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383.7 Proxy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

4. Motifs de comportement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424.1 Chaîne de responsabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 424.2 Commande . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434.3 Itérateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

lcroise

Tampon

2
Traitement de données et techniques de programmation
Python 3

4.4 Mémento . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474.5 Visiteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484.6 Observateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494.7 Stratégie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514.8 Fonction de rappel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

5. ZCA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535.1 Rappels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535.2 Adaptateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535.3 Utilitaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 555.4 Fabrique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565.5 Pour aller plus loin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

Chapitre 1.2XML

1. XML et les technologies qui gravitent autour . . . . . . . . . . . . . . . . . . . . . . . . 591.1 Définition de XML, terminologie associée . . . . . . . . . . . . . . . . . . . . . . 591.2 Notion de schéma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 601.3 Avantages et inconvénients de XML . . . . . . . . . . . . . . . . . . . . . . . . . . . 611.4 Différentes manières de parcourir un fichier XML . . . . . . . . . . . . . . . . 62
1.5 Modules Python dédiés au XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
2. Valider un document XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632.1 Document XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 632.2 Schéma DTD. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642.3 Schéma XSD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642.4 Schéma RNG (RelaxNG) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652.5 Schematron . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

3. DOM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663.1 Lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 663.2 Écriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

4. SAX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 684.1 Support de SAX dans lxml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 684.2 API SAX Allégée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

5. XPath . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

6. XSLT. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72


7. Cas spécifique des fichiers HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 747.1 Problématique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 747.2 Parser un fichier HTML à la façon DOM . . . . . . . . . . . . . . . . . . . . . . . 747.3 Parser un fichier HTML à la façon SAX . . . . . . . . . . . . . . . . . . . . . . . . 76

Chapitre 1.3Génération de contenu

1. PDF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 791.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

1.1.1 Format PDF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 791.1.2 Avantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 791.1.3 Inconvénients. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 791.1.4 Présentation de la bibliothèque libre . . . . . . . . . . . . . . . . . . . . . 80

1.2 Bas niveau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 801.2.1 Bibliothèque de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 801.2.2 Canvas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82

1.3 Haut niveau. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 831.3.1 Styles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 831.3.2 Flux de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
1.3.3 Création d’un visuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 871.3.4 Template de page. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 871.3.5 Page contenant plusieurs zones . . . . . . . . . . . . . . . . . . . . . . . . . 88
2. OpenDocument. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 902.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 902.2 ezodf2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

2.2.1 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 912.2.2 OpenDocument Texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 912.2.3 OpenDocument Tableur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 912.2.4 Aller plus loin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

2.3 Alternatives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 922.3.1 lpod . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 922.3.2 Génération à partir de templates . . . . . . . . . . . . . . . . . . . . . . . . 92

3. Travailler avec des images. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 933.1 Représentation informatique d’une image . . . . . . . . . . . . . . . . . . . . . . 933.2 Présentation de Pillow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

4
Python 3

3.3 Formats d’images matricielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 953.4 Récupérer des informations d’une image . . . . . . . . . . . . . . . . . . . . . . . 973.5 Opérations d’ensemble sur une image. . . . . . . . . . . . . . . . . . . . . . . . . . 983.6 Travailler avec les calques ou les pixels . . . . . . . . . . . . . . . . . . . . . . . . 100

Chapitre 1.4Qualité

1. Programmation dirigée par les tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1031.1 Tests unitaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103

1.1.1 Principes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1031.1.2 Interprétation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1041.1.3 Couverture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1051.1.4 Outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1051.1.5 Autres outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107

1.2 Tests de non-régression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1071.2.1 Actions de développement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1071.2.2 Gestion de la découverte d’une anomalie par une MOA. . . . . 108

1.3 Tests fonctionnels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1091.4 Tests de performance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
1.5 Tests syntaxiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1121.6 Intégration continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
2. Programmation dirigée par la documentation . . . . . . . . . . . . . . . . . . . . . . . 1142.1 Documentation interne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

2.1.1 À destination des développeurs. . . . . . . . . . . . . . . . . . . . . . . . . 1142.1.2 À destination des utilisateurs . . . . . . . . . . . . . . . . . . . . . . . . . . 115

2.2 Documentation externe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1152.2.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1152.2.2 Démarrage rapide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1152.2.3 Résultat. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118

3. Optimisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1183.1 Qualimétrie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1183.2 Outils de débogage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1203.3 Outils de profilage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120


3.4 Règles d’optimisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1223.4.1 Pourquoi optimiser ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1223.4.2 Règles générales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1233.4.3 Profiler un algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1243.4.4 Optimiser l'utilisation de la mémoire. . . . . . . . . . . . . . . . . . . . 133

Partie 2Programmation, système, réseau et scientifique

Chapitre 2.1Programmation système

1. Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1351.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1351.2 Objectifs du chapitre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136

2. Appréhender son système d’exploitation. . . . . . . . . . . . . . . . . . . . . . . . . . . 1362.1 Avertissement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1362.2 Système d’exploitation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1362.3 Processus courant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1372.4 Utilisateurs et groupes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
2.5 Mots de passe et authentification . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1402.6 Constantes pour le système de fichiers . . . . . . . . . . . . . . . . . . . . . . . . 1412.7 Gérer les chemins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1422.8 Utilitaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
2.8.1 Comparer deux fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1422.8.2 Utilitaire de sauvegarde. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1442.8.3 Lire un fichier de configuration . . . . . . . . . . . . . . . . . . . . . . . . 1452.8.4 Pickle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146

2.9 Compresser et décompresser un fichier. . . . . . . . . . . . . . . . . . . . . . . . 1482.9.1 Tarfile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1482.9.2 Gzip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1502.9.3 Bz2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1512.9.4 Zipfile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1512.9.5 Interface de haut niveau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153

3. Gestion d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1543.1 Changer les droits d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1543.2 Changer de propriétaire ou de groupe . . . . . . . . . . . . . . . . . . . . . . . . . 156

6
Python 3

3.3 Récupérer des informations sur un fichier . . . . . . . . . . . . . . . . . . . . . 1573.4 Supprimer un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 157

4. Alternatives simples à des commandes bash usuelles . . . . . . . . . . . . . . . . . 1584.1 Répertoires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1584.2 Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1604.3 Module de haut niveau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1614.4 Recherche d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163

5. Exécuter des commandes externes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1645.1 Exécuter et afficher le résultat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1645.2 Exécuter et récupérer le résultat. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1655.3 Pour Python 3.5 et supérieur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166

6. IHM système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1666.1 Présentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1666.2 Travailler avec des arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1676.3 Fermeture du programme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1716.4 Entrée standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1726.5 Sortie standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1736.6 Sortie d’erreur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1746.7 Taille du terminal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175

7. Curses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1767.1 Présentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1767.2 Gérer le démarrage et l'arrêt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1767.3 Affichage de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1777.4 Gestion des attributs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1777.5 Gestion des couleurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1787.6 Gestion des événements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178

8. Accès aux périphériques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1788.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1798.2 Voir les partitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1798.3 Voir les clés USB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1808.4 Liste des informations disponibles. . . . . . . . . . . . . . . . . . . . . . . . . . . . 1818.5 Détecter le branchement d'une clé USB . . . . . . . . . . . . . . . . . . . . . . . 1818.6 Communiquer via un port série . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1828.7 Communiquer via un port USB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183


Chapitre 2.2Programmation réseau

1. Écrire un serveur et un client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1851.1 Utilisation d’une socket TCP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1851.2 Utilisation d’une socket UDP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1891.3 Création d’un serveur TCP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1911.4 Création d’un serveur UDP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1931.5 Un peu plus loin sur le sujet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194

2. Utiliser un protocole standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1952.1 Client HTTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1952.2 Serveur HTTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1962.3 Proxy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1992.4 Cookies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2002.5 FTP et SFTP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2002.6 SSH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2022.7 POP et POPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2042.8 IMAP et IMAPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2052.9 SMTP et SMPTS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2062.10 NNTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
2.11 IRC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212
3. Wake-on-LAN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2153.1 Prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2153.2 Mise en œuvre. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215

Chapitre 2.3Programmation web

1. Services web. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2171.1 REST . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2171.2 SOAP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2181.3 Pyro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220

2. Client web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221

3. Web scrapping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225

8
Python 3

Chapitre 2.4Programmation scientifique

1. Calcul scientifique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2271.1 Présentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2271.2 Python, une alternative libre et crédible . . . . . . . . . . . . . . . . . . . . . . . 2271.3 Vue d'ensemble de quelques bibliothèques . . . . . . . . . . . . . . . . . . . . . 228

2. Tableaux multidimensionnels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2292.1 Création . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2292.2 Déterminer la composition d'un tableau . . . . . . . . . . . . . . . . . . . . . . . 2302.3 Générateurs de tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2312.4 Opérations basiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2322.5 Opérateur crochet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234

3. Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236

4. Génération de graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2374.1 Syntaxe MATLAB. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2384.2 Syntaxe objet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2394.3 Mise en forme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2394.4 Graphiques 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244

5. Introduction à Pandas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
5.1 Présentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2475.2 Séries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2475.3 Dataframes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251
Partie 3Programmation concurrente

Chapitre 3.1Programmation concurrente

1. Notion de performance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2591.1 Programmation bloquante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2591.2 Utilisation de ressources CPU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2601.3 Organisation de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261


2. Terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2622.1 Processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2622.2 Fil d’exécution. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2632.3 Programmation non bloquante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2642.4 Notion de GIL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 264

3. Présentation des paradigmes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2653.1 Programmation asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2653.2 Programmation parallèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2653.3 Programmation distribuée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2663.4 Programmation concurrente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267

Chapitre 3.2Programmation asynchrone : initiation

1. Utilité de la programmation asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . 269

2. Introduction à l’asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2702.1 Notion de coroutine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2702.2 Exécution d’une coroutine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2712.3 Précisions sur le mot-clé await. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
2.4 Exécuter plusieurs coroutines en séries . . . . . . . . . . . . . . . . . . . . . . . . 2732.5 Tâches asynchrones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2742.6 Exécuter les tâches asynchrones de manière concurrente . . . . . . . . . 2762.7 Notion d’awaitable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2762.8 Précisions sur asyncio.sleep . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
3. Éléments de grammaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2773.1 Gestionnaire de contexte asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . 2773.2 Générateurs asynchrones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2783.3 Compréhensions asynchrones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2783.4 Itération asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278

4. Notions avancées. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2784.1 Introspection. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2784.2 Gestion du résultat ou de l’exception . . . . . . . . . . . . . . . . . . . . . . . . . 2824.3 Annuler une tâche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2834.4 Se prémunir d’une annulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2854.5 Timeouts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2864.6 Gestion globale fine de l’attente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 286

10
Python 3

4.7 Module contextvars . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289

5. Boucle événementielle asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2925.1 Gestion de la boucle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2925.2 Débogage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2935.3 Notion de future . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2955.4 Annulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2975.5 Gestion des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 298

6. Utiliser la boucle événementielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3026.1 Utilisation des fonctions de retour (callbacks) . . . . . . . . . . . . . . . . . . 3026.2 Planifier des appels à des fonctions classiques . . . . . . . . . . . . . . . . . . 3056.3 Utiliser des signaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3066.4 Synchronisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3096.5 Communication entre coroutines . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3136.6 Exemple : lecture de l’entrée standard . . . . . . . . . . . . . . . . . . . . . . . . . 3176.7 Programmation parallèle et asynchrone . . . . . . . . . . . . . . . . . . . . . . . 3186.8 Exécuter du code bloquant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318

7. L’asynchrone suivant les versions de Python. . . . . . . . . . . . . . . . . . . . . . . . 3197.1 Python 3.7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3197.2 Python 3.6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3207.3 Python 3.5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
7.4 Python 3.4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3217.5 Python 3.3 et inférieur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3217.6 Python 2.7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322
8. Cas concret . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3228.1 Exemple de travail. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 322

9. Exemple retravaillé en utilisant des générateurs . . . . . . . . . . . . . . . . . . . . . 3259.1 Télécharger en asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3269.2 Parser en asynchrone. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3279.3 Faire plusieurs traitements en asynchrone . . . . . . . . . . . . . . . . . . . . . 3289.4 Utiliser un exécuteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3299.5 Pour aller plus loin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329

1
Chapitre 3.3Programmation asynchrone : avancée

1. Transports et protocoles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3311.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3311.2 Transports . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3311.3 Protocoles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3351.4 Mise en œuvre. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3361.5 Exemple pour le protocole TCP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3381.6 Exemple pour le protocole SSL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3461.7 Exemple pour le protocole UDP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3491.8 Traiter d’autres types de protocoles réseau. . . . . . . . . . . . . . . . . . . . . 3521.9 Exemple pour Subprocess. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353

2. Flux. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3592.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3592.2 Exemple avec le protocole TCP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359

Chapitre 3.4Programmation asynchrone : alternatives

1. Gevent . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3631.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3631.2 DNS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3631.3 Appels système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3641.4 Programmation asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 365

2. Twisted . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3662.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3662.2 Client/Serveur TCP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3662.3 Serveur/Client UDP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3682.4 AMP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3692.5 Autres protocoles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372

3. Trollius . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372

4. HTTP asynchrone avec aiohttp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3744.1 Côté serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3744.2 Côté client. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376

12
Python 3

Chapitre 3.5Programmation parallèle

1. Utilisation d’un fil d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3771.1 Gestion d’un fil d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377

1.1.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3771.1.2 Création . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 377

1.2 Gestion de plusieurs fils d’exécution . . . . . . . . . . . . . . . . . . . . . . . . . . 3801.2.1 Lancement et contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3801.2.2 Opportunité d’utiliser un fil d’exécution . . . . . . . . . . . . . . . . . 382

1.3 Résolution des problématiques liées . . . . . . . . . . . . . . . . . . . . . . . . . . 3841.3.1 Synchronisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3841.3.2 Synchronisation conditionnelle . . . . . . . . . . . . . . . . . . . . . . . . 3861.3.3 Sémaphore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388

2. Utilisation de processus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3902.1 Gestion d’un processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390

2.1.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3902.1.2 Création . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390

2.2 Gestion de plusieurs processus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3932.2.1 Synchronisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
2.2.2 Paralléliser un travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 393
2.3 Résolution des problématiques liées . . . . . . . . . . . . . . . . . . . . . . . . . . 3952.3.1 Communication interprocessus . . . . . . . . . . . . . . . . . . . . . . . . 3952.3.2 Partage de données entre processus . . . . . . . . . . . . . . . . . . . . . 397

2.4 Opportunité d’utiliser les processus . . . . . . . . . . . . . . . . . . . . . . . . . . 3982.5 Démon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398

3. Exécution asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4003.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4003.2 Présentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401

3
Chapitre 3.6Programmation distribuée

1. Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407

2. ØMQ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4072.1 Présentation générale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4072.2 Pair . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4092.3 Client/Serveur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4102.4 Publish/Subscribe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4112.5 Push/Pull . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4152.6 Patron pipeline . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416

3. AMQP avec RabbitMQ. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4183.1 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4183.2 Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4183.3 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4193.4 Notions importantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4213.5 Publish/Subscribe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4223.6 Routage et sujets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 423

4. Celery . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4254.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425
4.2 Dans quel cas utiliser Celery ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4254.3 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4254.4 Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4264.5 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4274.6 Monitorer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
5. Crossbar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4295.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4295.2 WebSocket. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4305.3 Publish/Subscribe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436

Index. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439

85
1
Chapitre 2.2Programmation réseau

Programmation réseau1. Écrire un serveur et un client1.1 Utilisation d’une socket TCP

TCP est l’acronyme de Transmission Control Protocol, soit protocole de contrôle de transmis-sion et a été développé en 1973 et documenté au sein de la RFC 793. Il est situé dans lemodèle OSI au sein de la couche transport et est répandu de par sa fiabilité.Il se caractérise par la manière de mettre en place la synchronisation entre client et serveur
et par le découpage en segments des octets à transmettre, chaque segment étant parfaite-ment identifiable et disposant d’un système de contrôle d’intégrité qui fait que celui quireçoit un paquet peut savoir que le paquet est corrompu et le redemander.Le flux TCP utilise les sockets et c’est le module éponyme de Python qui va nous permettrede travailler avec TCP.L’idée ici est de réaliser un mini serveur de données clé-valeur très basique et le plus simplepossible de manière à voir comment créer un serveur puis un client, mais aussi commentmanipuler les données qui sont échangées de l’un à l’autre.Ce qu’il faut absolument comprendre est que les données qui sont transmises d’un serveurà un client ou d’un client à un serveur sont des octets, et rien d’autre. En Python 2, celapouvait prêter à confusion, puisque le type str de Python 2 était assimilable à des octets.Le type Python 3 str représente une chaîne de caractères en unicode et c’est le typebytes qui permet de gérer des octets.Il faut donc particulièrement être attentif à ce point, puisque la plupart des exemples pré-sents sur le net, par ailleurs d’excellentes qualités, sont écrits pour Python 2 et génèrentune confusion sur le type de données réellement envoyées.On va créer un serveur qui s'attend à recevoir un nombre et qui renvoie un code en fonc-tion du fait que ce nombre soit premier ou non.

lcroise

Tampon

186Traitement de données et techniques de programmation

Python 3

Voici le code ce cette fonction :def isprime(n): '''check if integer n is a prime'''

# negative numbers, 0 and 1 are not primes if n < 2: return False

# 2 is the only even prime number if n == 2: return True

# all other even numbers are not primes if not n & 1: return False

# range starts with 3 and only needs to go up the squareroot # of n for all odd numbers for x in range(3, int(n**0.5)+1, 2): if n % x == 0: return False return True

Voici donc le code du serveur (disponible en téléchargement) :#!/usr/bin/python3

© E

diti

ons

ENI -

All

righ

ts r

eser

ved

import socket

params = ('127.0.0.1', 8809)BUFFER_SIZE = 1024 # default

donnees = {}

s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)#Internet, TCPs.bind(params)s.listen(1)

Le serveur est lancé et il écoute sur le port 8809. la méthode accept attend qu’uneconnexion se présente et dès qu’elle arrive, elle renvoie les éléments nécessaires pour quela connexion puisse être traitée. Ce qui est réalisé dans une boucle sans fin. Le principe estque tant que l’échange client serveur dure, il est traité.

conn, addr = s.accept()print('Connexion acceptée: %s' % str(addr))

while True: data = conn.recv(BUFFER_SIZE) if not data: break

87
1Programmation réseauChapitre 2.2
print('Donnée reçue: %s' % data) try : number = int(data) except: response = b'E' phrase = "'%s' n'est pas un entier" % data else: if isprime(number): phrase = "'%s' est un nombre premier" % number response = b'T' else: phrase = "'%s' n'est pas est un nombre premier" % number response = b'F' finally: print(response) conn.send(response)conn.close()

La partie complexe n’est pas tant la gestion de la connexion et des transferts réseau que letraitement des données. Ce qui compte est de savoir quoi faire des données et commentmettre en place un dialogue entre client et serveur, sachant que les seuls éléments échan-geables sont des octets.Dans cet exemple, on a choisi la convention suivante : si on ne comprend pas la donnéetransmise par le client, on renvoie un code E (pour erreur). Si le nombre est premier, onrenvoie un code T (pour True), sinon on renvoie un code F (pour False).Les choix effectués dans cet exemple sont assez basiques et limités : on cherche à trans-mettre le moins de données possible, mais serveur et client doivent s'entendre pour se com-
prendre entre eux : le client devra connaître l'ensemble des codes susceptibles d'êtreenvoyés par le serveur et les gérer.Cela montre les problématiques typiques qui se posent lorsque l’on cherche à manipulerdes données en utilisant des couches de bas niveau.Voici le code du client, qu’il faut lire en faisant le lien avec celui du serveur :
#!/usr/bin/python3

import socket


s=socket.socket(socket.AF_INET, socket.SOCK_STREAM)s.connect(params)

Le parti a été pris d’envoyer une succession de messages de manière à couvrir tous les caspossibles de traitement côté serveur.

chiffres = [4j, 4, 5, -5, 17, 29, 2**50, 2**50-1]


Python 3

En face de chaque message, qui est en réalité une sorte d’instruction donnée au serveur, estmis en commentaire le comportement attendu.Voici le code qui effectue les requêtes vers le serveur et qui traite les réponses :

for chiffre in chiffres: s=socket.socket(socket.AF_INET, socket.SOCK_STREAM) s.connect(params) print("Envoi d'un message %s" % chiffre) s.send(('%s\n' % chiffre).encode('utf8')) data = s.recv(BUFFER_SIZE) if len(data) == 0: print("\tPas de réponses") elif data == b'E\n': print("\tUne erreur est détectée par le serveur") elif data == b'T\n': print("\tLe nombre est bien un nombre premier") elif data == b'F\n': print("\tLe nombre n'est pas un nombre premier") else: print("\tLa donnée reçue n'est pas comprise : %s" % data) s.close()

TODO : tant que l’on est dans la boucle, on communique avec le serveur et donc le serveurreste dans la boucle infinie de communication. Le fait de fermer la connexion côté clientenvoie une trame vide qui va permettre de passer dans le break côté serveur (if notdata: break) et ainsi libérer le serveur.S’il y avait une boucle autour de la méthode accept, le serveur continuerait à tourner en

© E

diti

ons

ENI -

All

righ

ts r

eser

ved

attendant de nouvelles données qu’une nouvelle connexion lui parvienne et tourneraitainsi à l’infini, mais en l’occurrence, il n’y a pas cette boucle et il se stoppe donc.Cet exemple ne permet donc que de parler à un seul client, puis d’arrêter le serveur. Ilexiste, dans la pratique, des cas d’utilisation tels que celui-ci.Il existe, par exemple, un excellent outil nommé woof qui s'installe via le gestionnaire depaquet et se lance en ligne de commande :

$ sudo aptitude install woof

$ python path/to/woof.py path/to/filenameUn serveur est lancé et propose une URL qu’il suffit de donner à quelqu’un par IRC ou unautre moyen pour que cette personne, en cliquant dessus, télécharge le fichier. À la fin dutéléchargement, le serveur se ferme. On peut donc transmettre un document par le réseaurapidement.

89
1Programmation réseauChapitre 2.2
1.2 Utilisation d’une socket UDPComme TCP, UDP appartient à la couche transport du modèle OSI, mais contrairementà lui, il ne réalise pas de connexion préliminaire, de synchronisation et ne garantit pas labonne réception des données. Par contre, il intègre un système qui assure l’intégrité de ladonnée transmise, comme TCP.UDP est moins fiable que TCP, car il peut perdre des paquets, mais il est beaucoup plusrapide car il nécessite beaucoup moins d’allers-retours. Il est donc préférable pour des tech-nologies pour lesquelles la fiabilité n’est pas le principal besoin par rapport à la rapidité,comme la voix sur IP, le streaming ou les jeux en réseau.Ceci est vrai dans la mesure où les applications concernées sont capables soit de se passerd’une petite partie des données qui auraient été perdues, soit de les reconstruire (à partirdu moment où cela est plus rapide que les redemander), soit de les substituer.D’autre part, TCP est utilisé pour établir un dialogue entre un client et un serveur alorsqu’UDP est utilisé pour envoyer des données du client vers le serveur sans que le clientattende un retour.Là encore, on va utiliser les sockets, mais comme les protocoles TCP et UDP différent dansleur fonctionnement, cette différence est visible dans la manière d’écrire un serveur et unclient.Ainsi, le serveur n’attend pas de synchroniser une connexion avec un client et le client nese connecte pas au serveur avant de lui envoyer des données.En dehors de cela, la manière de traiter les données est identique à ce que l’on a vu pourTCP. Des exemples plus simples que ceux montrés dans cet ouvrage permettent de mettreen évidence les différences entre les protocoles TCP (http://wiki.python.org/moin/TcpCommunication) et UDP (http://wiki.python.org/moin/UdpCommunication). Dans
les deux cas, les serveurs affichent la donnée reçue et pour TCP, la donnée est égalementrenvoyée au client.L’exemple suivant est dans la lignée de celui pour TCP, le client donnant des informationsau serveur. Les lignes inutiles sont laissées en commentaire afin de mettre en évidence lesdifférences avec TCP.
#!/usr/bin/python3

import socket


donnees = {}

s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM) #SOCK_STREAMs.bind(params)# Les lignes suivantes n'ont pas de sens en UDP:#s.listen(1)#conn, addr = s.accept()#print('Connexion acceptée: %s' % str(addr))


Python 3

On voit clairement dans la première partie qu’il n’est pas nécessaire de se mettre à l’écouteet d’initier une connexion.Dans la partie qui suit, la différence de sémantique entre recv et recvfrom est révéla-trice du fait que la méthode recvfrom reçoit à la fois la donnée et l’adresse du client.

while True: #data = conn.recv(BUFFER_SIZE) data, addr = s.recvfrom(BUFFER_SIZE) print('Connexion reçue: %s' % str(addr)) print('Donnée reçue: %s' % data) if not data: break print('Donnée reçue: %s' % data) try: number = int(data) except: response = b'E' phrase = "'%s' n'est pas un entier" % data else: if isprime(number): phrase = "'%s' est un nombre premier" % number response = b'T' else: phrase = "'%s' n'est pas est un nombre premier" % number response = b'F' finally: print(response)

© E

diti

ons

ENI -

All

righ

ts r

eser

ved

#conn.close()À noter que si pour TCP il faut une boucle pour gérer chaque connexion et une autre pourgérer les échanges au sein de la connexion, en UDP une seule boucle suffit. Pour quel’exemple puisse se terminer proprement, il a été rajouté un cas d’utilisation particulierpermettant de sortir de la boucle.Voici la partie cliente correspondant :

#!/usr/bin/python3

import socketparams = ('127.0.0.1', 8808)BUFFER_SIZE = 1024 # default

s=socket.socket(socket.AF_INET, socket.SOCK_DGRAM)#s.connect(params)

Là encore, pas besoin de connexion. C’est au moment où l’on envoie les données que l’ondonne les informations sur le serveur à atteindre.

chiffres = [4j, 4, 5, -5, 17, 29, 2**50, 2**50-1]

Documents

Python 3 - fnac-static.com