Sébastien CHAZALLET Python 3 -...

Python 3 Les fondamentaux

du langage

Sébastien CHAZALLET

ISBN

: 97

8-2-

409-

0015

9-8

38,9

0 €

Ce livre sur les fondamentaux du langage Python 3 (en version 3.5 au moment de l’écriture) s’adresse à tout professionnel de l’informatique, ingénieur, étudiant (et particulièrement en BTS Services Informatiques Organisations), enseignant ou même autodidacte qui souhaite maîtriser ce langage très abouti. Il couvre un péri-mètre relativement large, détaille tout le cœur du langage et du traitement de données et ouvre des perspectives importantes sur tout ce que Python 3 permet de faire (de la création d’un site web au développement de jeux en passant par la conception d’une interface graphique avec Gtk). Le livre est consacré à la branche 3 de Python, et présente bien sûr les nouveautés apportées par la version 3.5. Toutefois, comme le langage Python 2 est encore très présent, lorsqu’elles existent, l’auteur présente les différences importantes avec la branche antérieure de Python.La première partie du livre détaille les atouts de Python 3 pour répondre aux be-soins des entreprises quel que soit le domaine informatique concerné. La seconde partie est un guide à destination des débutants, que ce soit en Python ou en développement en général, elle permet d’aborder en douceur les concepts clés autour de projets servant de fil rouge et propose la réalisation de quelques exercices.La troisième partie porte sur les fondamentaux du langage : les notions sont présentées progressivement avec des exemples de code qui illustrent chaque pro-pos. L’auteur a souhaité que le lecteur atteigne une autonomie réelle dans son ap-prentissage, avec pour chaque notion présentée deux objectifs distincts : permettre à celui qui ne connaît pas la notion de se l’approprier correctement, notamment en respectant son rôle, et permettre à celui qui la connaît de trouver des angles d’at-taques originaux pour aller le plus loin possible dans son exploitation.La quatrième partie permet de voir comment utiliser Python 3 pour résoudre des problématiques métiers et donc, comment utiliser tout ce qu’il y a autour de Py-thon 3 (protocoles, serveurs, images, …). Dans cette partie, le fil conducteur est la fonctionnalité et non pas le module ; chaque chapitre se concentre sur la manière d’exploiter une fonctionnalité par l’utilisation d’un ou de plusieurs modules et pré-sente une méthodologie, mais n’est pas centré sur une description anatomique des modules eux-mêmes. Les modules traités dans cette partie sont ceux qui ont été portés sous Python 3 ainsi que les fonctionnalités aujourd’hui matures pour cette dernière version du langage.Enfin, la dernière partie de l’ouvrage est un vaste tutoriel qui permet de mettre en pratique, dans un cadre professionnel, tout ce qui a été vu précédemment en créant une application qui couvre tous les domaines courants du développement (don-nées, Web avec Pyramid, interface graphique avec Gtk, script système...) et ainsi de présenter des solutions efficaces de développements utilisant Python 3.Le code source des parties 2, 4 et 5 est intégralement téléchargeable sur le site www.editions-eni.fr pour permettre au lecteur de tester le programme et de le modi-fier à sa guise de manière à faire ses propres expériences.

Sébastien CHAZALLETExpert technique Python / Django / Odoo et Web Backend / Frontend, Sébastien CHAZALLET intervient en tant qu’indépen-dant sur de longues missions de déve-loppement, d’audit, d’expertise et de formation (www.formation-python.com, www.inspyration.fr). Ses réalisations por-tent sur des développements autour de Python sur des projets de grande enver-gure, essentiellement des applications in-tranet sur mesure avec Django et sur Odoo (ex Open ERP), mais également sur des applications de bureau, des scripts systèmes, la création de sites web ou de e-commerce. A travers ce livre, il a su faire profiter le lecteur de sa parfaite maî-trise du langage Python dans sa dernière version et de l’expérience terrain acquise sur ses différentes missions.

Python 3 - Les fondamentaux du langage

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

sur www.editions-eni.fr : b Exemples de scripts de mise en œuvre

des dialogues client/serveur.b Exemples de programmes de création

de tâches et processus.b Code de certains exemples du livre.b Code des applications traitées dans la dernière partie.

Pyth

on 3

Les

fond

amen

taux

du

lang

age

Pour plus d’informations :

Avant-propos • Partie Les atouts de Python : Python dans le paysage informatique • Pré-sentation de Python • Pourquoi choisir Py-thon • Installer son environnement de tra-vail • Partie Guide Python : Les premiers pas • Fonctions et modules • Les principaux types • Les classes • Partie Les fondamen-taux du langage : Algorithmique de base • Déclarations • Modèle objet • Types de don-nées et algorithmes appliqués • Motifs de conception • Partie Les fonctionnalités : Manipulation de données • Génération de contenu • Programmation parallèle • Pro-grammation système et réseau • Program-mation asynchrone • Programmation scien-tifique • Bonnes pratiques • Partie Mise en pratique : Créer une application web en 30 minutes • Créer une application console en 10 minutes • Créer une application gra-phique en 20 minutes • Créer un jeu en 30 minutes avec PyGame • Annexes

Les chapitres du livre

2e édition

Nouvelle édition

1Table des matières

Avant-propos1. Contenu de l’ouvrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

2. Progressivité de l'ouvrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

3. À destination des enseignants et élèves . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

4. À destination des chercheurs ou doctorants . . . . . . . . . . . . . . . . . . . . . . . . . 34

5. À destination de ceux qui viennent d’un autre langage . . . . . . . . . . . . . . . . 35

Partie 1 : Les atouts de Python

Chapitre 1.1Python dans le paysage informatique

1. Petite histoire des langages informatiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 371.1 Informatique théorique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371.2 Chronologie de l’informatique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

1.2.1 Évolutions des problématiques liées à l’informatique . . . . . . . . 371.2.2 Chronologie des langages informatiques . . . . . . . . . . . . . . . . . . 39

1.3 Histoire de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431.3.1 La genèse. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431.3.2 Extension du périmètre fonctionnel. . . . . . . . . . . . . . . . . . . . . . 431.3.3 Évolution de la licence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441.3.4 Avenir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

2. Typologie des langages de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . 452.1 Paradigmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

2.1.1 Définition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452.1.2 Paradigme impératif et dérivés . . . . . . . . . . . . . . . . . . . . . . . . . . 462.1.3 Paradigme objet et dérivés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462.1.4 Programmation orientée aspect . . . . . . . . . . . . . . . . . . . . . . . . . 472.1.5 Paradigme fonctionnel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472.1.6 Paradigme logique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

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

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

2Les fondamentaux du langage

Python 3

2.1.7 Programmation concurrente . . . . . . . . . . . . . . . . . . . . . . . . . . . . 482.1.8 Synthèse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

2.2 Interopérabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 492.3 Niveau de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

2.3.1 Machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 502.3.2 Bas niveau. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 512.3.3 Haut niveau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

2.4 Typage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522.4.1 Faible vs fort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 522.4.2 Statique vs dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

2.5 Grammaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532.5.1 Langages formels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 532.5.2 Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

3. Python et le reste du monde . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543.1 Positionnement stratégique du langage Python . . . . . . . . . . . . . . . . . . 54

3.1.1 Segments de marchés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543.1.2 Niveau de complexité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 543.1.3 Forces du langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 553.1.4 Points faibles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

3.2 Intégration avec d’autres langages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563.2.1 Extensions C. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 563.2.2 Intégration de programmes écrits en C . . . . . . . . . . . . . . . . . . . 563.2.3 Intégration de programmes Python dans du C . . . . . . . . . . . . . 563.2.4 Intégration de programmes écrits en Java . . . . . . . . . . . . . . . . . 563.2.5 Intégration de programmes Python dans Java . . . . . . . . . . . . . . 563.2.6 Autres intégrations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

Chapitre 1.2Présentation de Python

1. Philosophie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591.1 Python en quelques lignes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

1.1.1 D’où vient le nom « Python » ? . . . . . . . . . . . . . . . . . . . . . . . . . . 591.1.2 Présentation technique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 591.1.3 Présentation conceptuelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

1.2 Comparaison avec d’autres langages . . . . . . . . . . . . . . . . . . . . . . . . . . . 601.2.1 Shell. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 601.2.2 Perl . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61


1.2.3 C, C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 611.2.4 Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 621.2.5 PHP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

1.3 Grands principes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 641.3.1 Le zen de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 641.3.2 Le développeur n’est pas stupide . . . . . . . . . . . . . . . . . . . . . . . . 651.3.3 Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661.3.4 Python est livré piles incluses . . . . . . . . . . . . . . . . . . . . . . . . . . . 661.3.5 Duck Typing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 661.3.6 Notion de code pythonique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66

2. Gouvernance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 672.1 Développement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

2.1.1 Branches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 672.1.2 Communauté. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

2.2 Mode de gouvernance. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 682.2.1 Créateur du langage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 682.2.2 PEP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 682.2.3 Prise de décisions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68

3. Que contient Python ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 693.1 Une grammaire et une syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 693.2 Plusieurs implémentations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 693.3 Une bibliothèque standard. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 703.4 Des bibliothèques tierces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 703.5 Des frameworks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

4. Phases d’exécution d’un programme Python. . . . . . . . . . . . . . . . . . . . . . . . . 704.1 Chargement de la machine virtuelle . . . . . . . . . . . . . . . . . . . . . . . . . . . 704.2 Compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 704.3 Interprétation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

Chapitre 1.3Pourquoi choisir Python

1. Qualités du langage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 731.1 Ticket d’entrée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 731.2 Qualités intrinsèques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 741.3 Couverture fonctionnelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 751.4 Domaines d’excellence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76


Python 3

1.5 Garanties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

2. Diffusion. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 782.1 Entreprises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 782.2 Le monde de la recherche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 792.3 Le monde de l’éducation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 802.4 Communauté . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

3. Références. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 823.1 Poids lourds de l’industrie informatique . . . . . . . . . . . . . . . . . . . . . . . . 82

3.1.1 Google . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 823.1.2 Mozilla . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 823.1.3 Microsoft . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 833.1.4 Canonical . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 833.1.5 Cisco . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

3.2 Entreprises innovantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 843.2.1 Services de stockage en ligne . . . . . . . . . . . . . . . . . . . . . . . . . . . . 843.2.2 Informatique dématérialisée . . . . . . . . . . . . . . . . . . . . . . . . . . . . 843.2.3 Forge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 843.2.4 Réseaux sociaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

3.3 Éditeurs de contenus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 853.3.1 Disney Animation Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 853.3.2 YouTube . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 853.3.3 Box ADSL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 853.3.4 Spotify . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

3.4 Éditeurs de logiciels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

4. Retours d’expérience . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 864.1 Internet des objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 864.2 Système et développement web. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 874.3 Enseignement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 874.4 Embarqué. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 884.5 Développement web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 894.6 ERP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89


Chapitre 1.4Installer son environnement de travail

1. Introduction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

2. Installer Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 912.1 Pour Windows. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 912.2 Pour Mac . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 942.3 Pour GNU/Linux et BSD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 942.4 Par la compilation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 952.5 Pour un smartphone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

3. Installer une bibliothèque tierce . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 963.1 À partir de Python 3.4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 963.2 Pour une version inférieure à Python 3.4 . . . . . . . . . . . . . . . . . . . . . . . 983.3 Pour Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

4. Créer un environnement virtuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 994.1 À quoi sert un environnement virtuel ? . . . . . . . . . . . . . . . . . . . . . . . . 994.2 Pour Python 3.3 ou version supérieure . . . . . . . . . . . . . . . . . . . . . . . . . 994.3 Pour toute version de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1004.4 Pour Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101

5. Installer Anaconda. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1025.1 Pour Windows. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1025.2 Pour Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1055.3 Pour Mac . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1055.4 Mettre à jour Anaconda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1065.5 Installer une bibliothèque externe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1065.6 Environnements virtuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106

6. La console Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1066.1 Démarrer la console Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1066.2 BPython. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1076.3 IPython . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1076.4 IPython Notebook . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

7. Installer un IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1087.1 Liste d'IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1087.2 Présentation de PyCharm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1097.3 Configuration de PyCharm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109


Python 3

Partie 2 : Guide Python

Chapitre 2.1Les premiers pas

1. Avant de commencer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1151.1 Quelques notions importantes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115

1.1.1 Comment fonctionne un ordinateur ? . . . . . . . . . . . . . . . . . . . 1151.1.2 Qu'est-ce qu’un programme informatique ? . . . . . . . . . . . . . . 1161.1.3 Qu'est-ce qu'un code source ? . . . . . . . . . . . . . . . . . . . . . . . . . . 116

1.2 Quelques conventions utilisées dans ce livre . . . . . . . . . . . . . . . . . . . 1161.2.1 Code Python. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1161.2.2 Terminal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1171.2.3 Mise en forme. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117

1.3 Quelle est la meilleure méthode pour apprendre ? . . . . . . . . . . . . . . . 118

2. Premier programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1182.1 Hello world ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1182.2 Affectation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1202.3 Valeur booléenne. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1212.4 Type . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1222.5 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1232.6 Bloc conditionnel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1262.7 Conditions avancées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1272.8 Bloc itératif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128

3. Premier jeu : Devine le nombre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1303.1 Description du jeu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1303.2 Aides. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130

3.2.1 Gestion du hasard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1303.2.2 Étapes de développement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130

3.3 Pour aller plus loin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131


Chapitre 2.2Fonctions et modules

1. Les fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1331.1 Pourquoi utiliser des fonctions ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1331.2 Introduction aux fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135

1.2.1 Comment déclarer une fonction. . . . . . . . . . . . . . . . . . . . . . . . 1351.2.2 Gestion d'un paramètre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1361.2.3 Comment rendre une fonction plus générique . . . . . . . . . . . . 1381.2.4 Paramètres par défaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140

1.3 Problématiques de couplage et duplication de code . . . . . . . . . . . . . . 1411.3.1 Niveau de ses fonctions. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1411.3.2 Notion de complexité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1431.3.3 Bonnes pratiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145

2. Les modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1462.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146

2.1.1 Qu'est-ce qu'un module ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1462.1.2 Comment crée-t-on un module Python ? . . . . . . . . . . . . . . . . 1472.1.3 Organiser son code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147

2.2 Gérer le code de ses modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1472.2.1 Exécuter un module, importer un module . . . . . . . . . . . . . . . . 1472.2.2 Gérer une arborescence de modules . . . . . . . . . . . . . . . . . . . . . 148

3. Terminer le jeu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1493.1 Créer des niveaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1493.2 Déterminer un nombre de coups maximal . . . . . . . . . . . . . . . . . . . . . 1503.3 Enregistrer les meilleurs scores. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1503.4 Intelligence artificielle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150

Chapitre 2.3Les principaux types

1. Chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1511.1 Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1511.2 Formatage d'une chaîne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1521.3 Notion de casse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1531.4 Notion de longueur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1531.5 Appartenance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1541.6 Notion d’occurrence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154


Python 3

1.7 Remplacement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1551.8 Notion de caractère. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1551.9 Typologie des caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1561.10 Séquencer une chaîne de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . 157

2. Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1582.1 Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1582.2 Indices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1582.3 Valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1592.4 Hasard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1602.5 Techniques d'itération . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1612.6 Tri. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163

3. Dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1653.1 Présentation des dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1653.2 Parcourir un dictionnaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1663.3 Exemple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166

Chapitre 2.4Les classes

1. Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169

2. Notion d'instance courante . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170

3. Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172

4. Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1744.1 Spécialisation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1744.2 Programmation par composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175

Partie 3 : Les fondamentaux du langage

Chapitre 3.1Algorithmique de base

1. Délimiteurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1771.1 Instruction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1771.2 Une ligne de code = une instruction . . . . . . . . . . . . . . . . . . . . . . . . . . 1771.3 Commentaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1781.4 Une instruction sur plusieurs lignes . . . . . . . . . . . . . . . . . . . . . . . . . . 1781.5 Mots-clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178


1.6 Mots réservés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1791.7 Indentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1801.8 Symboles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1811.9 Opérateurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1841.10 Utilisation du caractère souligné . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1871.11 PEP-8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1881.12 PEP-7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1881.13 PEP-257 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

2. Instructions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1882.1 Définitions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

2.1.1 Variable. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1882.1.2 Fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1902.1.3 Fonctions lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1912.1.4 Classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1922.1.5 Instruction vide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1932.1.6 Suppression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1932.1.7 Renvoyer le résultat de la fonction. . . . . . . . . . . . . . . . . . . . . . 194

2.2 Instructions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1952.2.1 Définition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1952.2.2 Condition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1952.2.3 Instruction if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1952.2.4 Instruction elif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1962.2.5 Instruction else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1962.2.6 Instruction switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1982.2.7 Interruptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1982.2.8 Approfondissement des conditions . . . . . . . . . . . . . . . . . . . . . 1982.2.9 Performances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199

2.3 Itérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2002.3.1 Instruction for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2002.3.2 Instruction while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2012.3.3 Quelle différence entre for et while ? . . . . . . . . . . . . . . . . . . . . 2012.3.4 Instruction break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2012.3.5 Instruction return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2032.3.6 Instruction continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2032.3.7 Instruction else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2042.3.8 Générateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205


Python 3

2.4 Constructions fonctionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2072.4.1 Construction conditionnelle . . . . . . . . . . . . . . . . . . . . . . . . . . . 2072.4.2 Générateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2082.4.3 Compréhensions de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2082.4.4 Compréhensions d’ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . 2082.4.5 Compréhensions de dictionnaires. . . . . . . . . . . . . . . . . . . . . . . 208

2.5 Gestion des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2082.5.1 Présentation rapide des exceptions . . . . . . . . . . . . . . . . . . . . . . 2082.5.2 Lever une exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2092.5.3 Pourquoi lever une exception ? . . . . . . . . . . . . . . . . . . . . . . . . . 2102.5.4 Assertions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2102.5.5 Capturer une exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2112.5.6 Effectuer un traitement de l’exception. . . . . . . . . . . . . . . . . . . 2122.5.7 Gérer la sortie du bloc de capture . . . . . . . . . . . . . . . . . . . . . . . 2142.5.8 Gérer le non-déclenchement d’exceptions . . . . . . . . . . . . . . . . 2142.5.9 Prise et libération de ressources. . . . . . . . . . . . . . . . . . . . . . . . . 2162.5.10 Programmation asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . 217

2.6 Divers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2182.6.1 Gérer des imports . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2182.6.2 Traverser les espaces de nommage . . . . . . . . . . . . . . . . . . . . . . 2192.6.3 Fonctions print, help, eval et exec . . . . . . . . . . . . . . . . . . . . . . 221

Chapitre 3.2Déclarations

1. Variable. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2231.1 Qu’est-ce qu’une variable ?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223

1.1.1 Contenu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2231.1.2 Contenant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2231.1.3 Modes de modification d’une variable . . . . . . . . . . . . . . . . . . . 225

1.2 Typage dynamique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2281.2.1 Affectation : rappels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2281.2.2 Primitive type et nature du type. . . . . . . . . . . . . . . . . . . . . . . . 2281.2.3 Caractéristiques du typage Python. . . . . . . . . . . . . . . . . . . . . . 229

1.3 Visibilité. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2311.3.1 Espace global. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2311.3.2 Notion de bloc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232


2. Fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2352.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2352.2 Paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236

2.2.1 Signature d’une fonction. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2362.2.2 Notion d’argument ou de paramètre . . . . . . . . . . . . . . . . . . . . 2372.2.3 Valeur par défaut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2372.2.4 Valeur par défaut mutable . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2392.2.5 Paramètres nommés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2402.2.6 Déclaration de paramètres extensibles . . . . . . . . . . . . . . . . . . . 2402.2.7 Passage de paramètres étoilés . . . . . . . . . . . . . . . . . . . . . . . . . . 2422.2.8 Signature universelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2422.2.9 Obliger un paramètre à être nommé (keyword-only) . . . . . . . 2432.2.10 Annotations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2452.2.11 Types hints . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248

3. Classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2493.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249

3.1.1 Signature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2493.1.2 Attribut . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2503.1.3 Méthode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2503.1.4 Bloc local . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251

3.2 Instanciation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2513.2.1 Syntaxe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2513.2.2 Relation entre l’instance et la classe. . . . . . . . . . . . . . . . . . . . . 252

4. Module . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2524.1 À quoi sert un module ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2524.2 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2534.3 Instructions spécifiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2534.4 Comment appréhender le contenu d’un module ? . . . . . . . . . . . . . . . 2544.5 Compilation des modules. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 255

Chapitre 3.3Modèle objet

1. Tout est objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2571.1 Principes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 257

1.1.1 Quel sens donner à « objet » ? . . . . . . . . . . . . . . . . . . . . . . . . . . 2571.1.2 Adaptation de la théorie objet dans Python . . . . . . . . . . . . . . 258


Python 3

1.1.3 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2591.2 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259

1.2.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2591.2.2 Déclaration impérative d’une classe . . . . . . . . . . . . . . . . . . . . . 2601.2.3 Instance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2601.2.4 Objet courant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2621.2.5 Déclaration par prototype d’une classe . . . . . . . . . . . . . . . . . . 2621.2.6 Tuples nommés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265

1.3 Méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2651.3.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2651.3.2 Appel de méthode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2671.3.3 Méthodes et attributs spéciaux. . . . . . . . . . . . . . . . . . . . . . . . . 2691.3.4 Constructeur et initialisateur . . . . . . . . . . . . . . . . . . . . . . . . . . 2731.3.5 Gestion automatisée des attributs . . . . . . . . . . . . . . . . . . . . . . 2741.3.6 Intérêt du paradigme objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2741.3.7 Relation entre objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275

1.4 Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2751.4.1 Polymorphisme par sous-typage . . . . . . . . . . . . . . . . . . . . . . . . 2751.4.2 Surcharge de méthode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2761.4.3 Surcharge des opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2781.4.4 Polymorphisme paramétrique . . . . . . . . . . . . . . . . . . . . . . . . . . 2791.4.5 Héritage multiple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281

2. Autres outils de la programmation objet . . . . . . . . . . . . . . . . . . . . . . . . . . . 2832.1 Principes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2832.2 Interfaces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2832.3 Attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2862.4 Propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2882.5 Emplacements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2902.6 Métaclasses . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2922.7 Classes abstraites. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2942.8 La Zope Component Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297

2.8.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2972.8.2 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2972.8.3 Définir une interface et un composant. . . . . . . . . . . . . . . . . . . 2982.8.4 Autres fonctionnalités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2992.8.5 Avantages de la ZCA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299


3. Fonctions spéciales et primitives associées . . . . . . . . . . . . . . . . . . . . . . . . . 2993.1 Personnalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 299

3.1.1 Classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2993.1.2 Instances. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3013.1.3 Comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3023.1.4 Évaluation booléenne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3023.1.5 Relations d’héritage ou de classe à instance. . . . . . . . . . . . . . . 303

3.2 Classes particulières . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3033.2.1 Itérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3033.2.2 Conteneurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3063.2.3 Instances assimilables à des fonctions . . . . . . . . . . . . . . . . . . . 3063.2.4 Ressources à protéger . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3073.2.5 Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308

Chapitre 3.4Types de données et algorithmes appliqués

1. Nombres. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3091.1 Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309

1.1.1 Entiers. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3091.1.2 Réels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3101.1.3 Socle commun aux nombres entiers et réels . . . . . . . . . . . . . . 3111.1.4 Méthodes dédiées aux nombres entiers . . . . . . . . . . . . . . . . . . 3121.1.5 Méthodes dédiées aux nombres réels . . . . . . . . . . . . . . . . . . . . 3131.1.6 Complexes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313

1.2 La console Python, la calculatrice par excellence . . . . . . . . . . . . . . . . 3141.2.1 Opérateurs mathématiques binaires . . . . . . . . . . . . . . . . . . . . 3141.2.2 Opérateurs binaires particuliers . . . . . . . . . . . . . . . . . . . . . . . . 3151.2.3 Opérateurs mathématiques unaires . . . . . . . . . . . . . . . . . . . . . 3161.2.4 Arrondis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3171.2.5 Opérateurs de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . . 3191.2.6 Opérations mathématiques n-aires . . . . . . . . . . . . . . . . . . . . . 3201.2.7 Fonctions mathématiques usuelles. . . . . . . . . . . . . . . . . . . . . . 321

1.3 Représentations d'un nombre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3271.3.1 Représentation décimale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3271.3.2 Représentation par un exposant. . . . . . . . . . . . . . . . . . . . . . . . 3271.3.3 Représentation par une fraction . . . . . . . . . . . . . . . . . . . . . . . . 3271.3.4 Représentation hexadécimale . . . . . . . . . . . . . . . . . . . . . . . . . . 328


Python 3

1.3.5 Représentation octale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3291.3.6 Représentation binaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3301.3.7 Opérations binaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3301.3.8 Longueur de la représentation mémoire d'un entier . . . . . . . . 332

1.4 Conversions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3331.4.1 Conversion entre entiers et réels . . . . . . . . . . . . . . . . . . . . . . . 3331.4.2 Conversion entre réels et complexes . . . . . . . . . . . . . . . . . . . . 3331.4.3 Conversion vers un booléen . . . . . . . . . . . . . . . . . . . . . . . . . . . 334

1.5 Travailler avec des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3351.5.1 Un nombre est non mutable . . . . . . . . . . . . . . . . . . . . . . . . . . . 3351.5.2 Modifier la valeur d'une variable . . . . . . . . . . . . . . . . . . . . . . . 3351.5.3 Opérateurs d'incrémentation . . . . . . . . . . . . . . . . . . . . . . . . . . 336

1.6 Statistiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337

2. Séquences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3382.1 Présentation des différents types de séquences. . . . . . . . . . . . . . . . . . 338

2.1.1 Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3382.1.2 Les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3392.1.3 Les n-uplets. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3402.1.4 Conversion entre listes et n-uplets . . . . . . . . . . . . . . . . . . . . . 3422.1.5 Socle commun entre liste et n-uplet . . . . . . . . . . . . . . . . . . . . 3422.1.6 Notion d’itérateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343

2.2 Utilisation des indices et des tranches. . . . . . . . . . . . . . . . . . . . . . . . . 3452.2.1 Définition de l’indice d’un objet et des occurrences . . . . . . . . 3452.2.2 Utiliser l’indice pour adresser la séquence . . . . . . . . . . . . . . . . 3462.2.3 Retrouver les occurrences d’un objet et leurs indices . . . . . . . 3472.2.4 Taille d’une liste, comptage d’occurrences . . . . . . . . . . . . . . . . 3492.2.5 Utiliser l’indice pour modifier ou supprimer . . . . . . . . . . . . . . 3502.2.6 Itération simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3522.2.7 Présentation de la notion de tranches (slices) . . . . . . . . . . . . . 3552.2.8 Cas particulier de la branche 2.x de Python . . . . . . . . . . . . . . . 3632.2.9 Utilisation basique des tranches . . . . . . . . . . . . . . . . . . . . . . . . 3642.2.10 Utilisation avancée des tranches. . . . . . . . . . . . . . . . . . . . . . . . 365

2.3 Utilisation des opérateurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3682.3.1 Opérateur + . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3682.3.2 Opérateur *. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3692.3.3 Opérateur += . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3712.3.4 Opérateur *= . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372


2.3.5 Opérateur in. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3732.3.6 Opérateurs de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . . 374

2.4 Méthodes de modifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3752.4.1 Ajouter des éléments dans une liste et un n-uplet . . . . . . . . . 3752.4.2 Supprimer un objet d’une liste et d’un n-uplet . . . . . . . . . . . 3782.4.3 Solutions de contournement pour la modification

de n-uplets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3812.4.4 Renverser une liste ou un tuple . . . . . . . . . . . . . . . . . . . . . . . . 3822.4.5 Trier une liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383

2.5 Utilisation avancée des listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3862.5.1 Opérations d'ensemble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3862.5.2 Pivoter une séquence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3872.5.3 Itérer correctement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3882.5.4 Programmation fonctionnelle . . . . . . . . . . . . . . . . . . . . . . . . . . 3892.5.5 Compréhensions de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3912.5.6 Itérations avancées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3922.5.7 Combinatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 397

2.6 Adapter les listes à des besoins spécifiques . . . . . . . . . . . . . . . . . . . . 3992.6.1 Liste d'entiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3992.6.2 Présentation du type array . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4012.6.3 Utiliser une liste comme pile . . . . . . . . . . . . . . . . . . . . . . . . . . 4032.6.4 Utiliser une liste comme file d'attente . . . . . . . . . . . . . . . . . . . 4032.6.5 Conteneur plus performant . . . . . . . . . . . . . . . . . . . . . . . . . . . 4042.6.6 Utiliser des listes pour représenter des matrices . . . . . . . . . . . 4052.6.7 Liste sans doublons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 406

2.7 Autres types de données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408

3. Ensembles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4103.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 410

3.1.1 Définition d’un ensemble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4103.1.2 Différences entre set et frozenset . . . . . . . . . . . . . . . . . . . . . . . 4123.1.3 Utilisation pour dédoublonner des listes . . . . . . . . . . . . . . . . . 4123.1.4 Rajouter une relation d’ordre . . . . . . . . . . . . . . . . . . . . . . . . . . 413

3.2 Opérations ensemblistes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4133.2.1 Opérateurs pour un ensemble à partir de deux autres . . . . . . 4133.2.2 Opérateurs pour modifier un ensemble à partir d’un autre . . 4143.2.3 Méthodes équivalentes à la création

ou modification ensembliste. . . . . . . . . . . . . . . . . . . . . . . . . . . 415


Python 3

3.2.4 Méthodes de comparaison des ensembles . . . . . . . . . . . . . . . . 4153.2.5 Exemples non classiques d’utilisation. . . . . . . . . . . . . . . . . . . . 417

3.3 Méthodes de modification d’un ensemble . . . . . . . . . . . . . . . . . . . . . 4203.3.1 Ajouter un élément . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4203.3.2 Supprimer un élément . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4213.3.3 Vider un ensemble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4213.3.4 Dupliquer un élément . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4213.3.5 Sortir une valeur d’un ensemble . . . . . . . . . . . . . . . . . . . . . . . 4223.3.6 Utiliser un ensemble comme un recycleur d’objets . . . . . . . . . 4233.3.7 Algorithmique avancée : résolution du problème

des n-dames . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426

4. Chaînes de caractères. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4284.1 Présentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428

4.1.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4284.1.2 Vocabulaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4294.1.3 Spécificités de la branche 2.x. . . . . . . . . . . . . . . . . . . . . . . . . . . 4304.1.4 Changements apportés par la branche 3.x . . . . . . . . . . . . . . . . 4314.1.5 Chaîne de caractères en tant que séquence de caractères . . . . 4334.1.6 Caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4354.1.7 Opérateurs de comparaison. . . . . . . . . . . . . . . . . . . . . . . . . . . . 436

4.2 Formatage de chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . 4384.2.1 Opérateur modulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4384.2.2 Méthodes de formatage sur l’ensemble de la chaîne . . . . . . . . 4434.2.3 Nouvelle méthode de formatage des variables

dans une chaîne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4464.3 Opérations d'ensemble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449

4.3.1 Séquençage de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4494.3.2 Opérations sur la casse . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4514.3.3 Recherche sur une chaîne de caractères . . . . . . . . . . . . . . . . . . 4524.3.4 Informations sur les caractères . . . . . . . . . . . . . . . . . . . . . . . . . 453

4.4 Problématiques relatives à l'encodage . . . . . . . . . . . . . . . . . . . . . . . . . 4554.4.1 Encodage par défaut. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4554.4.2 Encodage du système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4554.4.3 L'unicode, référence absolue . . . . . . . . . . . . . . . . . . . . . . . . . . . 4554.4.4 Autres encodages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4564.4.5 Ponts entre l'unicode et le reste du monde. . . . . . . . . . . . . . . . 4574.4.6 Revenir vers l'Unicode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 458


4.5 Manipulations de bas niveau avancées . . . . . . . . . . . . . . . . . . . . . . . . 4594.5.1 Opérations de comptage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4594.5.2 Une chaîne de caractères vue comme une liste . . . . . . . . . . . . 4604.5.3 Une chaîne de caractères vue

comme un ensemble de caractères . . . . . . . . . . . . . . . . . . . . . . 4604.6 Représentation mémoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461

4.6.1 Présentation du type bytes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4614.6.2 Lien avec les chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . 4624.6.3 Présentation du type bytearray . . . . . . . . . . . . . . . . . . . . . . . . 4634.6.4 Gestion d’un jeu de caractères . . . . . . . . . . . . . . . . . . . . . . . . . 465

5. Dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4705.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 470

5.1.1 Définition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4705.1.2 Évolutions et différences entre les branches 2.x et 3.x . . . . . . 4715.1.3 Vues de dictionnaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4725.1.4 Instanciation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4745.1.5 Compréhension de dictionnaire . . . . . . . . . . . . . . . . . . . . . . . . 474

5.2 Manipuler un dictionnaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4755.2.1 Récupérer une valeur d’un dictionnaire . . . . . . . . . . . . . . . . . . 4755.2.2 Modifier les valeurs d’un dictionnaire . . . . . . . . . . . . . . . . . . . 4765.2.3 Supprimer une entrée d’un dictionnaire . . . . . . . . . . . . . . . . . 4775.2.4 Dupliquer un dictionnaire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4775.2.5 Utiliser le dictionnaire comme agrégateur de données . . . . . . 4785.2.6 Méthodes d’itération . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 479

5.3 Utilisation avancée des dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . 4795.3.1 Rajouter une relation d'ordre . . . . . . . . . . . . . . . . . . . . . . . . . . 4795.3.2 Algorithmiques classiques. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4835.3.3 Adapter les dictionnaires à des besoins spécifiques . . . . . . . . . 4855.3.4 Représentation universelle de données . . . . . . . . . . . . . . . . . . 487

6. Booléens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4886.1 Le type booléen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 488

6.1.1 Classe bool . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4886.1.2 Les deux objets True et False . . . . . . . . . . . . . . . . . . . . . . . . . . 4896.1.3 Différence entre l’opérateur d’égalité et d'identité . . . . . . . . . 489

6.2 Évaluation booléenne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4896.2.1 Méthode générique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4896.2.2 Objets classiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489


Python 3

7. Données temporelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4907.1 Gérer une date calendaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 490

7.1.1 Notion de date calendaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4907.1.2 Travailler sur une date . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4917.1.3 Considérations astronomiques . . . . . . . . . . . . . . . . . . . . . . . . . 4927.1.4 Considérations historiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4927.1.5 Considérations techniques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4927.1.6 Représentation textuelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 493

7.2 Gérer un horaire ou un moment d’une journée . . . . . . . . . . . . . . . . . 4957.2.1 Notion d’instant. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4957.2.2 Notion de fuseau horaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4967.2.3 Représentation textuelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 496

7.3 Gérer un instant absolu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4977.3.1 Notion d’instant absolu. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4977.3.2 Rapport avec les notions précédentes. . . . . . . . . . . . . . . . . . . . 4987.3.3 Représentation textuelle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4997.3.4 Gestion des fuseaux horaires . . . . . . . . . . . . . . . . . . . . . . . . . . . 5007.3.5 Créer une date à partir d’une représentation textuelle . . . . . . 500

7.4 Gérer une différence entre deux dates ou instants . . . . . . . . . . . . . . . 5007.4.1 Notion de différence et de résolution . . . . . . . . . . . . . . . . . . . . 5007.4.2 Considérations techniques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5027.4.3 Utilisation avec des dates calendaires . . . . . . . . . . . . . . . . . . . 5037.4.4 Utilisation avec des horaires . . . . . . . . . . . . . . . . . . . . . . . . . . . 5037.4.5 Utilisation avec des dates absolues . . . . . . . . . . . . . . . . . . . . . . 5037.4.6 La seconde comme unité de base . . . . . . . . . . . . . . . . . . . . . . . 503

7.5 Spécificités des fuseaux horaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5047.6 Problématiques de bas niveau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505

7.6.1 Timestamp et struct_time . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5057.6.2 Mesures de performances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506

7.7 Utilisation du calendrier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5087.7.1 Présentation du module calendar . . . . . . . . . . . . . . . . . . . . . . . 5087.7.2 Fonctions essentielles du calendrier . . . . . . . . . . . . . . . . . . . . . 512


Chapitre 3.5Motifs de conception

1. Définition. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5151.1 Positionnement par rapport à la notion d’objet . . . . . . . . . . . . . . . . . 5151.2 Organisation du chapitre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5161.3 Positionnement par rapport à d’autres concepts . . . . . . . . . . . . . . . . 516

2. Motifs de création . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5172.1 Singleton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5172.2 Fabrique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5172.3 Fabrique abstraite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5202.4 Monteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5212.5 Prototype. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 523

3. Motifs de structuration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5263.1 Adaptateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5263.2 Pont . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5293.3 Composite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5323.4 Décorateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5343.5 Façade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5363.6 Poids-mouche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5383.7 Proxy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 540

4. Motifs de comportement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5424.1 Chaîne de responsabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5424.2 Commande . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5434.3 Itérateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5454.4 Mémento. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5474.5 Visiteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5484.6 Observateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5494.7 Stratégie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5514.8 Fonction de rappel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 552

5. ZCA . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5535.1 Rappels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5535.2 Adaptateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5535.3 Utilitaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5555.4 Fabrique. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5565.5 Pour aller plus loin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 557


Python 3

Partie 4 : Les fonctionnalités

Chapitre 4.1Manipulation de données

1. Bases de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5591.1 Présentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5591.2 Accès à une base de données relationnelle. . . . . . . . . . . . . . . . . . . . . . 559

1.2.1 Point d’entrée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5591.2.2 MySQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5601.2.3 PostgreSQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5641.2.4 SQLite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5671.2.5 Oracle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 567

1.3 Utilisation d’un ORM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5681.3.1 Qu’est-ce qu’un ORM ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5681.3.2 ORM proposés par Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5681.3.3 SQLAlchemy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 568

1.4 Autres bases de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5751.4.1 CSV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5751.4.2 NoSQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5811.4.3 Base de données orientée objet : ZODB . . . . . . . . . . . . . . . . . . 5811.4.4 Base de données de type clé-valeur : Redis . . . . . . . . . . . . . . . . 5861.4.5 Bases de données orientées documents :

CouchDB et MongoDB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5871.4.6 Bases de données natives XML : BaseX, eXist. . . . . . . . . . . . . 5881.4.7 Cassandra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5891.4.8 Bases de données orientées colonnes : HBase. . . . . . . . . . . . . . 5901.4.9 Big Data : l'écosystème Hadoop . . . . . . . . . . . . . . . . . . . . . . . . 591

2. LDAP. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5942.1 Présentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594

2.1.1 Protocole . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5942.1.2 Serveurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5942.1.3 Terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 594

2.2 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5952.3 Ouvrir une connexion à un serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . 5952.4 Effectuer une recherche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5962.5 Synchrone vs asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 597


2.6 Connexions sécurisées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 598

3. XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5993.1 XML et les technologies qui gravitent autour . . . . . . . . . . . . . . . . . . 599

3.1.1 Définition de XML, terminologie associée . . . . . . . . . . . . . . . . 5993.1.2 Notion de schéma . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6003.1.3 Avantages et inconvénients de XML . . . . . . . . . . . . . . . . . . . . 6013.1.4 Différentes manières de parcourir un fichier XML . . . . . . . . . 6023.1.5 Modules Python dédiés au XML. . . . . . . . . . . . . . . . . . . . . . . . 602

3.2 Valider un document XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6033.2.1 Document XML. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6033.2.2 Schéma DTD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6043.2.3 Schéma XSD . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6043.2.4 Schéma RNG (RelaxNG). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6053.2.5 Schematron . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 605

3.3 DOM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6063.3.1 Lecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6063.3.2 Écriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 607

3.4 SAX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6083.4.1 Support de SAX dans lxml . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6083.4.2 API SAX Allégée. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 609

3.5 XPath . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6103.6 XSLT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6123.7 Cas spécifique des fichiers HTML . . . . . . . . . . . . . . . . . . . . . . . . . . . . 613

3.7.1 Problématique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6133.7.2 Parser un fichier HTML à la façon DOM. . . . . . . . . . . . . . . . . 6143.7.3 Parser un fichier HTML à la façon SAX . . . . . . . . . . . . . . . . . . 615

4. Outils de manipulation de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6164.1 Encrypter une donnée. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 616

4.1.1 Fonctions de hachage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6164.1.2 Code d’authentification de message. . . . . . . . . . . . . . . . . . . . . 6184.1.3 Stéganographie. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 620

4.2 Générer des nombres aléatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6234.3 Expressions régulières . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 624

5. Travailler avec des images. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6285.1 Représentation informatique d’une image . . . . . . . . . . . . . . . . . . . . . 6285.2 Présentation de Pillow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 629


Python 3

5.3 Formats d’images matricielles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6305.4 Récupérer des informations d’une image . . . . . . . . . . . . . . . . . . . . . . 6315.5 Opérations d’ensemble sur une image. . . . . . . . . . . . . . . . . . . . . . . . . 6335.6 Travailler avec les calques ou les pixels . . . . . . . . . . . . . . . . . . . . . . . . 635

Chapitre 4.2Génération de contenu

1. PDF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6391.1 Présentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 639

1.1.1 Format PDF . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6391.1.2 Avantages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6391.1.3 Inconvénients. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6391.1.4 Présentation de la bibliothèque libre. . . . . . . . . . . . . . . . . . . . . 640

1.2 Bas niveau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6401.2.1 Bibliothèque de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6401.2.2 Canvas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 642

1.3 Haut niveau. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6431.3.1 Styles. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6431.3.2 Flux de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6451.3.3 Création d’un visuel. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6471.3.4 Template de page . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6471.3.5 Page contenant plusieurs zones . . . . . . . . . . . . . . . . . . . . . . . . 648

2. OpenDocument . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6502.1 Présentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6502.2 ezodf2. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 651

2.2.1 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6512.2.2 OpenDocument Texte. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6512.2.3 OpenDocument Tableur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6512.2.4 Aller plus loin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 652

2.3 Alternatives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6522.3.1 lpod . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6522.3.2 Génération à partir de templates . . . . . . . . . . . . . . . . . . . . . . . 653


Chapitre 4.3Programmation parallèle

1. Terminologie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6551.1 Processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6551.2 Tâche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 656

2. Utilisation d’une tâche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6562.1 Gestion d’une tâche . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 656

2.1.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6562.1.2 Création . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 656

2.2 Gestion de plusieurs tâches . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6592.2.1 Lancement et contrôle. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6592.2.2 Opportunité d’utiliser une tâche . . . . . . . . . . . . . . . . . . . . . . . 661

2.3 Résolution des problématiques liées . . . . . . . . . . . . . . . . . . . . . . . . . . 6632.3.1 Synchronisation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6632.3.2 Synchronisation conditionnelle . . . . . . . . . . . . . . . . . . . . . . . . 6652.3.3 Sémaphore . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 668

3. Utilisation de processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6693.1 Gestion d’un processus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669

3.1.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6693.1.2 Création . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 669

3.2 Gestion de plusieurs processus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6723.2.1 Synchronisation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6723.2.2 Paralléliser un travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 672

3.3 Résolution des problématiques liées . . . . . . . . . . . . . . . . . . . . . . . . . . 6743.3.1 Communication interprocessus . . . . . . . . . . . . . . . . . . . . . . . . 6743.3.2 Partage de données entre processus . . . . . . . . . . . . . . . . . . . . . 676

3.4 Opportunité d’utiliser les processus . . . . . . . . . . . . . . . . . . . . . . . . . . 6773.5 Démon. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 677

4. Exécution asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6794.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6794.2 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 680


Python 3

Chapitre 4.4Programmation système et réseau

1. Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6871.1 Définition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6871.2 Objectifs du chapitre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 688

2. Écrire des scripts système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6882.1 Appréhender son système d’exploitation . . . . . . . . . . . . . . . . . . . . . . 688

2.1.1 Avertissement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6882.1.2 Système d’exploitation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6882.1.3 Processus courant. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6892.1.4 Utilisateurs et groupes. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6902.1.5 Constantes pour le système de fichiers . . . . . . . . . . . . . . . . . . 6922.1.6 Gérer les chemins . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 692

2.2 Gestion d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6932.2.1 Ouvrir un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6932.2.2 Lire un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6942.2.3 Écrire un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6952.2.4 Changer les droits d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . . 6962.2.5 Changer de propriétaire ou de groupe . . . . . . . . . . . . . . . . . . . 6972.2.6 Récupérer des informations sur un fichier . . . . . . . . . . . . . . . . 6982.2.7 Supprimer un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 699

2.3 Alternatives simples à des commandes bash usuelles. . . . . . . . . . . . . 6992.3.1 Répertoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6992.3.2 Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7022.3.3 Module de haut niveau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7032.3.4 Recherche d’un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 705

2.4 Exécuter des commandes externes. . . . . . . . . . . . . . . . . . . . . . . . . . . . 7052.4.1 Exécuter et afficher le résultat. . . . . . . . . . . . . . . . . . . . . . . . . . 7052.4.2 Exécuter et récupérer le résultat . . . . . . . . . . . . . . . . . . . . . . . . 7062.4.3 Pour Python 3.5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 707

2.5 Utilitaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7072.5.1 Comparer deux fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7072.5.2 Utilitaire de sauvegarde . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7092.5.3 Lire un fichier de configuration. . . . . . . . . . . . . . . . . . . . . . . . . 7102.5.4 Pickle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 711


2.6 Compresser et décompresser un fichier. . . . . . . . . . . . . . . . . . . . . . . . 7132.6.1 Tarfile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7132.6.2 Gzip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7152.6.3 Bz2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7162.6.4 Zipfile . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7162.6.5 Interface de haut niveau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 718

3. Travailler avec des arguments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7193.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7193.2 Mise en œuvre. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 720

4. Programmation réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7234.1 Écrire un serveur et un client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 723

4.1.1 Utilisation d’une socket TCP . . . . . . . . . . . . . . . . . . . . . . . . . . 7234.1.2 Utilisation d’une socket UDP . . . . . . . . . . . . . . . . . . . . . . . . . . 7264.1.3 Création d’un serveur TCP . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7294.1.4 Création d’un serveur UDP. . . . . . . . . . . . . . . . . . . . . . . . . . . . 7314.1.5 Un peu plus loin sur le sujet . . . . . . . . . . . . . . . . . . . . . . . . . . . 731

4.2 Utiliser un protocole standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7334.2.1 HTTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7334.2.2 Proxy. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7374.2.3 Cookies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7384.2.4 FTP et SFTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7384.2.5 SSH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7404.2.6 POP et POPS. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7424.2.7 IMAP et IMAPS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7434.2.8 SMTP et SMPTS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7444.2.9 NNTP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7484.2.10 IRC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 749

4.3 Services web . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7524.3.1 REST. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7524.3.2 SOAP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7534.3.3 Pyro. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 755

5. Utilisation du matériel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7565.1 Wake-on-LAN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 756

5.1.1 Prérequis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7565.1.2 Mise en œuvre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 756

5.2 Utilisation du port série . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 757


Python 3

Chapitre 4.5Programmation asynchrone

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

2. Exemple de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 760

3. Exemple retravaillé en utilisant des générateurs . . . . . . . . . . . . . . . . . . . . . 762

4. Exemple retravaillé en asynchrone pour Python 3.4 . . . . . . . . . . . . . . . . . . 763

5. Exemple retravaillé en asynchrone pour Python 3.5 . . . . . . . . . . . . . . . . . . 765

6. Pour aller plus loin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 766

Chapitre 4.6Programmation scientifique

1. Calcul scientifique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7691.1 Présentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7691.2 Python, une alternative libre et crédible . . . . . . . . . . . . . . . . . . . . . . . 7691.3 Vue d'ensemble de quelques bibliothèques . . . . . . . . . . . . . . . . . . . . . 770

2. Tableaux multidimensionnels. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7712.1 Création . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7712.2 Déterminer la composition d'un tableau . . . . . . . . . . . . . . . . . . . . . . . 7722.3 Générateurs de tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7732.4 Opérations basiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7742.5 Opérateur crochet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 776

3. Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 778

4. Génération de graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7794.1 Syntaxe MATLAB. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7804.2 Syntaxe objet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7814.3 Mise en forme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7814.4 Graphiques 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 786


Chapitre 4.7Bonnes pratiques

1. Programmation dirigée par les tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7911.1 Tests unitaires. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 791

1.1.1 Principes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7911.1.2 Interprétation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7921.1.3 Couverture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7931.1.4 Outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7931.1.5 Autres outils. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 795

1.2 Tests de non-régression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7951.2.1 Actions de développement . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7951.2.2 Gestion de la découverte d’une anomalie par une MOA . . . . 796

1.3 Tests fonctionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7971.4 Tests de performance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7981.5 Intégration continue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 800

2. Programmation dirigée par la documentation. . . . . . . . . . . . . . . . . . . . . . . 8012.1 Documentation interne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 801

2.1.1 À destination des développeurs . . . . . . . . . . . . . . . . . . . . . . . . 8012.1.2 À destination des utilisateurs . . . . . . . . . . . . . . . . . . . . . . . . . . 801

2.2 Documentation externe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8022.2.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8022.2.2 Démarrage rapide. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8022.2.3 Résultat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 805

3. Optimisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8053.1 Qualimétrie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8053.2 Outils de débogage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8073.3 Outils de profilage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8073.4 Règles d’optimisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 808

3.4.1 Pourquoi optimiser ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8083.4.2 Règles générales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8093.4.3 Profiler un algorithme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8103.4.4 Optimiser l'utilisation de la mémoire. . . . . . . . . . . . . . . . . . . . 820


Python 3

Partie 5 : Mise en pratique

Chapitre 5.1Créer une application web en 30 minutes

1. Description de l’application à construire . . . . . . . . . . . . . . . . . . . . . . . . . . . 823

2. Mise en place . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8242.1 Isolation de l’environnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8242.2 Création du projet. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8252.3 Paramétrage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8252.4 Premiers essais . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 826

3. Réalisation de l’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8273.1 Modèles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8273.2 Vues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8303.3 Contrôleurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 831

4. Pour aller plus loin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 835

Chapitre 5.2Créer une application console en 10 minutes

1. Objectif. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 837

2. Enregistrer le script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 837

3. Création des données. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 838

4. Parseur d’arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 839

Chapitre 5.3Créer une application graphique en 20 minutes

1. Objectif. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8411.1 Fonctionnel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8411.2 Technique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 841

2. Présentation rapide de Gtk et d’astuces . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8422.1 Présentation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8422.2 Astuces. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 842

3. Démarrer le programme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 843

4. Interface graphique avec Glade . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 845

5. Créer le composant graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 848


6. Contrôleur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 850

7. Autres bibliothèques graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8517.1 TkInter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8517.2 wxPython . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8517.3 PyQt. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8517.4 PySide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8527.5 Autres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 852

Chapitre 5.4Créer un jeu en 30 minutes avec PyGame

1. Présentation de PyGame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 853

2. Réalisation d’un jeu Tetris . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8542.1 Présentation du jeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8542.2 Présentation des problématiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8552.3 Création des constantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 855

Annexes1. Objets mutables et non mutables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 867

2. Table Unicode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8692.1 Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 869

3. Bytes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8693.1 Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8693.2 Résultat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 869

4. Guide de portage vers Python 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 872

Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 875

687

Chapitre 4.4

Programmation système et réseau

Programmation système et réseau1. Présentation

1.1 DéfinitionLa programmation système se définit par opposition à la programmation d’applications. Ilne s’agit pas de concevoir un logiciel qui va utiliser le système et ses ressources pour effec-tuer une action, mais de concevoir une des briques qui va s’intégrer au système lui-même.Cela peut donc être le développement d’un pilote pour un matériel, d’une interface réseauou encore la gestion des ressources.Par extension, la création d’un programme qui utilise d’autres programmes systèmes estde la programmation système. Le terme programmation système s’étend alors à tout cequi peut permettre à un administrateur système de résoudre les problématiques usuellesconcernant son domaine de compétence, à savoir la gestion des utilisateurs, des périphé-riques, des processus, de la sauvegarde…Ainsi, par extension, l’utilisation des commandes bash est de la programmation système.L’utilisation des commandes mysql et mysqldump pour opérer des actions de sauvegardequotidiennes l’est également.Un système d’exploitation moderne est écrit majoritairement en C, le reste étant del’assembleur spécifique à la machine. Ce même système d’exploitation – moderne – a desfonctionnalités de haut niveau, telles que le gestionnaire de paquets qui a besoin parexemple d’effectuer des opérations diverses telles que des échanges réseau pour téléchargerdes paquets, vérifier leur intégrité, les ouvrir, les installer.Celles-ci sont le plus souvent écrites en Python, parce qu’il est un langage facile à manipu-ler, efficace, complet et surtout fiable, disposant de l’outillage nécessaire.

© E

dit

ions

EN

I -

All r

ights

rese

rved


Python 3

1.2 Objectifs du chapitreDans ce chapitre sont présentés les moyens mis à disposition par Python pour permettred’exécuter des commandes système de manière à effectuer des opérations de maintenance,l’utilisation du système de fichiers, les moyens permettant à Python d’être une alternativecrédible à Bash, en particulier par le traitement du passage d’arguments.Les problématiques liées à la gestion des protocoles réseau, souvent associées à de la pro-grammation système, sont également présentées, et orientées vers la communicationentre différents types de clients et de serveurs et différentes technologies. Cela couvre éga-lement les services web.La gestion des tâches et processus à haut niveau est également une problématique faisantpartie de la programmation système. Mais étant de haut niveau, elle est utilisée beaucoupplus pour des applications qu’en tant qu’élément de programmation système pure. C’estla raison pour laquelle cette partie est traitée dans un chapitre dédié, le chapitre Program-mation parallèle.

2. Écrire des scripts système

2.1 Appréhender son système d’exploitation

2.1.1 AvertissementL’exécution de commandes externes est intimement liée au système sur lequel se trouveinstallé Python. D’une part, chaque système d’exploitation possède ses propres com-mandes. Par exemple, pour lister un répertoire, on utilisera ls ou dir.Cette section traite principalement les commandes Unix.Au-delà des commandes système classiques, certaines commandes comme mysql oumysqldump ne peuvent être utilisées que si les programmes adéquats ont été installés,quel que soit le système.

2.1.2 Système d’exploitationPython propose un module de bas niveau permettant de gérer des informations sur le sys-tème d’exploitation :

>>> import os

Voici les deux principaux moyens de vérifier la nature du système :>>> os.name'posix'>>> os.uname()('Linux', 'nom_donne_au_host', '2.6.38-11-generic', '#50-Ubuntu SMP Mon Sep 12 21:17:25 UTC 2011', 'x86_64')

La première commande donne une standardisation de l’environnement et la seconde desdétails sur le nom du système d’exploitation, de la machine, le nom du noyau et sa versionainsi que l’architecture de la machine. Tester ces valeurs permet d'effectuer des choix etd’adapter une application à un environnement précis pour certaines opérations qui lenécessitent.

689Programmation système et réseauChapitre 4.4

Voici comment trouver la liste des variables d’environnement :>>> list(os.environ.keys())

Et voici comment aller chercher la valeur d’une de ces variables :>>> os.getenv('LANGUAGE')'fr_FR:fr'

L’exploitation de ces variables d’environnement permet également de diriger des choixpermettant l’adaptation de l’application. Dans le cas qui vient d’être vu, le choix de lalocale peut servir à produire une interface adaptée au langage de l’utilisateur. Il est possiblede lire les variables d'environnement sous forme d'octets avec os.environb (utilelorsque Python est unicode, mais pas le système).Python permet également de modifier ces variables d’environnement à l’aide de laméthode putenv. L’environnement est alors affecté dans tous les sous-processus.

2.1.3 Processus courantPython permet d’obtenir des informations sur le processus courant. Ces fonctionnalités nesont disponibles que pour Linux.La principale d’entre elles est l’identifiant du processus courant et celui du parent :

>>> os.getpid()5256>>> os.getppid()3293

Le parent peut correspondre à l’identifiant d’un processus Python père ou à celui de laconsole lorsque Python est lancé en mode console depuis la console.Il peut récupérer l’utilisateur affecté au processus et l’utilisateur effectif :

>>> os.getuid()1000>>> os.geteuid()1000

On peut également avoir des informations textuelles :>>> os.getlogin()'sch'

Et des informations sur les groupes rattachés au processus :>>> os.getgroups()[4, 20, 24, 46, 112, 120, 122, 1000]

Ainsi que sur le 3-uplet (utilisateur courant, effectif, sauvegardé) :>>> os.getresuid()(1000, 1000, 1000)

Voici le 3-uplet des groupes associés (courant, effectif, sauvegardé) :>>> os.getresgid()(1000, 1000, 1000)

© E

dit

ions

EN

I -

All r

ights

rese

rved


Python 3

L’identifiant 0 est celui de root, 1000 celui du premier utilisateur créé (lors de l’installationdu système) pour Unix.Si l’on ne veut pas que l'application puisse être lancée par root, on peut faire :

>>> if os.getuid() == 0:... print('Ne doit pas être lancé avec root...')

Enfin, il est possible de retrouver le terminal contrôlant le processus : >>> os.ctermid()'/dev/tty'

Pour plus d’informations :$ man tty

Pour tester les différences, la console peut être lancée en root :$ sudo python3

2.1.4 Utilisateurs et groupesUn système d’exploitation moderne est multi-utilisateur et permet de retrouver des infor-mations sur les utilisateurs déclarés.Python permet de rechercher des renseignements sur les utilisateurs en se servant desfichiers qui stockent ces informations :

>>> with open("/etc/passwd") as f:... users = [l.split(':', 6) for l in f]...

On peut ainsi afficher les données de l’utilisateur simplement :>>> users[0]['root', 'x', '0', '0', 'root', '/root', '/bin/bash\n']

Elles correspondent respectivement aux :– nom d’utilisateur ;– mot de passe encrypté (ou stocké chiffré dans un fichier séparé) ;– identifiant de l’utilisateur ;– identifiant de son groupe ;– nom complet ;– répertoire d’accueil ;– shell au démarrage de sa session.Avec ces données, celui qui connaît le fonctionnement de son système sait à quels niveauxil peut intervenir pour effectuer des modifications.Voici comment obtenir l’ensemble des valeurs utilisées pour les différents utilisateurs :

>>> {u[6] for u in users}{'/bin/sh\n', '/bin/false\n', '/bin/sync\n', '/bin/bash\n', '/usr/sbin/nologin\n'}>>> {u[5] for u in users}{'/home/sch', '/var/www', '/root', '/var/lib/bacula', [...]}

691Programmation système et réseauChapitre 4.4

On peut utiliser les mêmes procédés pour les groupes :>>> with open("/etc/group") as f:... groups = [l.split(':', 3) for l in f]... >>> groups[0]['root', 'x', '0', '\n']

Le troisième élément est le numéro du groupe servant de lien avec l’utilisateur.Voici comment mettre cette relation en évidence :

>>> guser = {u[3]: u[0] for u in users}>>> user_group = [(guser.get(g[2]), g[0]) for g in groups]

On voit donc en peu d’exemples comment utiliser la puissance des types de Python. Le bontype pour la bonne utilisation.Voici un script testant l’existence des éléments caractéristiques d’un utilisateur, nomd’utilisateur, le nom de groupe associé et son dossier personnel à l’emplacement pardéfaut :

>>> for username in ['sch', 'existepas']:... if username in (u[0] for u in users):... print("L'utilisateur %s existe déjà" % username)... if username in (g[0] for g in groups):... print("Le groupe %s existe déjà" % username)... home = '/home/%s' % username... if os.path.exists(home):... print('Le dossier %s existe déjà' % username)... L'utilisateur sch existe déjàLe groupe sch existe déjàLe dossier sch existe déjà

Enfin, pour terminer, les utilisateurs courants du système (pas les utilisateurs Apache,Bacula ou autre) ont un identifiant compris entre certaines bornes :

>>> max_user_id = max([id for id in (int(u[2]) for u in users) if 1000 < id < 19999])>>> max_group_id = max([id for id in (int(g[2]) for g in groups) if 1000 < id < 19999])

Voici les résultats pour ma machine qui ne contient que deux comptes d’utilisateurscourants :

>>> max_user_id, max_group_id(1001, 1001)

© E

dit

ions

EN

I -

All r

ights

rese

rved


Python 3

2.1.5 Constantes pour le système de fichiersLe système d’exploitation définit certaines caractéristiques par rapport au système defichiers. Il s’agit de la notation du répertoire courant, du répertoire parent, du séparateurde répertoire (il peut y en avoir un second), du séparateur d’extensions, de la séparationentre chemins lorsqu’ils sont écrits l’un après l’autre, et le séparateur qui définit le chan-gement de ligne :

>>> os.curdir, os.pardir('.', '..')>>> os.sep, os.altsep, os.extsep, os.pathsep, os.linesep('/', None, '.', ':', '\n')

Chaque système définit également un chemin par défaut (liste de répertoires séparés parle séparateur os.pathsep) et un chemin vers une interface nulle :

>>> os.defpath':/bin:/usr/bin'>>> os.devnull'/dev/null'

Il existe encore un certain nombre d’opérations plus spécialisées, mais celles présentéespermettent déjà de réaliser un code indépendant du système :

>>> os.sep.join([os.curdir, 'rep', 'fname' + os.extsep + 'ext'])'./rep/fname.ext'

2.1.6 Gérer les cheminsPython 3.4 introduit une sémantique objet permettant de gérer les chemins beaucoup plussimplement que des chaînes de caractères :

>>> from pathlib import Path>>> mypath = Path('/var/www')>>> mypath.exists()True>>> mypath.is_dir()True

Pour les versions antérieures à Python 3.4, il est possible d'installer le module pathlib2 :$ sudo pip install pathlib2

Ce module est parfaitement intégré avec les modules Python déjà existants, parmi lesquelsle fameux module glob qui permet de faire des recherches de fichier très efficaces :

>>> www = Path('/var/www')>>> list(www.glob('**/*.html'))[PosixPath('index.html'), PosixPath('doc/index.html')]

Là où l'outil devient vraiment très efficace sémantiquement parlant, c'est qu'il profite àfond de la capacité de Python à surcharger les opérateurs et qu'il l'utilise intelligemmentde manière à rendre son utilisation très basique et surtout particulièrement lisible :

>>> doc, index = PurePath('doc'), PurePath('index.html')>>> myfile = mypath / doc / index

Sébastien CHAZALLET Python 3 -...

Documents

Transcript of Sébastien CHAZALLET Python 3 -...