APPRENEZ À PROGRAMMER EN

Vincent Le Goff
PYTHON 4e édition

Vous n’y connaissez rien en programmation et vous souhaitez apprendre un langage clair et
intuitif ? Python est fait pour vous ! Vous découvrirez dans ce livre, conçu pour les débutants, tout
ce dont vous avez besoin pour programmer, des bases à la bibliothèque standard, en passant par
la programmation orientée objet et l’acquisition d’outils avancés ou professionnels pour devenir
plus efficace.
La 4e édition de cet ouvrage est enrichie et mise à jour pour tirer parti des nouveautés de Python 3.1x.
Vincent Le Goff

Qu’allez-vous apprendre ?
• Qu’est-ce que la programmation ? Quel langage APPRENEZ À PROGRAMMER EN

Python
choisir ? Pourquoi Python ?
• Installation de Python et découverte
du langage

4e édition
• Les concepts de la programmation
orientée objet
• Initiation aux interfaces graphiques

PYTHON
avec Tkinter
• Communication en réseau dans
les programmes Python
4e édition
• Les bonnes pratiques pour améliorer

APPRENEZ À PROGRAMMER EN
vos codes
• Les réflexes du « bon programmeur »
pour tirer parti de votre code et de celui
des autres
• Les outils du programmeur professionnel (chasse
aux erreurs, utilisation de bibliothèques…)

À propos de l’auteuR
Passionné d’informatique, Vincent Le Goff découvre au lycée la programmation en Python, un langage
qu’il affectionne tout particulièrement pour son aspect simple et puissant. Étudiant à IN’TECH, il se
spécialise en Système et Réseaux. Sur son temps libre, il publie des cours sur OpenClassrooms et participe
également à plusieurs projets open source. Une belle réussite quand on sait que Vincent est non-voyant
et malentendant !
ISBN : 978-2-416-00655-5
Code éditeur : G0100655

32 E

Couverture : Studio Eyrolles © Éditions Eyrolles

[Link] 1 25/01/2022 09:40

SUR LE MÊME THÈME
H. Bersini, K. Hasselmann. – L’intelligence artificielle en pratique avec Python.
N°0100456, 2021, 136 pages.
E. Matthes. – Cartes mémo Python.
N°67860, 2020, 101 cartes.
J-B. Civet, B. Hanuš. – Algorithmique et programmation en Python.
N°67769, 2019, 96 pages.
M. O’Hanlon, D. Whale. – Apprendre à coder en Python avec Minecraft.
N°67721, 2e édition, 2019, 304 pages.
J. Briggs. – Python pour les kids.
N°14088, 2015, 332 pages.
G. Swinnen. – Apprendre à programmer avec Python 3.
N°13434, 3e édition, 2012, 435 pages.

DANS LA MÊME COLLECTION

É. Lalitte. – Apprenez le fonctionnement des réseaux TCP/IP.
N°67776, 4e édition, 2019, 452 pages.
C. Herby. – Apprenez à programmer en Java.
N°67521, 3e édition, 2018, 788 pages.
M. Nebra. – Concevez votre site web avec PHP et MySQL.
N°67475, 3e édition, 2017, 392 pages.
M. Nebra. – Réalisez votre site web avec HTML 5 et CSS 3.
N°67476, 2e édition, 2017, 364 pages.
V. Thuillier. – Programmez en orienté objet en PHP.
N°14472, 2e édition, 2017, 474 pages.
J. Pardanaud, S. De la Marck. – Découvrez le langage JavaScript.
N°14399, 2017, 478 pages.

Retrouvez nos bundles (livres papier + e-book) et livres numériques sur

http ://[Link]
 Vincent Le Goff

APPRENEZ À PROGRAMMER EN

PYTHON
4e édition

[Link] 3 08/10/2019 15:10

 Éditions Eyrolles
61, bd Saint-Germain
75240 Paris Cedex 05
[Link]

Sauf mention contraire, le contenu de cet ouvrage est publié sous la licence :
Creative Commons BY-NC-SA 2.0
La copie de cet ouvrage est autorisée sous réserve du respect des conditions de la licence.
Texte complet de la licence disponible sur : [Link]
Mentions légales :
Conception couverture : Sophie Bai
Illustrations chapitres : Fan Jiyong et Sophie Bai

En application de la loi du 11 mars 1957, il est interdit de reproduire intégralement ou partiellement le

présent ouvrage, sur quelque support que ce soit, sans l’autorisation de l’Éditeur ou du Centre français
d’exploitation du droit de copie, 20, rue des Grands Augustins, 75006 Paris.

© Groupe Eyrolles, 2016

© Éditions Eyrolles, 2022, ISBN : 978-2-416-00655-5

Avant-propos

’ai commencé à m’intéresser à l’informatique, et plus particulièrement au monde

J de la programmation, au début du lycée, il y a maintenant près de quinze ans.
J’ai abordé ce terrain inconnu avec une grande curiosité. . . qui n’a pas encore
faibli puisque je suis aujourd’hui étudiant à IN’TECH, une école supérieure d’ingénierie
informatique ! Au premier abord, la programmation me semblait un monde aride et
froid, rempli d’équations compliquées et de notions abstraites.
Heureusement, le premier langage à avoir attiré mon attention s’est trouvé être Python :
à la fois simple et extrêmement puissant, je le considère aujourd’hui comme le meilleur
choix quand on souhaite apprendre à programmer. Il est d’ailleurs resté le langage que
j’utilise le plus dans les projets libres auxquels je contribue.
Cependant, Python n’est pas seulement simple : c’est un langage puissant. Il existe une
différence entre connaître un langage et coder efficacement avec. Plusieurs années de
pratique m’ont été nécessaires pour comprendre pleinement cette différence.
Les cours sur le langage Python s’adressant aux débutants ne sont pas rares sur le Web
et beaucoup sont de grande qualité. Toutefois, il en existe trop peu, à mon sens, qui
permettent de comprendre à la fois la syntaxe et la philosophie du langage.
Mon objectif ici est qu’après avoir lu ce livre, vous sachiez programmer en Python. Et
par « programmer », je n’entends pas seulement maîtriser la syntaxe du langage, mais
aussi comprendre sa philosophie.

Étant non-voyant et malentendant, je me suis efforcé de rendre ce cours aussi

accessible que possible à tous. Ainsi, ne soyez pas surpris si vous y trouvez
moins de schémas et d’illustrations que dans d’autres cours. J’ai fait en sorte
que leur présence ne soit pas indispensable à la compréhension du lecteur.

Pour ceux qui se demandent comment je travaille, j’ai un ordinateur absolument

semblable au vôtre. Pour l’utiliser, j’installe sur mon système un logiciel qu’on appelle
lecteur d’écran. Ce dernier me dicte une bonne partie des informations affichées dans
la fenêtre du logiciel que j’utilise, comme le navigateur Internet. Le lecteur, comme
APPRENEZ À PROGRAMMER EN PYTHON

son nom l’indique, lit grâce à une voix synthétique les informations qu’il détecte sur
la fenêtre et peut également les transmettre à une plage tactile. C’est un périphérique
qui se charge d’afficher automatiquement en braille les informations que lui transmet
le lecteur d’écran. Avec ces outils, je peux donc me servir d’un ordinateur, aller sur
Internet et même programmer !

Figure 1 – La plage tactile et le casque transmettent les informations affichées à l’écran

Qu’allez-vous apprendre en lisant ce livre ?

Ce livre s’adresse au plus grand nombre :
— si le mot programmation ne vous évoque rien de précis, ce livre vous guidera pas
à pas dans la découverte du monde du programmeur ;
— si vous connaissez déjà un autre langage de programmation, ce livre présente de
façon aussi claire que possible la syntaxe de Python et des exemples d’utilisation
concrète de ce langage ;
— si vous connaissez déjà Python, ce cours peut vous servir de support comparatif
avec d’autres livres et cours existants ;
— si vous enseignez le langage Python, j’ai espoir que ce livre pourra être un support
utile, autant pour vous que pour vos étudiants.
Ce livre est divisé en cinq parties. Les trois premières sont à lire dans l’ordre, sauf si
vous avez déjà de solides bases en Python :

II
 AVANT-PROPOS

1. Introduction à Python. Vous y apprendrez d’abord, si vous l’ignorez, ce que

signifie programmer, ce qu’est Python et la syntaxe de base du langage.
2. La Programmation Orientée Objet côté utilisateur. Après avoir vu les bases de
Python, nous allons étudier la façade objet de ce langage. Dans cette partie,
vous apprendrez à utiliser les classes que définit Python. Ne vous inquiétez pas,
les concepts d’objet et de classe seront largement détaillés ici. Donc, si ces mots
ne vous disent rien au premier abord, pas d’inquiétude !
3. La Programmation Orientée Objet côté développeur. Cette partie poursuit
l’approche de la façade objet débutée dans la partie précédente. Cette fois,
cependant, au lieu d’être utilisateur des classes déjà définies par Python, vous
allez apprendre à en créer. Là encore, ne vous inquiétez pas : nous verrons tous
ces concepts pas à pas.
4. Les merveilles de la bibliothèque standard. Cette partie étudie plus en détail cer-
tains modules déjà définis par Python. Vous y apprendrez notament à manipuler
les dates et heures, créer des interfaces graphiques, construire une architecture
réseau. . . et bien plus !
5. Annexes. Enfin, cette partie regroupe les annexes et résumés du cours. Il s’agit
de notions qui ne sont pas absolument nécessaires pour développer en Python
mais que je vous encourage tout de même à lire attentivement.

Comment lire ce livre ?

Suivez l’ordre des chapitres
Lisez ce livre comme on lit un roman. Il a été conçu pour cela.
Contrairement à beaucoup de livres techniques où il est courant de lire en diagonale et
de sauter certains chapitres, il est ici très fortement recommandé de suivre l’ordre du
cours, à moins que vous ne soyez déjà un peu expérimentés.

Pratiquez en même temps

Pratiquez régulièrement. N’attendez pas d’avoir fini de lire ce livre pour allumer votre
ordinateur et faire vos propres essais.

Utilisez les codes web !

Afin de tirer parti d’OpenClassrooms dont ce livre est issu, celui-ci vous propose ce
qu’on appelle des « codes web ». Ce sont des codes à six chiffres à saisir sur une page
d’OpenClassrooms pour être automatiquement redirigé vers un site web sans avoir à en
recopier l’adresse.
Pour les utiliser, rendez-vous sur la page suivante :
[Link]

III
APPRENEZ À PROGRAMMER EN PYTHON

Un formulaire vous invite à rentrer votre code. Faites un premier essai avec le suivant :

Tester le code web
▷
Code web : 123456
Ces codes ont deux intérêts :
— ils vous redirigent vers les sites web présentés tout au long du cours, vous facilitant
l’obtention des logiciels dans leur toute dernière version ;
— ils vous permettent de télécharger les codes sources inclus dans ce livre, ce qui
vous évitera d’avoir à recopier certains programmes un peu longs.
Ce système de redirection nous permet de tenir à jour le livre que vous avez entre les
mains sans que vous ayez besoin d’acheter systématiquement chaque nouvelle édition.
Si un site web change d’adresse, nous modifierons la redirection mais le code web à
utiliser restera le même. Si un site web disparaît, nous vous redirigerons vers une page
d’OpenClassrooms expliquant ce qui s’est passé et vous proposant une alternative.
En clair, c’est un moyen de nous assurer de la pérennité de cet ouvrage sans que vous
ayez à faire quoi que ce soit !

Remerciements
De nombreuses personnes ont, plus ou moins directement, participé à ce livre. Mes
remerciements leurs sont adressés :
— à ma famille avant tout, qui a su m’encourager, dans ce projet comme dans tout
autre, du début jusqu’à la fin ;
— aux personnes, trop nombreuses pour que j’en dresse ici la liste, qui ont contribué,
par leurs encouragements, leurs remarques et parfois leurs critiques, à faire de ce
livre ce qu’il est ;
— à l’équipe d’OpenClassrooms qui a rendu ce projet envisageable et a travaillé
d’arrache-pied pour qu’il se concrétise ;
— aux membres d’OpenClassrooms (Site du Zéro à l’époque) qui ont contribué à
sa correction ou son enrichissement.
Table des matières

I Introduction à Python 1

1 Qu’est-ce que Python ? 3

Un langage de programmation ? Qu’est-ce que c’est ? . . . . . . . . . . . . . . 4
La communication humaine . . . . . . . . . . . . . . . . . . . . . . . . . 4
Mon ordinateur communique aussi ! . . . . . . . . . . . . . . . . . . . . . 4
Pour la petite histoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
À quoi peut servir Python ? . . . . . . . . . . . . . . . . . . . . . . . . . 6
Un langage de programmation interprété . . . . . . . . . . . . . . . . . . 6
Différentes versions de Python . . . . . . . . . . . . . . . . . . . . . . . 7
Installer Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Sous Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Sous Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Sous macOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Lancer Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

2 Premiers pas avec l’interpréteur de commandes Python 13

Où est-ce qu’on est, là ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Vos premières instructions : un peu de calcul mental pour l’ordinateur . . . . 15
Saisir un nombre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Opérations courantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

3 Le monde merveilleux des variables 19

Qu’est-ce qu’une variable ? Et à quoi cela sert-il ? . . . . . . . . . . . . . . . . 20
APPRENEZ À PROGRAMMER EN PYTHON

Qu’est-ce qu’une variable ? . . . . . . . . . . . . . . . . . . . . . . . . . . 20

Comment cela fonctionne-t-il ? . . . . . . . . . . . . . . . . . . . . . . . 20
Les types de données en Python . . . . . . . . . . . . . . . . . . . . . . . . . 23
Qu’entend-on par « type de donnée » ? . . . . . . . . . . . . . . . . . . . 23
Les différents types de données . . . . . . . . . . . . . . . . . . . . . . . 23
Les chaînes de caractères formatées . . . . . . . . . . . . . . . . . . . . . 25
Un petit bonus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Quelques trucs et astuces pour vous faciliter la vie . . . . . . . . . . . . 26
Première utilisation des fonctions . . . . . . . . . . . . . . . . . . . . . . . . . 27
Utiliser une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
La fonction « type » . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
La fonction print . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

4 Les structures conditionnelles 31

Vos premières conditions et blocs d’instructions . . . . . . . . . . . . . . . . . 32
Forme minimale en if . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Forme complète (if, elif et else) . . . . . . . . . . . . . . . . . . . . 33
De nouveaux opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Les opérateurs de comparaison . . . . . . . . . . . . . . . . . . . . . . . 37
Prédicats et booléens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Les mots-clés and, or et not . . . . . . . . . . . . . . . . . . . . . . . . 38
Votre premier programme ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Avant de commencer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Sujet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Solution ou résolution . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

5 Les boucles 45
En quoi cela consiste-t-il ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
La boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
La boucle for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
Un petit bonus : les mots-clés break et continue . . . . . . . . . . . . . . 52
Le mot-clé break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Le mot-clé continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

VI
 TABLE DES MATIÈRES

6 Pas à pas vers la modularité (1/2) 55

Les fonctions : à vous de jouer . . . . . . . . . . . . . . . . . . . . . . . . . . 56
La création de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
Valeurs par défaut des paramètres . . . . . . . . . . . . . . . . . . . . . 58
Signature d’une fonction . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
L’instruction return . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Les annotations de type . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Les fonctions lambda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
À la découverte des modules . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Les modules, qu’est-ce que c’est ? . . . . . . . . . . . . . . . . . . . . . . 65
La méthode import . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Utiliser un espace de noms spécifique . . . . . . . . . . . . . . . . . . . . 67
Une autre méthode d’importation : from ... import ... . . . . . . 68
Bilan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

7 Pas à pas vers la modularité (2/2) 71

Mettre notre code en boîte . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Fini, l’interpréteur ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
Emprisonnons notre programme dans un fichier . . . . . . . . . . . . . . 72
Sous Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Sous Windows . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Je viens pour conquérir le monde. . . et créer mes propres modules . . . . . . . 75
Mes modules à moi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
Faire un test dans le module-même . . . . . . . . . . . . . . . . . . . . . 77
Les packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
En théorie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
En pratique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

8 Les exceptions 83
À quoi cela sert-il ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Forme minimale du bloc try . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Forme plus complète . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
Exécuter le bloc except pour un type d’exception précis . . . . . . . . 86

VII
APPRENEZ À PROGRAMMER EN PYTHON

Les mots-clés else et finally . . . . . . . . . . . . . . . . . . . . . . 87

Un petit bonus : le mot-clé pass . . . . . . . . . . . . . . . . . . . . . . 88
Les assertions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Lever une exception . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91

9 TP : tous au ZCasino 93
Notre sujet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Notre règle du jeu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Organisons notre projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
Le module random . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Arrondir un nombre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
À vous de jouer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Correction ! . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
Et maintenant ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

II La programmation orientée objet côté utilisateur 99

10 Notre premier objet : la chaîne de caractères 101

Vous avez dit objet ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Les méthodes de la classe str . . . . . . . . . . . . . . . . . . . . . . . . . . 102
Mettre en forme une chaîne . . . . . . . . . . . . . . . . . . . . . . . . . 104
Formater et afficher une chaîne . . . . . . . . . . . . . . . . . . . . . . . 106
Parcours et sélection de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . 111
Parcours par indice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
Sélection de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

11 Les listes et tuples (1/2) 115

Créons et éditons nos premières listes . . . . . . . . . . . . . . . . . . . . . . 116
D’abord, qu’est-ce qu’une liste ? . . . . . . . . . . . . . . . . . . . . . . . 116
Création de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 116
Insérer des objets dans une liste . . . . . . . . . . . . . . . . . . . . . . . 117
Suppression d’éléments d’une liste . . . . . . . . . . . . . . . . . . . . . 119
Le parcours de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
La fonction enumerate . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
Les listes et annotations de type . . . . . . . . . . . . . . . . . . . . . . 124

VIII
 TABLE DES MATIÈRES

Les tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

Affectation multiple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
Une fonction renvoyant plusieurs valeurs . . . . . . . . . . . . . . . . . . 125

12 Les listes et tuples (2/2) 127

Entre chaînes et listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Des chaînes aux listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Des listes aux chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 128
Une application pratique . . . . . . . . . . . . . . . . . . . . . . . . . . . 129
Les listes et paramètres de fonctions . . . . . . . . . . . . . . . . . . . . . . . 130
Les fonctions dont on ne connaît pas à l’avance le nombre de paramètres 130
Transformer une liste en paramètres de fonction . . . . . . . . . . . . . . 133
Match et les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
Les compréhensions de liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
Parcours simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
Filtrage avec un branchement conditionnel . . . . . . . . . . . . . . . . . 137
Mélangeons un peu tout cela . . . . . . . . . . . . . . . . . . . . . . . . 138
Nouvelle application concrète . . . . . . . . . . . . . . . . . . . . . . . . 138

13 Les dictionnaires 141

Création et édition de dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . 142
Créer un dictionnaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
Supprimer des clés d’un dictionnaire . . . . . . . . . . . . . . . . . . . . 145
Ordre des dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
Un peu plus loin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
Les méthodes de parcours . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Parcours des clés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
Parcours des valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
Parcours des clés et valeurs simultanément . . . . . . . . . . . . . . . . . 148
Les dictionnaires et paramètres de fonction . . . . . . . . . . . . . . . . . . . 149
Récupérer les paramètres nommés dans un dictionnaire . . . . . . . . . 149
Transformer un dictionnaire en paramètres nommés d’une fonction . . . 150
Les compréhensions de dictionnaire . . . . . . . . . . . . . . . . . . . . . . . . 151
Match et les dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

IX
APPRENEZ À PROGRAMMER EN PYTHON

14 Les ensembles 155

Utilité et création des ensembles . . . . . . . . . . . . . . . . . . . . . . . . . 156
Opérations sur les ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . 157
Opérations sur un ensemble . . . . . . . . . . . . . . . . . . . . . . . . . 157
Travail sur deux ensembles . . . . . . . . . . . . . . . . . . . . . . . . . 160
Quelques exemples d’utilisation . . . . . . . . . . . . . . . . . . . . . . . 162

15 Les fichiers 165

Avant de commencer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
Tout d’abord, pourquoi lire ou écrire dans des fichiers ? . . . . . . . . . . 166
Changer le répertoire de travail courant . . . . . . . . . . . . . . . . . . 166
Chemins relatifs et absolus . . . . . . . . . . . . . . . . . . . . . . . . . 167
Lecture et écriture dans un fichier . . . . . . . . . . . . . . . . . . . . . . . . 168
Ouverture du fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
Fermer le fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
Lire l’intégralité du fichier . . . . . . . . . . . . . . . . . . . . . . . . . . 170
Écriture dans un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
Écrire d’autres types de données . . . . . . . . . . . . . . . . . . . . . . 171
Le mot-clé with . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
Le module pathlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
Enregistrer des objets dans des fichiers . . . . . . . . . . . . . . . . . . . . . . 173
Enregistrer un objet dans un fichier . . . . . . . . . . . . . . . . . . . . 173
Récupérer nos objets enregistrés . . . . . . . . . . . . . . . . . . . . . . 174

16 Portée des variables et références 177

La portée des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
Dans nos fonctions, quelles sont les variables accessibles ? . . . . . . . . 178
La portée de nos variables . . . . . . . . . . . . . . . . . . . . . . . . . . 179
Les variables globales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
Le principe des variables globales . . . . . . . . . . . . . . . . . . . . . . 183
Utiliser concrètement les variables globales . . . . . . . . . . . . . . . . . 183

17 TP : un bon vieux pendu 185

Votre mission . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
Un jeu du pendu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186

X
 TABLE DES MATIÈRES

Le côté technique du problème . . . . . . . . . . . . . . . . . . . . . . . 186

Gérer les scores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
À vous de jouer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
Correction proposée . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
[Link] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 187
[Link] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188
[Link] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
En résumé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192

III La programmation orientée objet côté développeur 193

18 Première approche des classes 195

Les classes, tout un monde . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
Pourquoi utiliser des objets ? . . . . . . . . . . . . . . . . . . . . . . . . 196
Choix du modèle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 196
Convention de nommage . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
Nos premiers attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
Quand on crée notre objet. . . . . . . . . . . . . . . . . . . . . . . . . . . 199
Étoffons un peu notre constructeur . . . . . . . . . . . . . . . . . . . . . 199
Attributs de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
Les méthodes, la recette . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
Le paramètre self . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
Un peu d’introspection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
La fonction dir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206
L’attribut spécial __dict__ . . . . . . . . . . . . . . . . . . . . . . . . 207

19 Les propriétés 209

Qu’est-ce que l’encapsulation ? . . . . . . . . . . . . . . . . . . . . . . . . . . 210
Les propriétés à la casserole . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
Les propriétés en action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
Une propriété en lecture seule . . . . . . . . . . . . . . . . . . . . . . . . 211
Une propriété en lecture et écriture . . . . . . . . . . . . . . . . . . . . . 215
Les attributs privés et les propriétés . . . . . . . . . . . . . . . . . . . . 218

XI
APPRENEZ À PROGRAMMER EN PYTHON

20 Les méthodes spéciales 221

Édition de l’objet et accès aux attributs . . . . . . . . . . . . . . . . . . . . . 222
Édition de l’objet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222
Représentation de l’objet . . . . . . . . . . . . . . . . . . . . . . . . . . 223
Accès aux attributs de notre objet . . . . . . . . . . . . . . . . . . . . . 225
Les méthodes de conteneur . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
Accès aux éléments d’un conteneur . . . . . . . . . . . . . . . . . . . . . 228
La méthode spéciale derrière le mot-clé in . . . . . . . . . . . . . . . . . 229
Connaître la taille d’un conteneur . . . . . . . . . . . . . . . . . . . . . . 229
Les méthodes mathématiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
Ce qu’il faut savoir . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
Tout dépend du sens . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
D’autres opérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 234
Les méthodes de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
Des méthodes spéciales utiles à pickle . . . . . . . . . . . . . . . . . . . . . 236
La méthode spéciale __getstate__ . . . . . . . . . . . . . . . . . . . 236
La méthode __setstate__ . . . . . . . . . . . . . . . . . . . . . . . . 237
On peut enregistrer dans un fichier autre chose que des dictionnaires . . 238
Je veux encore plus puissant ! . . . . . . . . . . . . . . . . . . . . . . . . 239

21 Parenthèse sur le tri en Python 241

Première approche du tri . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
Deux méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242
Aperçu des critères de tri . . . . . . . . . . . . . . . . . . . . . . . . . . 243
Trier avec des clés précises . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 243
L’argument key . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 244
Trier une liste d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . 246
Trier dans l’ordre inverse . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
Plus rapide et plus efficace . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 248
Les fonctions du module operator . . . . . . . . . . . . . . . . . . . . 248
Trier selon plusieurs critères . . . . . . . . . . . . . . . . . . . . . . . . . 249

22 L’héritage 253
Pour bien commencer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
L’héritage simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254

XII
 TABLE DES MATIÈRES

Petite précision . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 258

Appel d’une méthode parente avec super() . . . . . . . . . . . . . . . 258
Deux fonctions très pratiques . . . . . . . . . . . . . . . . . . . . . . . . 260
L’héritage multiple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 260
Recherche des méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
Retour sur les exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 261
Création d’exceptions personnalisées . . . . . . . . . . . . . . . . . . . . 262

23 Derrière la boucle for 265

Les itérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
Utiliser les itérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 266
Créons nos itérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 267
Les générateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
Les générateurs simples . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
Les générateurs comme coroutines . . . . . . . . . . . . . . . . . . . . . 271

24 TP : un jeu de cartes 275

Notre mission . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
Session d’utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
Explications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
Correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 278
Pour conclure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 281

25 Les décorateurs 283

Qu’est-ce que c’est ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
Syntaxe et exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
Un premier exemple : mesurer la durée de nos fonctions . . . . . . . . . 287
Des paramètres dans nos fonctions décorées . . . . . . . . . . . . . . . . 289
Des décorateurs avec des paramètres . . . . . . . . . . . . . . . . . . . . 290
La syntaxe sans classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
Quelques décorateurs courants . . . . . . . . . . . . . . . . . . . . . . . . . . 293
Les propriétés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
Les méthodes de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . 295
Les méthodes statiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . 296

XIII
APPRENEZ À PROGRAMMER EN PYTHON

Les classes de données (dataclasses) . . . . . . . . . . . . . . . . . . . . 297

26 Les métaclasses 301

Retour sur le processus d’instanciation . . . . . . . . . . . . . . . . . . . . . . 302
La méthode __new__ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
Créer une classe dynamiquement . . . . . . . . . . . . . . . . . . . . . . . . . 304
La méthode que nous connaissons . . . . . . . . . . . . . . . . . . . . . . 304
Créer une classe dynamiquement . . . . . . . . . . . . . . . . . . . . . . 305
Définition d’une métaclasse . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
La méthode __new__ . . . . . . . . . . . . . . . . . . . . . . . . . . . . 308
La méthode __init__ . . . . . . . . . . . . . . . . . . . . . . . . . . . 308
Les métaclasses en action . . . . . . . . . . . . . . . . . . . . . . . . . . 309
Pour conclure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 310

IV Les merveilles de la bibliothèque standard 313

27 Les expressions régulières 315

Que sont les expressions régulières ? . . . . . . . . . . . . . . . . . . . . . . . 316
Quelques éléments de syntaxe pour les expressions régulières . . . . . . . 316
Concrètement, comment cela se présente-t-il ? . . . . . . . . . . . . . . . 316
Des caractères ordinaires . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
Rechercher au début ou à la fin de la chaîne . . . . . . . . . . . . . . . . 317
Contrôler le nombre d’occurrences . . . . . . . . . . . . . . . . . . . . . 317
Les classes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
Les groupes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
Le module re . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 318
Chercher dans une chaîne . . . . . . . . . . . . . . . . . . . . . . . . . . 318
Remplacer une expression . . . . . . . . . . . . . . . . . . . . . . . . . . 321
Des expressions compilées . . . . . . . . . . . . . . . . . . . . . . . . . . 322

28 Le temps 325
Le module time . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326
Représenter une date et une heure dans un nombre unique . . . . . . . . 326
La date et l’heure de façon plus présentable . . . . . . . . . . . . . . . . 327
Récupérer un timestamp depuis une date . . . . . . . . . . . . . . . . . 328

XIV
 TABLE DES MATIÈRES

Mettre en pause l’exécution du programme pendant un temps déterminé 329

Formater un temps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329
Bien d’autres fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
Le module datetime . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
Représenter une date . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
Représenter une heure . . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
Représenter des dates et heures . . . . . . . . . . . . . . . . . . . . . . . 332
Différence de dates et durées . . . . . . . . . . . . . . . . . . . . . . . . . . . 332

29 Un peu de programmation système 335

Les flux standards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
Accéder aux flux standards . . . . . . . . . . . . . . . . . . . . . . . . . 336
Modifier les flux standards . . . . . . . . . . . . . . . . . . . . . . . . . . 337
Les signaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
Les différents signaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . 338
Intercepter un signal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 339
Interpréter les arguments de la ligne de commande . . . . . . . . . . . . . . . 340
Accéder à la console de Windows . . . . . . . . . . . . . . . . . . . . . . 341
Accéder aux arguments de la ligne de commande . . . . . . . . . . . . . 341
Interpréter les arguments de la ligne de commande . . . . . . . . . . . . 342
Exécuter une commande système depuis Python . . . . . . . . . . . . . . . . 347
La fonction system . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
La fonction popen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 348

30 Un peu de mathématiques 349

Pour commencer, le module math . . . . . . . . . . . . . . . . . . . . . . . . 350
Fonctions usuelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
Un peu de trigonométrie . . . . . . . . . . . . . . . . . . . . . . . . . . . 350
Arrondir un nombre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 351
Des fractions avec le module fractions . . . . . . . . . . . . . . . . . . . . 352
Créer une fraction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 352
Manipuler les fractions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
Du pseudo-aléatoire avec random . . . . . . . . . . . . . . . . . . . . . . . . 353
Du pseudo-aléatoire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354
La fonction random . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354

XV
APPRENEZ À PROGRAMMER EN PYTHON

randrange et randint . . . . . . . . . . . . . . . . . . . . . . . . . . 354

Opérations sur des séquences . . . . . . . . . . . . . . . . . . . . . . . . 355

31 Gestion des mots de passe 357

Obtenir un mot de passe saisi par l’utilisateur . . . . . . . . . . . . . . . . . . 358
Chiffrer un mot de passe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
Générer des mots de passe aléatoires . . . . . . . . . . . . . . . . . . . . . . . 363

32 Le réseau 367
Brève présentation du réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
Le protocole TCP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
Clients et serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 368
Les différentes étapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369
Établir une connexion . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369
Les sockets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370
Construire notre socket . . . . . . . . . . . . . . . . . . . . . . . . . . . 370
Connecter le socket . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370
Faire écouter notre socket . . . . . . . . . . . . . . . . . . . . . . . . . . 371
Accepter une connexion venant du client . . . . . . . . . . . . . . . . . . 371
Création du client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
Connecter le client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
Faire communiquer nos sockets . . . . . . . . . . . . . . . . . . . . . . . 372
Fermer la connexion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373
Le serveur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 373
Le client . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374
Un serveur plus élaboré . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 375
Le module select . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 376
Et encore plus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379

33 Les tests unitaires avec unittest 381

Pourquoi tester ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
Premiers exemples de tests unitaires . . . . . . . . . . . . . . . . . . . . . . . 383
Tester une fonctionnalité existante . . . . . . . . . . . . . . . . . . . . . 384
Les principales méthodes d’assertion . . . . . . . . . . . . . . . . . . . . 391
La découverte automatique des tests . . . . . . . . . . . . . . . . . . . . . . . 392

XVI
 TABLE DES MATIÈRES

Lancement de tests unitaires depuis un répertoire . . . . . . . . . . . . . 392

Structure d’un projet avec ses tests . . . . . . . . . . . . . . . . . . . . . 393

34 Déboguer son code avec pdb 395

Déboguer, ça sert à quoi ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
Parlons de bogues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
Le débogueur n’est pas un plus . . . . . . . . . . . . . . . . . . . . . . . 397
pdb pour remonter à la source d’erreurs . . . . . . . . . . . . . . . . . . . . . 397
Lancer pdb . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 398
Examiner le contexte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
Un remplacement de nom . . . . . . . . . . . . . . . . . . . . . . . . . . 402
Pour conclure, ou continuer . . . . . . . . . . . . . . . . . . . . . . . . . 405

35 La programmation parallèle avec threading 407

Création de threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
Premier exemple d’un thread . . . . . . . . . . . . . . . . . . . . . . . . 408
La synchronisation des threads . . . . . . . . . . . . . . . . . . . . . . . . . . 412
Opérations concurrentes . . . . . . . . . . . . . . . . . . . . . . . . . . . 412
Accès simultané à des ressources . . . . . . . . . . . . . . . . . . . . . . 413
Les verrous à la rescousse . . . . . . . . . . . . . . . . . . . . . . . . . . 414

36 La programmation asynchrone avec asyncio 417

La programmation asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . 418
Retour au code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
Pourquoi une tâche se mettrait-elle en attente ? . . . . . . . . . . . . . . 423
La puissance des tâches asynchrones . . . . . . . . . . . . . . . . . . . . . . . 424
Dépendances à installer . . . . . . . . . . . . . . . . . . . . . . . . . . . 424
Version synchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 425
Version asynchrone . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428
Quelques autres exemples . . . . . . . . . . . . . . . . . . . . . . . . . . 432

37 Des interfaces graphiques avec Tkinter 435

Présentation de Tkinter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 436
Votre première interface graphique . . . . . . . . . . . . . . . . . . . . . . . . 436
De nombreux widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 438

XVII
APPRENEZ À PROGRAMMER EN PYTHON

Les widgets les plus communs . . . . . . . . . . . . . . . . . . . . . . . . 438

Organiser ses widgets dans la fenêtre . . . . . . . . . . . . . . . . . . . . 441
Bien d’autres widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
Les commandes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442
Pour conclure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444

V Annexes 445

38 Écrire nos programmes Python dans des fichiers 447

Garder le code dans un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . 448
Exécuter notre code sur Windows . . . . . . . . . . . . . . . . . . . . . . 448
Sur les systèmes Unix . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449
Préciser l’encodage de travail . . . . . . . . . . . . . . . . . . . . . . . . . . . 450
Mettre notre programme en pause . . . . . . . . . . . . . . . . . . . . . . . . 450

39 Distribuer facilement nos programmes Python avec PyInstaller 453

En théorie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
Avantages de PyInstaller . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
En pratique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 454
Utiliser le script pyinstaller . . . . . . . . . . . . . . . . . . . . . . . 455

40 De bonnes pratiques 457

Pourquoi suivre les conventions des PEP ? . . . . . . . . . . . . . . . . . . . . 458
La PEP 20 : toute une philosophie . . . . . . . . . . . . . . . . . . . . . . . . 458
La PEP 8 : des conventions précises . . . . . . . . . . . . . . . . . . . . . . . 460
Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 460
Forme du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 460
Directives d’importation . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
Le signe espace dans les expressions et instructions . . . . . . . . . . . . 462
Commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464
Conventions de nommage . . . . . . . . . . . . . . . . . . . . . . . . . . 464
Conventions de programmation . . . . . . . . . . . . . . . . . . . . . . . 465
Conclusion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 466
La PEP 257 : de belles documentations . . . . . . . . . . . . . . . . . . . . . 466

XVIII
 TABLE DES MATIÈRES

Qu’est-ce qu’une docstring ? . . . . . . . . . . . . . . . . . . . . . . . . . 467

Les docstrings sur une seule ligne . . . . . . . . . . . . . . . . . . . . . . 467
Les docstrings sur plusieurs lignes . . . . . . . . . . . . . . . . . . . . . . 468

41 Installer et gérer nos dépendances en Python 471

Pourquoi apprendre à utiliser des dépendances en Python ? . . . . . . . . . . 472
Installer des dépendances avec pip . . . . . . . . . . . . . . . . . . . . . . . . 473
Avant de commencer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 473
La commande pip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474
Installons flask . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 475
Tester flask . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 476
Les environnements indépendants . . . . . . . . . . . . . . . . . . . . . . . . . 477
Créer un environnement indépendant (virtualenv) . . . . . . . . . . . . . 479
Activer notre environnement indépendant . . . . . . . . . . . . . . . . . 479
Installer une dépendance dans notre environnement indépendant . . . . 480

42 Pour finir et bien continuer 483

Quelques références . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484
La documentation officielle . . . . . . . . . . . . . . . . . . . . . . . . . 484
Le tutoriel officiel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484
Le wiki Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 485
L’index des PEP (Python Enhancement Proposal) . . . . . . . . . . . . 485
La documentation par version . . . . . . . . . . . . . . . . . . . . . . . . 485
Des bibliothèques tierces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 486
Pour créer une interface graphique . . . . . . . . . . . . . . . . . . . . . 486
Dans le monde du Web . . . . . . . . . . . . . . . . . . . . . . . . . . . 486
Un peu de réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487
Pour conclure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 487

Index 489

XIX
 Première partie

Introduction à Python
Chapitre 1
Qu’est-ce que Python ?

Difficulté :

ous avez décidé d’apprendre Python et je ne peux que vous en féliciter. J’essaierai
V d’anticiper vos questions et de ne laisser personne en arrière.
Dans ce chapitre, je vais d’abord vous expliquer ce qu’est un langage de programmation.
Nous verrons ensuite brièvement l’histoire de Python, afin que vous sachiez au moins d’où
vient ce langage ! Ce chapitre est théorique mais je vous conseille vivement de le lire quand
même.
La dernière section portera sur l’installation de Python, une étape essentielle pour continuer
ce cours. Que vous travailliez avec Windows, Linux ou macOS, vous y trouverez des
explications précises sur l’installation.
Allez, on attaque !
INTRODUCTION À PYTHON

Un langage de programmation ? Qu’est-ce que c’est ?

La communication humaine
Non, ceci n’est pas une explication biologique ou philosophique, ne partez pas ! Très
simplement, si vous arrivez à comprendre ces suites de symboles étranges et déconcertants
que sont les lettres de l’alphabet, c’est parce que nous respectons certaines conventions,
dans le langage et dans l’écriture. En français, il y a des règles de grammaire et
d’orthographe, je ne vous apprends rien. Vous communiquez en connaissant plus ou
moins consciemment ces règles et en les appliquant plus ou moins bien, selon les cas.
Cependant, ces règles peuvent être aisément contournées : personne ne peut prétendre
connaître l’ensemble des règles de la grammaire et de l’orthographe françaises, et peu
de gens s’en soucient. Après tout, même si vous faites des fautes, les personnes avec qui
vous communiquez pourront facilement vous comprendre. Quand on communique avec
un ordinateur, cependant, c’est très différent.

Mon ordinateur communique aussi !

Eh oui, votre ordinateur communique sans cesse avec vous et vous communiquez sans
cesse avec lui. D’accord, il vous dit très rarement qu’il a faim, que l’été s’annonce
caniculaire et que le dernier disque de ce groupe très connu était à pleurer. Il n’y a rien
de magique si, quand vous cliquez sur la petite croix en haut à droite de l’application
en cours, celle-ci comprend qu’elle doit se fermer.

Le langage machine

En fait, votre ordinateur se fonde aussi sur un langage pour communiquer avec vous
ou avec lui-même. Les opérations qu’un ordinateur peut effectuer à la base sont des
plus classiques : l’addition de deux nombres, leur soustraction, leur multiplication, leur
division, entière ou non. Et pourtant, ces cinq opérations suffisent amplement à faire
fonctionner les logiciels de simulation les plus complexes ou les jeux super-réalistes.
Tous ces logiciels fonctionnent en gros de la même façon :
— une suite d’instructions écrites en langage machine compose le programme ;
— lors de l’exécution du programme, ces instructions décrivent à l’ordinateur ce
qu’il faut faire (l’ordinateur ne peut pas le deviner).

Une liste d’instructions ? Qu’est-ce que c’est encore que cela ?

En schématisant volontairement, une instruction pourrait demander au programme de

se fermer si vous cliquez sur la croix en haut à droite de votre écran, ou de rester en
tâche de fond si tel est son bon plaisir. Toutefois, en langage machine, une telle action
demande à elle seule un nombre assez important d’instructions. Mais bon, vous pouvez

4
 CHAPITRE 1. QU’EST-CE QUE PYTHON ?

vous en douter, parler avec l’ordinateur en langage machine, qui ne comprend que le
binaire, ce n’est ni très enrichissant, ni très pratique et en tout cas pas très drôle. On
a donc inventé des langages de programmation pour faciliter la communication avec
l’ordinateur.

Le langage binaire est uniquement constitué de 0 et de 1.

« 01000010011011110110111001101010011011110111010101110010 », par
exemple, signifie « Bonjour ». Bref, autant vous dire que discuter en binaire
avec un ordinateur peut être long (surtout pour vous).

Les langages de programmation

Les langages de programmation sont bien plus faciles à comprendre pour nous, pauvres
êtres humains que nous sommes. Le mécanisme reste le même, mais le langage est bien
plus compréhensible. Au lieu d’écrire les instructions dans une suite assez peu intelligible
de 0 et de 1, les ordres donnés à l’ordinateur sont écrits dans un « langage », souvent en
anglais, avec une syntaxe particulière qu’il est nécessaire de respecter. Toutefois, avant
que l’ordinateur puisse comprendre ces instructions, celles-ci doivent être traduites en
langage machine (figure 1.1).

Figure 1.1 – Traduction d’un programme en langage binaire

En gros, le programmeur « n’a qu’à » écrire des lignes de code dans le langage qu’il
a choisi, les étapes suivantes sont automatisées pour permettre à l’ordinateur de les
décoder.
Il existe un grand nombre de langages de programmation et Python en fait partie. Il
n’est pas nécessaire pour le moment de donner plus d’explications sur ces mécanismes
très schématisés. Si vous n’avez pas réussi à comprendre les mots de vocabulaire et
l’ensemble de ces explications, cela ne vous pénalisera pas pour la suite. Néanmoins, je
trouve intéressant de donner ces précisions quant aux façons de communiquer avec son
ordinateur.

Pour la petite histoire

La première version de Python est sortie en 1991. Créé par Guido van Rossum, il a
voyagé du Macintosh de son créateur, qui travaillait à cette époque au Centrum voor

5
INTRODUCTION À PYTHON

Wiskunde en Informatica aux Pays-Bas, jusqu’à se voir associer une organisation à

but non lucratif particulièrement dévouée, la Python Software Foundation, créée en
2001. Ce langage a été baptisé ainsi en hommage à la troupe de comiques les « Monty
Python ».

À quoi peut servir Python ?

Python est un langage puissant, à la fois facile à apprendre et riche en possibilités.
Dès l’instant où vous l’installez sur votre ordinateur, vous disposez de nombreuses
fonctionnalités intégrées que nous allons découvrir tout au long de ce livre.
Il est, en outre, très facile d’étendre les fonctionnalités existantes, comme nous allons
le voir. Ainsi, il existe ce qu’on appelle des bibliothèques qui aident le développeur à
travailler sur des projets particuliers. Plusieurs bibliothèques peuvent être installées
pour, par exemple, développer des interfaces graphiques en Python.
Concrètement, voilà ce qu’on peut faire avec Python :
— de petits programmes très simples, appelés scripts, chargés d’une mission très
précise sur votre ordinateur ;
— des programmes complets, comme des jeux, des suites bureautiques, des logiciels
multimédias, des clients de messagerie. . .
— des projets très complexes, comme des progiciels (groupes de plusieurs logiciels
fonctionnant ensemble, principalement utilisés dans le monde professionnel).
Voici quelques-unes des fonctionnalités offertes par Python et ses bibliothèques :
— créer des interfaces graphiques ;
— faire circuler des informations au travers d’un réseau ;
— dialoguer d’une façon avancée avec votre système d’exploitation ;
— créer et héberger un site web dynamique ;
— et bien d’autres. . .
Bien entendu, vous n’allez pas apprendre tout cela en quelques minutes. Ce cours vous
donnera des bases suffisamment larges pour développer des projets qui deviendront, par
la suite, assez importants.

Un langage de programmation interprété

Eh oui, vous allez devoir patienter encore un peu car il me reste deux ou trois choses
à vous expliquer et il est important de connaître un minimum ces détails qui peuvent
sembler peu pratiques de prime abord. Python est un langage de programmation
interprété, c’est-à-dire que les instructions que vous lui envoyez sont « transcrites » en
langage machine au fur et à mesure de leur lecture. D’autres langages (comme le C /
C++) sont appelés « langages compilés » car, avant de pouvoir les exécuter, un logiciel
spécialisé se charge de transformer le code du programme en langage machine. On
appelle cette étape la « compilation ». À chaque modification du code, il faut rappeler
une étape de compilation.

6
 CHAPITRE 1. QU’EST-CE QUE PYTHON ?

Les avantages d’un langage interprété sont la simplicité (on ne passe pas par une étape
de compilation avant d’exécuter son programme) et la portabilité (un langage tel que
Python est censé fonctionner aussi bien sous Windows que sous Linux ou macOS et on
ne devrait avoir à effectuer aucun changement dans le code pour le passer d’un système à
l’autre). Cela ne veut pas dire que les langages compilés ne sont pas portables, loin de là !
Toutefois, on doit souvent utiliser des compilateurs différents et, d’un système à l’autre,
certaines instructions ne sont pas compatibles, voire se comportent différemment.
En contrepartie, un langage compilé se révélera bien plus rapide qu’un langage interprété
(la traduction à la volée de votre programme ralentit l’exécution), bien que cette
différence tende à se faire de moins en moins sentir au fil des améliorations. De plus,
il faudra installer Python sur le système d’exploitation que vous utilisez pour que
l’ordinateur comprenne votre code.

Différentes versions de Python

Lors de la création de la Python Software Foundation, en 2001, et durant les années
qui ont suivi, le langage est passé par une suite de versions que l’on a englobées dans
l’appellation Python 2.x (2.3, 2.5, 2.6. . .). Depuis le 13 février 2009, la version 3.0.1
est disponible. Elle casse la compatibilité ascendante qui prévalait lors des dernières
versions.

Compatibilité quoi ?

Quand un langage de programmation est mis à jour, les développeurs se gardent

bien de supprimer ou de trop modifier d’anciennes fonctionnalités. L’intérêt est qu’un
programme qui fonctionne sous une certaine version marchera toujours avec la nouvelle
version en date. Cependant, la Python Software Foundation, observant un bon nombre
de fonctionnalités obsolètes, mises en œuvre plusieurs fois. . . a décidé de nettoyer tout
le projet. Un programme qui tourne à la perfection sous Python 2.x devra donc être mis
à jour un minimum pour fonctionner de nouveau sous Python 3. C’est pourquoi je vais
vous conseiller ultérieurement de télécharger et d’installer la dernière version en date de
Python. Je m’attarderai en effet sur les fonctionnalités de Python 3 et certaines d’entre
elles ne seront pas accessibles (ou pas sous le même nom) dans les anciennes versions.
Notons que la branche 2.x de Python n’est plus mise à jour depuis 2020. Vous pourrez
toujours apprendre et utiliser Python dans cette version, mais les bogues rencontrés ne
seront plus corrigés. C’est une raison supplémentaire de passer à Python 3.
Ceci étant posé, tous à l’installation !

7
INTRODUCTION À PYTHON

Installer Python
L’installation de Python est un jeu d’enfant,
aussi bien sous Windows que sous les systèmes 
Site officiel de Python
Unix. Quel que soit votre système d’exploitation, ▷
Code web : 199501
vous devez vous rendre sur le site officiel de
Python.

Sous Windows
1. Dans la section Download (téléchargement), vous devriez voir la version la plus
récente de Python (3.10.0 à l’heure où j’écris ces lignes). Cliquez sur le numéro
de version.
2. On vous propose un (ou plusieurs) lien(s) : sélectionnez la version qui conviendra
à votre processeur. Si vous avez un doute, téléchargez une version « x86 ».
3. Enregistrez puis exécutez le fichier d’installation et suivez les étapes. Ce n’est ni
très long ni très difficile.
4. Une fois l’installation terminée, vous pouvez vous rendre dans le menu Démarrer
> Tous les programmes. Python devrait apparaître dans cette liste (figure
1.2). Nous verrons bientôt comment le lancer, pas d’impatience. . .

Figure 1.2 – Python est installé sous Windows

8
 CHAPITRE 1. QU’EST-CE QUE PYTHON ?

Sous Linux
Python est pré-installé sur la plupart des distributions Linux. Cependant, il est possible
que vous n’ayez pas la dernière version en date. Pour le vérifier, tapez dans un terminal
la commande python -V. Elle vous renvoie la version de Python actuellement installée
sur votre système.
Cliquez sur download et téléchargez la dernière version de Python (actuellement
« Python 3.10 gzipped source tarball (for Linux, Unix or OS X) »). Ouvrez un terminal,
puis rendez-vous dans le dossier où se trouve l’archive :

1. Décompressez l’archive en tapant : tar -xzf [Link] (cette

commande est bien entendu à adapter suivant la version et le type de compres-
sion).
2. Attendez quelques instants que la décompression se termine, puis rendez-vous
dans le dossier qui vient d’être créé dans le répertoire courant (Python-3.10.0
dans mon cas).
3. Exécutez le script configure en tapant ./configure dans la console.
4. Une fois que la configuration s’est déroulée, il n’y a plus qu’à compiler en tapant
make puis make install en tant que super-utilisateur.

Sous macOS
Téléchargez la dernière version de Python. Ouvrez le fichier .dmg et double-cliquez sur
le paquet d’installation [Link]. Un assistant d’installation s’ouvre, laissez-vous
guider : Python est maintenant installé !

Lancer Python
Ouf ! Voilà qui est fait !
Bon, en théorie, on commence à utiliser Python dès le prochain chapitre mais, pour
que vous soyez un peu récompensés de votre installation exemplaire, voici les différents
moyens d’accéder à la ligne de commande Python que nous allons tout particulièrement
étudier dans les prochains chapitres.

Sous Windows

Vous avez plusieurs façons d’accéder à la ligne de commande Python, la plus évidente
consistant à passer par les menus Démarrer > Tous les programmes > Python
3.10 > Python (Command Line). Si tout se passe bien, vous devriez obtenir une
magnifique console (figure 1.3). Il se peut que les informations affichées dans la vôtre ne
soient pas les mêmes, mais ne vous en inquiétez pas.

9
INTRODUCTION À PYTHON

Figure 1.3 – La console Python sous Windows

Qu’est-ce que c’est que cela ?

On verra plus tard. L’important, c’est que vous ayez réussi à ouvrir la console d’inter-
prétation de Python ; le reste attendra le prochain chapitre.
Vous pouvez également passer par la ligne de commande Windows ; à cause des raccourcis,
je privilégie en général cette méthode, mais c’est une question de goût. Allez dans le menu
Démarrer, puis cliquez sur Exécuter. Dans la fenêtre qui apparaît, tapez simplement
python et la ligne de commande devrait s’afficher de nouveau. Sachez   pouvez
que vous 
directement vous rendre dans Exécuter en tapant le raccourci Windows + R .
Sous Windows 8 ou 10, vous pouvez tout simplement rechercher python. Cliquez sur le
menu Démarrer et tapez python. Windows devrait vous proposer la version installée
en premier choix.

Pour fermer 
l’interpréteur de commandes Python, tapez exit() puis appuyez sur la
touche Entrée .

Sous Linux

Lorsque vous l’avez installé sur votre système, Python a créé un lien vers l’interpréteur
sous la forme python3.X (le X étant le numéro de la version installée).
Si, par exemple, vous avez installé Python 3.10, vous pouvez y accéder grâce à la
commande :

10
 CHAPITRE 1. QU’EST-CE QUE PYTHON ?

1 $ python3.10
2 Python 3.10.0 (default, Dec 1 2021, 13:28:04) [GCC 9.3.0] on
,→ linux
3 Type "help", "copyright", "credits" or "license" for more
,→ information.
4 >>>
   
Pour fermer la ligne de commande Python, n’utilisez pas CTRL
+ C
mais CTRL
+ D

(nous verrons plus tard pourquoi).

Sous macOS

Cherchez un dossier Python dans le dossier Applications. Pour lancer le programme,

ouvrez l’application IDLE de ce dossier. Vous êtes prêts à passer au concret !

En résumé
— Python est un langage de programmation interprété, à ne pas confondre avec un
langage compilé.
— Il permet de créer toutes sortes de programmes, comme des jeux, des logiciels,
des progiciels, etc.
— Il est possible d’associer des bibliothèques à Python afin d’étendre ses possibilités.
— Il est portable, c’est-à-dire qu’il peut fonctionner sous différents systèmes d’ex-
ploitation (Windows, Linux, macOS).

11