ISBS B1-ST01 : programmation Python Tutoriel

ISBS B1-ST01 : programmation Python
Tutoriel
Traduit et adapté de :
The Python Tutorial
© Copyright 1990-2015, Python Software Foundation.
https://docs.python.org/3.4/tutorial/index.html
Jean-Claude GEORGES Année scolaire 2016–2017

Table des matières
1 Pour vous ouvrir l’appétit 1
2 Utilisation de l’interpréteur Python 3
2.1 Lancer l’interpréteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2.1.1 Passage d’arguments ........................................ 4
2.1.2 Mode interactif ............................................ 4
2.2 L’interpréteur et son environnement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2.1 Encodage du texte des programmes sources .......................... 4
3 Introduction informelle à Python 7
3.1 Utiliser Python comme une calculatrice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.1.1 Nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.1.2 Chaînes de caractères ........................................ 8
3.1.3 Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
3.2 Premiers pas vers la programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
4 Contrôle des instructions 15
4.1 La conditionnelle if . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
4.2 La boucle for ................................................. 15
4.3 La fonction range() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
4.4 Les instructions break et continue et la clause else sur les boucles . . . . . . . . . . . . . . . . . 16
4.5 L’instruction pass . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
4.6 Définitions de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.7 Plus loin dans les définitions de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.7.1 Arguments avec valeur par défaut ................................. 19
4.7.2 Arguments par mots-clefs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.7.3 Arguments récupérés dans un tuple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.7.4 Déballer une liste d’arguments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.7.5 Lambda-expressions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.7.6 Chaînes de documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.7.7 Annotations de fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
4.8 Intermède : style de codage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
5 Structures de données 25
5.1 Aller plus loin avec les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
5.1.1 Utiliser des listes en tant que piles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
5.1.2 Utiliser des listes en tant que files ................................. 26
5.1.3 Listes en compréhension . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
5.1.4 Listes en compréhension imbriquées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
5.2 L’instruction del . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
5.3 Tuples et séquences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5.4 Ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5.5 Dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
5.6 Techniques de boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
5.7 Plus sur les conditions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
5.8 Comparer des séquences ou d’autres types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
6 Modules 35
6.1 En savoir plus sur les modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
6.1.1 Exécuter des modules en tant que scripts . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
6.1.2 Comment Python cherche les modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
6.1.3 Fichiers Python "compilés" . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
6.2 Modules standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
I

II TABLE DES MATIÈRES
6.3 La fonction dir() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
6.4 Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
6.4.1 Importer *d’un package . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
6.4.2 Référence intra-package . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
6.4.3 Packages multi-répertoires ..................................... 41
7 Entrées et sorties 43
7.1 Formatage raffiné de sortie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
7.1.1 Formatage de chaînes à l’ancienne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
7.2 Lire et écrire dans des fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
7.2.1 Méthodes sur les objets fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
7.3 Sauvegarde de données structurées avec json . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
8 Erreurs et exceptions 49
8.1 Les erreurs de syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
8.2 Exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
8.3 Gérer les exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
8.4 Lancer des exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
8.5 Exceptions définies par l’utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
8.6 Définir des actions de nettoyage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
8.7 Actions de nettoyage prédéfinies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
9 Classes 55
9.1 Un mot sur les noms et les objets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
9.2 Portées et espaces de noms dans Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
9.2.1 Exemple de portée et d’espace de noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
9.3 Un premier coup d’œil aux classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
9.3.1 Syntaxe de définition de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
9.3.2 Objets classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
9.3.3 Objets instance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
9.3.4 Objets méthode . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
9.3.5 Variables de classe et variables d’instance . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
9.4 Quelques remarques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
9.5 Héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
9.5.1 Héritage multiple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
9.6 Variables privées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
9.7 Un peu de tout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
9.8 Les exceptions sont aussi des classes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
9.9 Itérateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
9.10 Générateurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
9.11 Expressions génératrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
10 Visite de la bibliothèque standard 67
10.1 Interface système . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
10.2 Caractères joker pour fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
10.3 Arguments de la ligne de commande . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
10.4 Redirection de la sortie d’erreurs et terminaison de programme . . . . . . . . . . . . . . . . . . . 68
10.5 Correspondance de motifs de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
10.6 Mathématiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
10.7 Accès à Internet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
10.8 Date et heure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
10.9 Compression de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
10.10 Mesure de performances . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
10.11 Contrôle qualité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
10.12 Piles fournies . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
11 Seconde visite de la bibliothèque standard 73
11.1 Formatage de sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
11.2 Modèles de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
11.3 Gérer des données binaires structurées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
11.4 Multi-threading . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
11.5 Journalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
11.6 Références faibles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
11.7 Utilitaires pour les listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

TABLE DES MATIÈRES
11.8 Arithmétique en virgule flottante décimale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
12 Environnements virtuels et packages 79
12.1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
12.2 Création d’environnements virtuels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79
12.3 Gestion des packages avec pip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
13 Comment aller plus loin ? 83
14 Édition de ligne de commande et historique 85
14.1 Complétion automatique et historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
14.2 Alternatives à l’interpréteur interactif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
15 Arithmétique en virgule flottante : problèmes et limitations 87
15.1 Erreur de représentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
16 Appendice 91
16.1 Mode interactif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
16.1.1 Gestion d’erreur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
16.1.2 Scripts Python exécutables ..................................... 91
16.1.3 Le fichier de démarrage interactif ................................. 91
16.1.4 Les modules de personnalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
A GLOSSAIRE 93
B ABOUT THESE DOCUMENTS 103
B.1 Contributors to the Python Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 103
C HISTORY AND LICENSE 105
C.1 History of the software . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
C.2 Terms and conditions for accessing or otherwise using Python . . . . . . . . . . . . . . . . . . . . 105
D COPYRIGHT 109