entwanne

Un zeste de Python

16 avril 2022
Table des matières

Introduction 15

I. Premiers pas avec Python 18

Introduction 19

I.1. Présentation du langage 20

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
I.1.1. Qui es-tu, Python ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
I.1.2. Réalisations concrètes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
I.1.3. Histoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
I.1.4. Versions de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

I.2. Installation 27
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
I.2.1. Installation sous Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
I.2.1.1. Depuis le Microsft Store . . . . . . . . . . . . . . . . . . . . . . . . . 27
I.2.1.2. Avec l’installateur officiel . . . . . . . . . . . . . . . . . . . . . . . . 27
I.2.1.3. Avec un environnement de développement . . . . . . . . . . . . . . . 29
I.2.2. Installation sous MacOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
I.2.3. Installation sous GNU/Linux . . . . . . . . . . . . . . . . . . . . . . . . . . 30
I.2.3.1. Ubuntu / Debian / Linux Mint . . . . . . . . . . . . . . . . . . . . . 30
I.2.3.2. Fedora . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
I.2.3.3. Archlinux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
I.2.3.4. Autres distributions . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
I.2.4. Lancement de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
I.2.4.1. IDLE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
I.2.4.2. Depuis un terminal . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
I.2.5. Éditeur de texte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
I.2.5.1. Geany . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
I.2.5.2. PyCharm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
I.2.5.3. Autres éditeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

I.3. Prise en main de l’interpréteur 36

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
I.3.1. Interpréteur interactif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
I.3.2. Une machine à calculer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

1
Table des matières

I.4. Écrire du code dans des fichiers 39

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
I.4.1. Éditer un fichier Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
I.4.1.1. En-têtes de fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
I.4.2. Exécution du fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
I.4.2.1. Exécution depuis le terminal . . . . . . . . . . . . . . . . . . . . . . 41

I.5. Fichiers ou interpréteur interactif ? 43

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
I.5.1. Interpréteur interactif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
I.5.2. Écriture dans des fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

II. Manipuler des données 45

Introduction 46

II.1. Retour sur la calculatrice 47

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
II.1.1. Des nombres à virgule . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
II.1.2. Autres opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
II.1.2.1. Priorités des opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . 50
II.1.3. Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

II.2. Des variables pour sauvegarder nos résultats 54

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
II.2.1. Une étiquette sur une valeur . . . . . . . . . . . . . . . . . . . . . . . . . . 54
II.2.2. Assignations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
II.2.3. Conventions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
II.2.3.1. La variable _ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

II.3. Manipuler du texte 60

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
II.3.1. Chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
II.3.2. Opérations sur les chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62

II.4. Interactions 66
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
II.4.1. Entrées utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
II.4.2. Conversions de types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67

II.5. Objets et méthodes 69

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
II.5.1. Objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
II.5.2. Méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
II.5.3. Méthodes des chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . 70
II.5.3.1. strip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
II.5.3.2. capitalize et title . . . . . . . . . . . . . . . . . . . . . . . . . . 70

2
Table des matières

II.5.3.3. upper et lower . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

II.5.3.4. index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
II.5.4. Attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

II.6. TP : Combat en tour par tour 74

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
II.6.1. Présentation générale du TP . . . . . . . . . . . . . . . . . . . . . . . . . . 74
II.6.2. Initialisation du jeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
II.6.2.1. Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
II.6.3. Tour de jeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
II.6.3.1. Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

III. Des programmes moins déterminés 80

Introduction 81

III.1. Les conditions (if/elif/else) 82

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
III.1.1. Test d’égalité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
III.1.2. Bloc conditionnel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
III.1.2.1. Interpréteur interactif . . . . . . . . . . . . . . . . . . . . . . . . . . 85
III.1.2.2. Blocs sur une ligne . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
III.1.3. Et sinon ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
III.1.4. Structures multiples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
III.1.4.1. Enchaînement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
III.1.4.2. Imbrication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

III.2. Expressions booléennes 90

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
III.2.1. Opérations booléennes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
III.2.1.1. Vocabulaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
III.2.1.2. Opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
III.2.1.3. Priorités des opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . 92
III.2.2. Booléens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
III.2.2.1. Algèbre de Boole . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
III.2.2.2. Conditions et priorités . . . . . . . . . . . . . . . . . . . . . . . . . . 94
III.2.2.3. Conversions implicites et explicites . . . . . . . . . . . . . . . . . . . 95
III.2.2.4. Comparaisons chaînées . . . . . . . . . . . . . . . . . . . . . . . . . . 96

III.3. TP : Ajoutons des conditions à notre jeu 97

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
III.3.1. Proposer plusieurs attaques . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
III.3.2. Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

3
Table des matières

III.4. Les listes 100

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
III.4.1. Des séquences de valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100
III.4.2. Opérations sur les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
III.4.2.1. Opérations élémentaires . . . . . . . . . . . . . . . . . . . . . . . . . 102
III.4.2.2. Mutabilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
III.4.2.3. Slicing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
III.4.3. Listes à plusieurs dimensions . . . . . . . . . . . . . . . . . . . . . . . . . . 109
III.4.3.1. Problème de la multiplication . . . . . . . . . . . . . . . . . . . . . . 110

III.5. Itérer sur nos listes avec des boucles for 112
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
III.5.1. Le bloc for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112
III.5.2. Itération . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
III.5.2.1. Parcourir des listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
III.5.2.2. Itérables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
III.5.2.3. Construire une liste . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
III.5.2.4. Boucles imbriquées . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120

III.6. Boucler sur une condition (while) 121

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
III.6.1. Boucler sur une condition . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
III.6.2. Vers l’infini et au-delà . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
III.6.3. Boucle for ou boucle while ? . . . . . . . . . . . . . . . . . . . . . . . . . . 124

III.7. Algorithmes 126

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
III.7.1. Minimum d’une liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
III.7.2. Tri d’une liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
III.7.3. Un peu de dessin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
III.7.3.1. Affichons un rectangle . . . . . . . . . . . . . . . . . . . . . . . . . . 128
III.7.3.2. Passons au triangle . . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
III.7.3.3. Mon beau sapin, roi des forêts . . . . . . . . . . . . . . . . . . . . . . 130
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132

III.8. TP : Ajoutons des boucles à notre jeu 134

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
III.8.1. Itérer sur les attaques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134
III.8.1.1. Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
III.8.2. Un jeu au tour par tour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
III.8.2.1. Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136

IV. Types de données 139

Introduction 140

4
Table des matières

IV.1. Retour sur les types précédents 141

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
IV.1.1. Généralités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
IV.1.1.1. Conversions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
IV.1.1.2. Comparaisons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
IV.1.2. Booléens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
IV.1.2.1. Conversions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
IV.1.2.2. Opérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
IV.1.3. Nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
IV.1.3.1. Conversions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
IV.1.3.2. Opérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
IV.1.3.3. Représentations des entiers . . . . . . . . . . . . . . . . . . . . . . . 146
IV.1.3.4. Précision des flottants . . . . . . . . . . . . . . . . . . . . . . . . . . 147
IV.1.3.5. Notation des flottants . . . . . . . . . . . . . . . . . . . . . . . . . . 148
IV.1.3.6. Nombres complexes . . . . . . . . . . . . . . . . . . . . . . . . . . . 149
IV.1.4. Chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
IV.1.4.1. Conversions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
IV.1.4.2. Opérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
IV.1.4.3. Principales méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
IV.1.4.4. Méthodes avancées . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
IV.1.5. Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
IV.1.5.1. Conversions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 155
IV.1.5.2. Opérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
IV.1.5.3. Principales méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
IV.1.5.4. Identité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
IV.1.6. None . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162

IV.2. Les dictionnaires 163

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
IV.2.1. Des tables d’association . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
IV.2.2. Opérations sur les dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . 164
IV.2.2.1. Méthodes principales . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
IV.2.2.2. Conversions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
IV.2.3. Données composites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
IV.2.4. Clés de dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169

IV.3. Itérer sur un dictionnaire 171

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
IV.3.1. Dictionnaire et boucle for . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
IV.3.2. Autres manières d’itérer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
IV.3.2.1. Conversions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173

IV.4. Les tuples 174

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
IV.4.1. Les tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
IV.4.2. Opérations sur les tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
IV.4.3. Utilisations des tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177

5
Table des matières

IV.5. TP 179
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
IV.5.1. Structurer les données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
IV.5.2. Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181

V. Les fonctions 184

Introduction 185

V.1. Des fonctions pour factoriser 186

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
V.1.1. Don’t Repeat Yourself . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
V.1.2. Factoriser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
V.1.2.1. Identifier les portions logiques dans un code plus complet . . . . . . . 187
V.1.3. Définir une fonction (bloc def) . . . . . . . . . . . . . . . . . . . . . . . . . 187
V.1.4. Appel de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189

V.2. Fonctions paramétrées 191

V.2.1. Paramètres de fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
V.2.2. Espace de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
V.2.3. Arguments positionnels et nommés . . . . . . . . . . . . . . . . . . . . . . . 195

V.3. Retours de fonctions 197

V.3.1. Renvoyer une valeur avec return . . . . . . . . . . . . . . . . . . . . . . . . 197
V.3.2. Plusieurs return dans une fonction . . . . . . . . . . . . . . . . . . . . . . . 198
V.3.3. Renvoyer plusieurs valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
V.3.3.1. Unpacking . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199

V.4. Paramètres et types mutables 201

V.4.1. Rappel sur les types mutables . . . . . . . . . . . . . . . . . . . . . . . . . . 201
V.4.2. Paramètres mutables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
V.4.2.1. Effets de bord . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202

V.5. Fonctions de tests 204

V.5.1. Un monde rempli de bugs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
V.5.2. Fonctions de tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
V.5.2.1. Assertions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
V.5.2.2. Tests unitaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205

V.6. TP : Intégrons des fonctions à notre application 210

V.6.1. Découpage en fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
V.6.1.1. Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
V.6.2. Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
V.6.2.1. Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211

6
Table des matières

VI. Entrées / sorties 214

Introduction 215

VI.1. Découper son code en modules 216

VI.1.1. Factoriser le code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
VI.1.2. Les modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 216
VI.1.2.1. La fonction help . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
VI.1.3. Imports . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218
VI.1.4. Bibliothèque standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 220
VI.1.5. Modules de tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222

VI.2. Lire un fichier en Python 225

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
VI.2.1. Fichiers et dossiers sur l’ordinateur . . . . . . . . . . . . . . . . . . . . . . . 225
VI.2.2. Problématique : sauvegarder l’état de notre jeu . . . . . . . . . . . . . . . . 226
VI.2.3. Fonction open . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226
VI.2.4. Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
VI.2.4.1. Lire le contenu d’un fichier . . . . . . . . . . . . . . . . . . . . . . . 227
VI.2.4.2. Fermer un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
VI.2.4.3. Bloc with . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229

VI.3. Itérer sur un fichier 231

VI.3.1. Méthodes des fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
VI.3.2. Les fichiers sont itérables . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234

VI.4. Écrire dans un fichier 236

VI.4.1. Écriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
VI.4.1.1. Écrire plusieurs lignes dans un fichier . . . . . . . . . . . . . . . . . . 237
VI.4.1.2. La fonction print . . . . . . . . . . . . . . . . . . . . . . . . . . . . 239
VI.4.2. Autres modes des fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . 240
VI.4.2.1. Insérer à la fin du fichier . . . . . . . . . . . . . . . . . . . . . . . . . 240
VI.4.2.2. Créer un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 241
VI.4.2.3. Lire et écrire à la fois . . . . . . . . . . . . . . . . . . . . . . . . . . 241

VI.5. Chaînes de formatage 243

VI.5.1. Opérations de formatage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
VI.5.1.1. Méthode format . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
VI.5.1.2. Options de formatage . . . . . . . . . . . . . . . . . . . . . . . . . . 244
VI.5.1.3. Operateur % . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247
VI.5.2. f-strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 247

VI.6. Gérer les exceptions (try/except) 249

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 249
VI.6.1. Tout ne se passe pas comme prévu . . . . . . . . . . . . . . . . . . . . . . . 249
VI.6.2. Éviter l’exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 250
VI.6.2.1. Limites . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 251

7
Table des matières

VI.6.3. Traiter l’exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 252

VI.6.3.1. Attraper plusieurs exceptions . . . . . . . . . . . . . . . . . . . . . . 254
VI.6.3.2. Remontée d’erreurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . 256

VI.7. Formater les données 259

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
VI.7.1. Format JSON . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
VI.7.1.1. Module json . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
VI.7.1.2. Avantages et inconvénients . . . . . . . . . . . . . . . . . . . . . . . . 261
VI.7.2. Format XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
VI.7.2.1. Module xml . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 262
VI.7.2.2. Avantages et inconvénients . . . . . . . . . . . . . . . . . . . . . . . . 266
VI.7.3. Format INI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
VI.7.3.1. Module configparser . . . . . . . . . . . . . . . . . . . . . . . . . 267
VI.7.3.2. Avantages et inconvénients . . . . . . . . . . . . . . . . . . . . . . . . 269
VI.7.4. Format CSV . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
VI.7.4.1. Module csv . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
VI.7.4.2. Avantages et inconvénients . . . . . . . . . . . . . . . . . . . . . . . . 272
VI.7.5. Chaînes de bytes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272
VI.7.5.1. Encodages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
VI.7.5.2. Mode binaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
VI.7.6. Sérialisation binaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
VI.7.6.1. Module pickle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
VI.7.6.2. Avantages et inconvénients . . . . . . . . . . . . . . . . . . . . . . . . 279
VI.7.7. Autres formats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279

VI.8. Arguments de la ligne de commande 282

VI.8.1. Ligne de commande . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282
VI.8.1.1. Sortie standard et sortie d’erreur . . . . . . . . . . . . . . . . . . . . 283
VI.8.2. Parseur d’arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285

VI.9. Les paquets 287

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
VI.9.1. Construction d’un paquet . . . . . . . . . . . . . . . . . . . . . . . . . . . . 287
VI.9.1.1. Imports relatifs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 288
VI.9.2. Fichier [Link] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
VI.9.3. Fichier [Link] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291

VI.10. TP : Sauvegarder la partie 292

VI.10.1. Découpage en modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
VI.10.1.1. Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
VI.10.2. Sauvegarde . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
VI.10.2.1. Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
VI.10.3. Tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
VI.10.3.1. Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294

8
Table des matières

VII. Aller plus loin 304

Introduction 305

VII.1. Les autres types de données 306

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
VII.1.1. Les ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
VII.1.1.1. Opérations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
VII.1.1.2. Méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 309
VII.1.1.3. frozenset . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310
VII.1.2. Module collections . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
VII.1.2.1. Counter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
VII.1.2.2. defaultdict . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
VII.1.2.3. OrderedDict . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 315
VII.1.2.4. ChainMap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
VII.1.2.5. deque . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
VII.1.2.6. namedtuple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 321
VII.1.3. Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323

VII.2. Retour sur les conditions 326

VII.2.1. Instructions et expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326
VII.2.2. Expressions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . 327

VII.3. Retour sur les boucles 329

VII.3.1. Cas des boucles infinies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329
VII.3.2. Contrôle du flux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329
VII.3.3. Outils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332
VII.3.3.1. Fonctions natives (builtins) . . . . . . . . . . . . . . . . . . . . . . . 333
VII.3.3.2. reversed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334
VII.3.3.3. sorted . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334
VII.3.3.4. min et max . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
VII.3.3.5. zip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
VII.3.3.6. Module itertools . . . . . . . . . . . . . . . . . . . . . . . . . . . 337
VII.3.4. Listes en intension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
VII.3.4.1. Conditions de filtrage . . . . . . . . . . . . . . . . . . . . . . . . . . 340
VII.3.4.2. Boucles imbriquées . . . . . . . . . . . . . . . . . . . . . . . . . . . . 342
VII.3.4.3. Autres constructions en intension . . . . . . . . . . . . . . . . . . . . 343
VII.3.5. Itérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343
VII.3.5.1. Itérables et itérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . 343
VII.3.5.2. Fonctions map et filter . . . . . . . . . . . . . . . . . . . . . . . . 346
VII.3.5.3. Itérateurs infinis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
VII.3.5.4. Fonction iter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349

VII.4. Retour sur les fonctions 351

VII.4.1. Arguments optionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351
VII.4.1.1. Paramètres par défaut mutables . . . . . . . . . . . . . . . . . . . . . 352
VII.4.1.2. Ordre de placement des paramètres . . . . . . . . . . . . . . . . . . . 353
VII.4.2. Arguments variadiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354
VII.4.2.1. Opérateur splat . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356

9
Table des matières

VII.4.3. Documentation et annotations . . . . . . . . . . . . . . . . . . . . . . . . . 356

VII.4.3.1. Docstring . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
VII.4.3.2. Comment documenter ? . . . . . . . . . . . . . . . . . . . . . . . . . 358
VII.4.3.3. Annotations de types . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
VII.4.3.4. Module typing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
VII.4.4. Décorateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
VII.4.4.1. Décorateur paramétré . . . . . . . . . . . . . . . . . . . . . . . . . . 362
VII.4.5. Fonctions lambdas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
VII.4.6. Fonctions récursives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 366
VII.4.6.1. Récursion infinie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
VII.4.6.2. Récursions croisées . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368

VII.5. Retour sur les variables 369

VII.5.1. Expressions d’assignation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369
VII.5.2. Annotations de types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 371
VII.5.3. Scopes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
VII.5.3.1. Variables globales . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373
VII.5.3.2. Fonctions imbriquées . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
VII.5.3.3. Variables non-locales . . . . . . . . . . . . . . . . . . . . . . . . . . . 375

VII.6. Retour sur les exceptions 376

VII.6.1. Bloc except . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376
VII.6.1.1. Données complémentaires des exceptions . . . . . . . . . . . . . . . . 377
VII.6.2. Autres mots-clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
VII.6.2.1. else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
VII.6.2.2. finally . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
VII.6.3. Bloc with . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
VII.6.3.1. Supprimer une exception . . . . . . . . . . . . . . . . . . . . . . . . . 382
VII.6.4. Lever une exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
VII.6.4.1. Hiérarchie des exceptions . . . . . . . . . . . . . . . . . . . . . . . . 384

VII.7. Débogage 386

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386
VII.7.1. Programme de référence . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 386
VII.7.2. Introspection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
VII.7.2.1. Informations sur la valeur . . . . . . . . . . . . . . . . . . . . . . . . 389
VII.7.2.2. Contenu de la valeur . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
VII.7.3. Déboguer «à la main» . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 392
VII.7.3.1. Suivre et comprendre les exceptions . . . . . . . . . . . . . . . . . . 392
VII.7.3.2. S’appuyer sur des tests unitaires . . . . . . . . . . . . . . . . . . . . 395
VII.7.4. Utilisation d’un débogueur (Pdb) . . . . . . . . . . . . . . . . . . . . . . . . 397
VII.7.4.1. Lancer un programme pas-à-pas avec Pdb . . . . . . . . . . . . . . . 398
VII.7.4.2. Invoquer Pdb depuis le programme . . . . . . . . . . . . . . . . . . . 403
VII.7.5. Déboguer avec votre IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . 405

VIII. La bibliothèque standard 407

Introduction 408

10
Table des matières

VIII.1. Tour d’horizon de la bibliothèque standard 409

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
VIII.1.1. Fonctions natives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
VIII.1.1.1. Module operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
VIII.1.2. Gestion des nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
VIII.1.2.1. Nombres décimaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . 413
VIII.1.2.2. Nombres rationnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
VIII.1.2.3. Hiérarchie des nombres . . . . . . . . . . . . . . . . . . . . . . . . . 416
VIII.1.2.4. Bibliothèques mathématiques . . . . . . . . . . . . . . . . . . . . . . 417
VIII.1.3. Chemins et fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
VIII.1.3.1. Usage des chemins . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419
VIII.1.3.2. Propriétés des chemins . . . . . . . . . . . . . . . . . . . . . . . . . . 420
VIII.1.3.3. Méthodes concrètes . . . . . . . . . . . . . . . . . . . . . . . . . . . 422
VIII.1.3.4. Méthodes pour les répertoires . . . . . . . . . . . . . . . . . . . . . . 424
VIII.1.3.5. Méthodes pour les fichiers . . . . . . . . . . . . . . . . . . . . . . . . 425
VIII.1.4. Modules systèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427
VIII.1.4.1. Module sys . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 427
VIII.1.4.2. Module shutil . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 429
VIII.1.4.3. Module os . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 431

VIII.2. Un peu d’aléatoire 434

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434
VIII.2.1. Le module random . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434
VIII.2.1.1. Nombres aléatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434
VIII.2.1.2. Opérations aléatoires . . . . . . . . . . . . . . . . . . . . . . . . . . . 435
VIII.2.2. Distributions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 437
VIII.2.2.1. Lois de distribution . . . . . . . . . . . . . . . . . . . . . . . . . . . 437
VIII.2.2.2. Pondération . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 439

VIII.3. Gestion du temps 443

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
VIII.3.1. Module time . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
VIII.3.1.1. Les timestamps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
VIII.3.1.2. Structure de temps . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444
VIII.3.1.3. Utilitaires du module . . . . . . . . . . . . . . . . . . . . . . . . . . . 445
VIII.3.2. Module datetime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446
VIII.3.2.1. Conversions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446
VIII.3.2.2. Durées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448
VIII.3.2.3. Fuseaux horaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449
VIII.3.3. Module calendar . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 450
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 451

VIII.4. Expressions rationnelles 452

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452

VIII.5. TP : Monstre sauvage 453

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453
VIII.5.1. L’aléatoire à la rescousse ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453
VIII.5.1.1. Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453

11
Table des matières

VIII.5.2. Animations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454

VIII.5.2.1. Solution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455
Contenu masqué . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 455

VIII.6. Un peu de réseau 461

VIII.6.1. Connecteurs réseau (sockets) . . . . . . . . . . . . . . . . . . . . . . . . . . 461
VIII.6.2. Client réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
VIII.6.3. Serveur réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
VIII.6.4. Protocoles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
VIII.6.5. TP : un jeu en réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461

VIII.7. Plusieurs tâches en même temps 462

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462
VIII.7.1. Programmation multi-thread . . . . . . . . . . . . . . . . . . . . . . . . . . 462
VIII.7.2. Programmation asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . 462
VIII.7.3. Programmation multi-processus . . . . . . . . . . . . . . . . . . . . . . . . . 462

VIII.8. TP 463
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463

VIII.9. Installer des modules complémentaires 464

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464
VIII.9.1. Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464
VIII.9.2. Pip, le gestionnaire de paquets Python . . . . . . . . . . . . . . . . . . . . . 464
VIII.9.3. Environnements virtuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 467

IX. Exercices 469

Introduction 470

IX.1. Premiers pas avec Python 471

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471

IX.2. Manipuler des données 472

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 472

IX.3. Des programmes moins déterminés 473

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473

IX.4. Types de données 474

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474

IX.5. Types de données 475

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475

IX.6. Entrées / sorties 476

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476

12
Table des matières

IX.7. Aller plus loin 477

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 477

X. Annexes 478
Introduction 479

X.1. Glossaire et mots clés 480

X.1.1. Glossaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 480
X.1.2. Tableau des mots-clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 489
X.1.3. Tableau des opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 495
X.1.3.1. Opérateurs simples (expressions) . . . . . . . . . . . . . . . . . . . . 495
X.1.3.2. Opérateurs d’assignation . . . . . . . . . . . . . . . . . . . . . . . . . 499
X.1.4. Priorité des opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 500
X.1.4.1. Ordre d’évaluation des expressions . . . . . . . . . . . . . . . . . . . 500
X.1.4.2. Tableau des priorités . . . . . . . . . . . . . . . . . . . . . . . . . . . 500
X.1.5. Autres éléments de syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . 501

X.2. Notes diverses 503

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503
X.2.1. En-têtes de fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 503

X.3. Quelques modules complémentaires bien utiles 505

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505
X.3.1. Requests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 505
X.3.2. Numpy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506
X.3.3. Django . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 506
X.3.4. Pillow . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507
X.3.5. PyGObject (PyGTK) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 507
X.3.6. Pygame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 509

X.4. Tests 511

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511
X.4.1. Pytest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 511
X.4.2. Unittest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 513

X.5. Outils 515

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515
X.5.1. Linters . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515
X.5.1.1. Flake8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515
X.5.1.2. Pylint . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515
X.5.1.3. Black . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515
X.5.1.4. isort . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516
X.5.2. mypy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 516

X.6. Packaging 517

X.6.1. [Link] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517
X.6.2. Poetry . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 517

13
Table des matières

X.7. Bases de données 518

X.7.1. SQLite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518
X.7.2. PostgreSQL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 518

X.8. Les erreurs courantes en Python 519

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 519

X.9. Ressources 520

Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520
X.9.1. Liens utiles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520
X.9.2. Cours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520
X.9.2.1. Sur Zeste de Savoir . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520
X.9.2.2. Ailleurs sur le web . . . . . . . . . . . . . . . . . . . . . . . . . . . . 520
X.9.3. Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521
X.9.4. Discussions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521
X.9.4.1. Forums . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521
X.9.4.2. Salons de discussions . . . . . . . . . . . . . . . . . . . . . . . . . . . 521
X.9.5. Conférences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 521

Conclusion 522

14
Introduction

15
Introduction

Bien le bonjour ! Bienvenue dans le monde magique de Python !

À toi qui t’intéresses à la programmation informatique, au développement logiciel et à son
apprentissage : voici un tutoriel pour te guider et te permettre d’avancer dans ta quête.
Ce cours a pour but de t’apprendre à parler le Python. Il s’agit d’un langage particulier—un
langage de programmation—pour communiquer avec ton ordinateur afin de lui demander de réa-
liser des tâches précises (comme exécuter un calcul, récupérer des événements du clavier, afficher
une image à l’écran, etc.), c’est-à-dire exécuter un programme informatique (un logiciel).
Il existe une multitude de langages de programmation (tels que le C, le Java, le PHP ou le
Javascript), j’ai choisi le Python pour ce cours car il me semble être le langage idéal pour débuter
puis continuer la programmation.
Peut-être connais-tu déjà l’un ou l’autre de ces langages, ou même que tu programmes au
quotidien : ce cours s’adresse tout de même à toi, il vise à apprendre le Python quelque soit ton
niveau de départ.
Ta quête du Python est sur le point de commencer ! Un tout nouveau monde de rêves, d’aventures
et de programmation t’attend ! Dingue !
Pour nous rejoindre, rien de plus simple, rends-toi de ce pas vers le premier chapitre afin
d’en découvrir plus sur le langage.

Figure .0.1. – Un zeste de Python.

16
Introduction

J’ai découpé ce cours en plusieurs parties (ou paliers) pour te permettre d’avancer pas à pas
dans l’apprentissage du Python, en commençant par les bases pour à terme réussir à réaliser
des programmes complets.
Chaque partie se divise en chapitres, pour présenter les différentes notions du langage, avec des
exercices pour les mettre en pratique.
Les parties sont généralement conclues par un chapitre de travaux pratiques (TP), pour utiliser
concrètement les connaissances apprises au long des chapitres qui précèdent, dans le but de
réaliser un jeu de combat au tour par tour en mode texte.

i
Tu n’as pas besoin de connaissances particulières pour démarrer ce tutoriel : savoir installer
un logiciel sur ton ordinateur et connaître les bases du calcul (opérations élémentaires)
sont les seuls pré-requis.
Quelques notions d’anglais sont un plus.

La difficulté augmente bien sûr au long du cours, mais j’ai fait en sorte que l’avancée soit
progressive et donc que cette difficulté soit transparente. N’hésite pas à demander de l’aide si
toutefois tu buttais sur un point ou étais bloqué sur un exercice.
Je suis aussi ouvert à tous retours si tu trouves que telle notion est mal expliquée ou que telle
autre mériterait d’être abordée.
Car oui, ce cours ne couvre pas l’entièreté du langage Python et n’a pas pour volonté de
remplacer sa documentation . Il a simplement pour but d’apprendre les bases du langage et
d’écrire des programmes complets en exploitant ces bases.
Mais ce tuto ne traite pas de la programmation objet en Python ou des notions avancées du
langage, sujets pour lesquels j’ai écrit deux autres cours afin de compléter ton apprentissage :
— La programmation orientée objet en Python .
— Notions de Python avancées .
Je t’ai donné soif d’apprendre ? Alors installe-toi, prends un smoothie, et n’hésite pas à y
ajouter un zeste de Python.

17
 Première partie

Premiers pas avec Python

18