N OTES DE COURS

Langage et Programmation Informatiques :

Initiation à la Programmation Python

Dr Ing Mahugnon Géraud AZEHOUN PAZOU

Université Nationale des Sciences, Technologies et Ingénierie Mathématiques
(UNSTIM)
Institut National Supérieur des Classes Préparatoires aux études d’Ingénieur
(INSPEI)

Dernière mise à jour : 30 mai 2025

Initiation à la Programmation Python
Support de cours

Dr Ing Mahugnon Géraud AZEHOUN PAZOU

Copyright © 2025

T OUTE UTILISATION DE CE DOCUMENT À DES FINS COMMERCIALES EST INTERDITE .

 Table des matières

Avant-propos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

1 Introduction à Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.1 Présentation de Python : origines et applications . . . . . . . . . . . . . . . . . . . 13
1.1.1 Origines de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
1.1.2 Caractéristiques de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
1.1.3 Applications de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

1.2 Installation et configuration : Python, VSCode . . . . . . . . . . . . . . . . . . . . . . 15

1.2.1 Étape 1 : Installation de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.2.2 Étape 2 : Installation de Visual Studio Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15

1.2.3 Étape 3 : Configuration de VSCode pour Python . . . . . . . . . . . . . . . . . . . . . . . . . . 16

1.3 Un premier programme Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

1.3.1 Qu’est-ce qu’un programme Python ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.3.2 Un premier programme simple . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

1.4 Shell interactif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

1.4.1 Qu’est-ce que le shell interactif ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.4.2 Accéder au shell interactif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.4.3 Utiliser le shell interactif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
1.4.4 Commandes utiles dans le shell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

1.5 Syntaxe de base : commentaires, indentation, PEP 8 . . . . . . . . . . . . . . . . 19

1.5.1 Les commentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.5.2 L’indentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
1.5.3 PEP 8 : Guide de style pour Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.6 Erreurs courantes : SyntaxError, NameError, TypeError . . . . . . . . . . . . . . 20
1.6.1 Qu’est-ce qu’une erreur en Python ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.6.2 Erreur 1 : SyntaxError . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.6.3 Erreur 2 : NameError . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
1.6.4 Erreur 3 : TypeError . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

2 Variables, types et entrées/sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

2.1 Variables et types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.1.1 Déclaration et affectation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
2.1.2 Types fondamentaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.1.3 Opérations arithmétiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.1.4 Conversion de types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
2.1.5 Notation scientifique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

2.2 Chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

2.2.1 Définition, délimiteurs, échappement, chaînes brutes . . . . . . . . . . . . . . . . . . . . . . . 30
2.2.2 Opérations sur les chaînes : concaténation, répétition, indexation, découpage . . . . . 31
2.2.3 Formatage : format(), f-strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

2.3 Entrées/sorties . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
2.3.1 Fonction print() : paramètres sep, end . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
2.3.2 Fonction input() : lecture de chaînes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

3 Structures de contrôle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.1 Opérateurs de comparaison et logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.1.1 Opérateurs de comparaison . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.1.2 Opérateurs logiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
3.1.3 Opérateur in . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

3.2 Instructions conditionnelles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

3.2.1 Syntaxe de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.2.2 Utilisation de else . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.2.3 Utilisation de elif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
3.2.4 Conditions imbriquées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45

3.3 Boucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.3.1 Boucle for et fonction range() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
3.3.2 Boucle while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

3.4 Contrôle des boucles : break, continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50

3.4.1 Utilisation de break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.4.2 Utilisation de continue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.5 Introduction aux exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.5.1 Qu’est-ce qu’une exception ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
3.5.2 Syntaxe de try-except . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.5.3 Capturer plusieurs exceptions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.5.4 Capturer toutes les exceptions (approche générique) . . . . . . . . . . . . . . . . . . . . . . . 53
3.5.5 Subtilités et bonnes pratiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

4 Collections de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.1 Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.1.1 Création, indexation, slicing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.1.2 Méthodes de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4.1.3 Listes imbriquées et copie de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
4.1.4 Parcours des listes avec la boucle for . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65

4.2 Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
4.2.1 Création et syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
4.2.2 Immutabilité des tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
4.2.3 Accès aux éléments et slicing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
4.2.4 Déballage des tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
4.2.5 Cas d’usage des tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
4.2.6 Opérations sur les tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69

4.3 Dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.3.1 Création et syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70
4.3.2 Accès aux valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.3.3 Modification et ajout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
4.3.4 Suppression d’éléments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
4.3.5 Itération sur les dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
4.3.6 Comparaison avec les listes et tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

4.4 Ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
4.4.1 Création et syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
4.4.2 Ajout et suppression d’éléments . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
4.4.3 Opérations ensemblistes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.4.4 Tests d’appartenance et relations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
4.4.5 Frozenset : ensembles immuables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
4.4.6 Cas d’usage des ensembles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76

4.5 Utilitaires et compréhensions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77

4.5.1 Fonctions utilitaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
4.5.2 Compréhensions de listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
4.5.3 Compréhensions de dictionnaires et d’ensembles . . . . . . . . . . . . . . . . . . . . . . . . . 80

5 Fonctions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.1 Définition et appel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81

5.2 Paramètres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
5.2.1 Paramètres positionnels, mot-clé, valeurs par défaut . . . . . . . . . . . . . . . . . . . . . . . 83
5.2.2 Paramètres variables : *args, **kwargs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

5.3 Valeurs de retour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87

5.3.1 Utilisation du mot-clé return . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
5.3.2 Retour d’une seule valeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
5.3.3 Retour de plusieurs valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
5.3.4 Fonctions sans retour explicite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89

5.4 Portée des variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90

5.4.1 Portée locale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
5.4.2 Portée globale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
5.4.3 Modification des variables globales avec global . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
5.4.4 Portée non locale avec nonlocal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
5.4.5 Règle LEGB : Résolution des noms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92

5.5 Fonctions récursives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93

5.6 Fonctions anonymes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

5.6.1 Syntaxe et création . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94
5.6.2 Utilisation avec les fonctions intégrées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96

6 Modules et fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
6.1 Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
6.1.1 Syntaxe : import, from, as . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99
6.1.2 Modules standards . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
6.1.3 Obtenir de l’aide sur les modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 106
6.1.4 Modules externes : installation avec pip . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108

6.2 Programmation modulaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109

6.2.1 Création de modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
6.2.2 Docstrings et documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 112

6.3 Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114

6.3.1 open(), contexte with . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
6.3.2 Méthodes de lecture : read, readline, readlines . . . . . . . . . . . . . . . . . . . . . . . . . . 116
6.3.3 Modes : r, w, a, rb, wb . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
7 Bibliothèques scientifiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
7.1 Introduction aux bibliothèques scientifiques . . . . . . . . . . . . . . . . . . . . . . 119
7.1.1 Rôle des bibliothèques dans les sciences et l’ingénierie . . . . . . . . . . . . . . . . . . . . 119
7.1.2 Aperçu des bibliothèques : NumPy, Matplotlib et Pandas . . . . . . . . . . . . . . . . . . . 119
7.1.3 Installation des bibliothèques : outils et vérification . . . . . . . . . . . . . . . . . . . . . . . . 120

7.2 NumPy : fondations des calculs numériques . . . . . . . . . . . . . . . . . . . . . . 121

7.2.1 Concepts de base : tableaux et matrices dans NumPy . . . . . . . . . . . . . . . . . . . . . 121
7.2.2 Opérations sur les tableaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
7.2.3 Indexation et slicing : accès aux éléments des tableaux . . . . . . . . . . . . . . . . . . . . 129
7.2.4 Fonctions universelles : opérations mathématiques vectorisées . . . . . . . . . . . . . . 132
7.2.5 Algèbre linéaire et statistiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133

7.3 Matplotlib : visualisation des données scientifiques . . . . . . . . . . . . . . . . 139

7.3.1 Concepts de base : premiers pas avec Matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . 139
7.3.2 Personnalisation des graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
7.3.3 Types de graphiques courants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152
7.3.4 Gestion de multiples graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 156
7.3.5 Sauvegarde et exportation des graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 160

7.4 Pandas : manipulation et analyse des données . . . . . . . . . . . . . . . . . . . . 161

7.4.1 Introduction à Pandas et ses structures de données . . . . . . . . . . . . . . . . . . . . . . . 161
7.4.2 Importation et exploration des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 164
7.4.3 Manipulation des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
7.4.4 Analyse des données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
7.4.5 Gestion des données manquantes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
7.4.6 Fusion et jointure de datasets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
7.4.7 Exportation des résultats . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186

8 Introduction à la programmation orientée objet . . . . . . . . . . . . . . . . 189

8.1 Classes, objets, attributs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
8.1.1 Création d’une classe et instanciation d’objets . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
8.1.2 Attributs d’instance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
8.1.3 Attributs de classe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192

8.2 Constructeur __init__ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194

8.2.1 Rôle et syntaxe du constructeur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194

8.3 Méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197

8.3.1 Méthodes d’instance . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
8.3.2 Méthode spéciale : __str__ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
10

8.4 Introduction à l’héritage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201

8.4.1 Concepts de base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 201
8.4.2 Réutilisation des méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
8.4.3 Redéfinition des méthodes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
8.4.4 Extension avec super() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 Avant-propos

Contexte et objectifs du cours

Ce cours s’adresse à vous, étudiants de première année universitaire, qui découvrez la program-
mation ou souhaitez consolider vos bases en informatique. La programmation est une compétence
essentielle dans de nombreux domaines : sciences, ingénierie, économie, santé et bien d’autres.
Python, le langage choisi pour ce cours, est adapté à l’apprentissage grâce à sa syntaxe claire, sa
polyvalence et sa popularité dans les communautés académiques et professionnelles.
L’objectif principal de ce cours est de vous fournir une compréhension solide des concepts fon-
damentaux de la programmation à travers Python. Vous apprendrez à écrire des programmes
structurés, à résoudre des problèmes de manière logique et à appliquer vos connaissances à des
projets concrets. Chaque chapitre est conçu pour être progressif, avec des explications claires et des
exercices qui renforcent votre apprentissage. À la fin de ce cours, vous serez capables de concevoir
des programmes pertinents et de poursuivre votre exploration de la programmation avec confiance.

Prérequis
Aucun prérequis en programmation n’est requis pour suivre ce cours. Une familiarité de base avec
l’utilisation d’un ordinateur et des notions en algorithmique suffisent.

Conseils pour réussir

Apprendre à programmer demande de la pratique et de la patience. Voici quelques recommanda-
tions :

• Expérimentez : Testez les exemples de code fournis et modifiez-les pour mieux comprendre
leur fonctionnement.
• Posez des questions : Les erreurs sont une partie normale de l’apprentissage. Analysez les
messages d’erreur et cherchez des solutions.
• Progressez à votre rythme : Chaque concept s’appuie sur les précédents. Assurez-vous de
maîtriser les bases avant de passer aux notions avancées.
• Utilisez les ressources : Consultez la documentation officielle ou des plateformes comme
12

Real Python 1 et W3Schools 2 pour approfondir vos connaissances.

N’oubliez pas : la programmation demande de la pratique. Prenez le temps d’écrire et de tester vos
programmes et n’hésitez pas à expérimenter vos propres solutions aux problèmes. Les erreurs font
partie intégrante de l’apprentissage : elles vous aideront à mieux comprendre le fonctionnement du
langage.
Ce cours est conçu pour vous accompagner dans votre découverte de la programmation. Avec de la
curiosité et de la persévérance, vous développerez des compétences précieuses et applicables à de
nombreux contextes.

1. [Link]
2. [Link]

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 1. Introduction à Python

1.1 Présentation de Python : origines et applications

Python est un langage de programmation de haut niveau, créé en 1991 par Guido van Rossum,
qui se distingue par sa simplicité, sa lisibilité et sa polyvalence. Son nom, inspiré par le groupe
comique britannique Monty Python, reflète l’esprit accessible et convivial que son créateur a voulu
insuffler. Depuis sa création, Python a évolué pour devenir l’un des langages les plus utilisés dans
le monde, tant dans l’enseignement que dans l’industrie et la recherche scientifique.
Un langage de programmation de haut niveau est un langage conçu pour être compréhensible
par les humains, avec une syntaxe proche du langage naturel, contrairement aux langages de bas
niveau, qui sont plus proches du fonctionnement des machines. Python privilégie la clarté et la
concision, ce qui le rend idéal pour les débutants.
Cette section présente les origines de Python, ses principales caractéristiques et ses applications
dans divers domaines. Vous découvrirez pourquoi Python est un choix privilégié pour apprendre à
programmer et comment il peut être utilisé dans des contextes concrets.

1.1.1 Origines de Python

Guido van Rossum a développé Python pour répondre à un besoin de langage simple et efficace,
capable de faciliter le développement de logiciels tout en restant puissant. La première version
publique, Python 0.9.0, est sortie en février 1991. Depuis, Python a connu plusieurs évolutions
majeures, notamment le passage à Python 3 en 2008, qui a introduit des améliorations significatives
tout en rompant partiellement la compatibilité avec Python 2 (désormais obsolète depuis 2020) 1 .
Aujourd’hui, Python est maintenu par une communauté mondiale et bénéficie de mises à jour
régulières, avec des versions comme Python 3.10 et supérieures intégrant des fonctionnalités
modernes.
Python est un langage open-source, ce qui signifie que son code source est librement accessible,
modifiable et distribué. Cette ouverture a favorisé le développement d’une vaste communauté
de contributeurs qui enrichissent le langage avec des bibliothèques et des outils, rendant Python
adaptable à une multitude de besoins.

1. Pour plus de détails sur l’histoire de Python, consultez [Link]

word/.
 14 Chapitre 1. Introduction à Python

1.1.2 Caractéristiques de Python

Python se distingue par plusieurs caractéristiques qui en font un langage particulièrement adapté à
l’apprentissage et à l’utilisation professionnelle. Voici les principales :
• Python privilégie une syntaxe concise, claire et lisible, où l’indentation structure les blocs de
code. Cela réduit la complexité visuelle et aide à produire un code facilement compréhensible.
• Python est un langage généraliste, utilisable pour des applications variées : développement
web, analyse de données, cybersécurité, intelligence artificielle, automatisation de tâches et
bien plus encore. Cette polyvalence est renforcée par une riche bibliothèque standard et des
modules externes.
• Python est un langage interprété, ce qui signifie que le code est exécuté ligne par ligne par un
interpréteur sans nécessiter de compilation préalable, à l’opposé des langages comme C/C++.
Cela permet un développement rapide et une exécution immédiate des programmes.
• En Python, il n’est pas nécessaire de déclarer le type d’une variable avant de l’utiliser. Le
type est déterminé automatiquement à l’exécution, ce qui simplifie l’écriture du code mais
exige une attention particulière pour éviter des erreurs.
• Python fonctionne sur divers systèmes d’exploitation, y compris Windows, macOS, Linux,
Android et même des systèmes embarqués comme les microcontrôleurs. Cette compatibilité
garantit la portabilité des programmes dans des environnements variés.
• Python supporte la programmation orientée objet, permettant de créer des classes et des
objets pour structurer le code de manière modulaire et réutilisable. Ce paradigme est essentiel
pour des projets complexes.
• Python utilise un ramasse-miettes (garbage collector) pour gérer la mémoire, libérant au-
tomatiquement les ressources inutilisées. Cela permet de se concentrer sur la logique du
programme sans gérer manuellement l’allocation mémoire.
• Python bénéficie d’une communauté active et d’un écosystème riche avec une bonne docu-
mentation 2 . Des milliers de bibliothèques, telles que NumPy, Pandas ou PyTorch, étendent
ses capacités.
• Python est régulièrement classé parmi les langages de programmation les plus populaires
selon des indices comme TIOBE 3 , ce qui témoigne de son adoption massive dans le monde
académique et professionnel.
Note. Bien que le typage dynamique simplifie le code, il peut entraîner des erreurs si les types de
données ne sont pas bien compris. Par exemple, additionner une chaîne de caractères et un nombre
provoque une erreur TypeError.

1.1.3 Applications de Python

Python est utilisé dans une grande variété de domaines grâce à sa flexibilité et à son écosystème.
Voici quelques exemples concrets :
• Sciences et ingénierie : Python est un outil de choix pour le calcul scientifique, la visualisa-
tion de données et la simulation. Des bibliothèques comme NumPy et Matplotlib permettent
de manipuler des tableaux multidimensionnels, de résoudre des équations différentielles ou
de créer des graphiques.
• Intelligence artificielle : Des frameworks comme TensorFlow, scikit-learn et PyTorch font
de Python le langage dominant pour développer des modèles d’apprentissage automatique et
d’apprentissage profond, utilisés dans la reconnaissance d’images, le traitement du langage
naturel et plus encore.
• Cybersécurité : Python est utilisé pour développer des outils d’analyse de sécurité, tester la
2. [Link]
3. [Link]

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 1.2 Installation et configuration : Python, VSCode 15

robustesse des systèmes et automatiser des audits de vulnérabilités.

• Développement web : Des frameworks comme Django, Flask et FastAPI facilitent la création
de sites web dynamiques et sécurisés, adaptés à une large gamme d’applications, des blogs
aux plateformes de commerce en ligne.
• Automatisation : Python est idéal pour écrire des scripts qui automatisent des tâches répéti-
tives, comme la gestion de fichiers, l’envoi d’emails ou l’extraction de données.

1.2 Installation et configuration : Python, VSCode

Pour commencer à programmer en Python, il est essentiel de configurer un environnement de travail
adapté. Cela implique l’installation du langage Python et d’un environnement de développement
intégré (IDE) pour écrire, exécuter et tester vos programmes. Ce cours recommande l’utilisation de
Visual Studio Code (VSCode), un outil populaire, gratuit et polyvalent, particulièrement adapté aux
débutants comme aux programmeurs expérimentés.

1.2.1 Étape 1 : Installation de Python

Python est un langage open-source, disponible gratuitement sur le site officiel. Pour garantir la
compatibilité avec les exemples de ce cours, il est recommandé d’installer une version récente de
Python 3 (version 3.10 ou supérieure).
1. Téléchargement : Rendez-vous sur le site officiel [Link]
nloads/. La page détecte automatiquement votre système d’exploitation et propose la
dernière version stable (par exemple, Python 3.13 en avril 2025) que vous pouvez télécharger.
2. Installation :
• Windows : Lancez le programme d’installation (.exe). Cochez l’option Add Python
to PATH pour permettre l’exécution de Python depuis la ligne de commande. Suivez
les instructions en sélectionnant Install Now.
• macOS : Ouvrez le fichier .pkg téléchargé et suivez les étapes de l’assistant d’installa-
tion.
• Linux : La plupart des distributions installent Python par défaut. Pour installer une
version récente, utilisez le gestionnaire de paquets (par exemple, sudo apt install
python3 sur Ubuntu).
3. Vérification : Ouvrez un terminal (Invite de commandes sur Windows, Terminal sur macOS/-
Linux) et tapez : python3 −−version. La sortie affiche la version installée, par exemple :
$ python3 −−version
Python 3.12.9

Si la commande échoue (généralement sur Windows), vérifiez que Python est ajouté au
PATH.
Note. Sur certains systèmes, la commande python peut correspondre à Python 2 ou ne pas
être reconnue. Utilisez python3 pour garantir l’exécution de Python 3. De plus, assurez-vous
de télécharger Python depuis [Link] pour éviter des versions
non officielles ou des logiciels malveillants.

1.2.2 Étape 2 : Installation de Visual Studio Code

Visual Studio Code (VSCode) est un éditeur de code léger et puissant, développé par Microsoft,
qui prend en charge Python via des extensions. Il offre des fonctionnalités comme la coloration
syntaxique, l’autocomplétion, le débogage et l’intégration avec les terminaux. Visitez https:

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 16 Chapitre 1. Introduction à Python

//[Link]/ puis téléchargez et installez la version correspondant à votre

système d’exploitation, en suivant les différentes instructions.

1.2.3 Étape 3 : Configuration de VSCode pour Python

Pour utiliser Python dans VSCode, il faut installer une extension dédiée et configurer l’environne-
ment.
1. Installation de l’extension Python :
• Dans VSCode, cliquez sur l’icône des extensions (carré avec une flèche) dans la barre
latérale gauche ou utilisez le raccourci Ctrl+Shift+X (Windows/Linux) ou Cmd+Shift
+X (macOS).
• Recherchez Python et installez l’extension officielle publiée par Microsoft. Elle contient
des outils pour l’exécution, le débogage et la vérification du code. De plus, elle est
automatiquement installée avec l’extension Pylance qui assure une autocomplétion et
une analyse de code avancées.
2. Sélection de l’interpréteur Python :
• Ouvrez la palette de commandes avec Ctrl+Shift+P (Windows/Linux) ou Cmd+Shift
+P (macOS).
• Tapez Python: Select Interpreter et sélectionnez la version de Python installée
(par exemple, Python 3.12). Si aucune version n’apparaît, vérifiez l’installation de
Python.
Note. Bien que VSCode soit recommandé pour sa simplicité et sa puissance, d’autres outils peuvent
convenir comme PyCharm qui est aussi puissant que VSCode, mais trop lourd, ou encore Jupyter
Notebook qui est adapté pour les analyses scientifiques interactives.
Pour ce cours, restez avec VSCode, car ses fonctionnalités sont bien adaptées aux débutants et les
exemples seront testés dans cet environnement.

1.3 Un premier programme Python

Comprendre la structure d’un programme est essentiel pour écrire du code clair et fonctionnel.

1.3.1 Qu’est-ce qu’un programme Python ?

Un programme est un ensemble d’instructions que l’ordinateur exécute pour accomplir une tâche.
Un programme Python est un fichier texte, généralement avec l’extension .py, contenant des ins-
tructions écrites dans la syntaxe du langage. Ces instructions sont lues et exécutées séquentiellement
par l’interpréteur Python, ligne par ligne. Un programme peut être aussi simple qu’une seule ligne
affichant un message ou aussi complexe qu’une application avec des milliers de lignes de code.
Une instruction est une unité de code qui indique à l’ordinateur d’effectuer une action, comme
afficher un texte, effectuer un calcul ou prendre une décision. En Python, chaque instruction est
généralement écrite sur une ligne.

1.3.2 Un premier programme simple

Pour illustrer la structure d’un programme, commençons par un exemple minimal qui affiche un
message de bienvenue. Ce programme sera créé dans Visual Studio Code (VSCode) et exécuté pour
vérifier son fonctionnement.
Créez un fichier nommé [Link] et ajoutez le code suivant :

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 1.4 Shell interactif 17

1 # Premier programme : afficher un message de bienvenue

2 message = "Bienvenue dans ce cours de Python !"
3 print(message)

Pour exécuter ce programme, enregistrez le fichier puis cliquez sur le bouton Run (triangle en haut
à droite) ou utilisez F5. La sortie s’affiche dans le terminal intégré :
Bienvenue dans ce cours de Python !

Le programme ci-dessus contient trois éléments fondamentaux :

1. Commentaire : La ligne 1 est un commentaire. Les commentaires commencent par # et ne
sont pas exécutés par l’interpréteur. Ils servent à expliquer le code, rendant sa lecture plus
facile pour vous et d’autres programmeurs.
2. Variable et affectation : La ligne 2 crée une variable nommée message et lui assigne
la valeur "Bienvenue dans ce cours de Python !". Une variable est comme une boîte
étiquetée qui stocke une donnée pour une utilisation ultérieure. Les variables seront explorées
en profondeur au chapitre suivant.
3. Instruction d’affichage : La ligne 3 appelle la fonction print() pour afficher le contenu
de la variable message dans le terminal. La fonction print() est un outil de base pour
communiquer les résultats d’un programme.
Notes.
1. L’ordre des instructions est important en Python. Par exemple, print(message) doit appa-
raître après la définition de message, sinon une erreur NameError se produira, car la variable
n’est pas encore définie.
2. Il existe plusieurs façons d’exécuter un programme Python :
• Via VSCode : Utilisez le bouton Run ou F5, comme décrit dans la section 1.2.
• Via le terminal : Naviguez dans le dossier contenant votre fichier (par exemple, cd
CoursPython) et tapez python3 nom_du_fichier.py
• Via le shell interactif : Pour tester des instructions ligne par ligne, utilisez le shell
Python.

1.4 Shell interactif

Pour écrire et exécuter des programmes Python, vous avez plusieurs options : exécuter un fichier
.py comme vu précédemment ou interagir directement avec Python via un shell interactif. Le shell
interactif est un outil puissant pour expérimenter, tester des idées rapidement et comprendre le
comportement du langage.

1.4.1 Qu’est-ce que le shell interactif ?

Le shell interactif, parfois appelé REPL (Read-Eval-Print Loop, ou boucle de lecture-évaluation-
affichage), est une interface où vous pouvez entrer des instructions Python ligne par ligne et voir
leurs résultats immédiatement. Il est intégré à Python et constitue un excellent outil, car il permet
de tester des concepts sans créer un fichier complet.

Un shell interactif est un environnement qui exécute chaque instruction dès qu’elle est saisie,
affiche le résultat puis attend la prochaine instruction. Il est idéal pour expérimenter et apprendre
les bases du langage.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 18 Chapitre 1. Introduction à Python

1.4.2 Accéder au shell interactif

Pour démarrer le shell interactif, ouvrez un terminal, tapez python3 et appuyez sur Entrée : Vous
verrez une invite comme celle-ci :
$ python3
Python 3.12.9 (main, Feb 5 2025, [Link]) [GCC 14.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

L’invite >>> indique que Python attend votre instruction.

Note. Si la commande python3 ne fonctionne pas, vérifiez que Python est correctement installé et
ajouté au PATH. Sur certains systèmes, essayez {python au lieu de python3, mais assurez-vous
que cela lance Python 3.

1.4.3 Utiliser le shell interactif

Dans le shell, vous pouvez entrer des instructions Python et les résultats s’affichent immédiatement.
Voici quelques exemples pour illustrer son fonctionnement :
Tapez les instructions suivantes dans le shell, une par une, en appuyant sur Entrée après chaque
ligne :
>>> 2 + 3
5
>>> message = "Bonjour !"
>>> print(message)
Bonjour !
>>> aire = 4.5 * 2.3
>>> aire
10.35

Observations :
• L’instruction 2 + 3 affiche directement 5, car le shell évalue les expressions et montre leur
résultat.
• La création de la variable message ne produit pas de sortie, mais print(message) affiche le
contenu.
• Après avoir calculé aire, taper aire affiche sa valeur, car le shell affiche automatiquement
la valeur d’une variable ou d’une expression.
Le shell est souvent utile pour :
• Tester des calculs ou des fonctions rapidement.
• Vérifier la syntaxe d’une instruction avant de l’ajouter à un programme.
Note. Les instructions saisies dans le shell ne sont pas sauvegardées. Pour conserver votre code,
utilisez un fichier .py. Le shell est idéal pour des tests temporaires, tandis que les fichiers sont
adaptés aux programmes réutilisables.

1.4.4 Commandes utiles dans le shell

Le shell interactif offre quelques commandes intégrées :
• help() : Ouvre une aide interactive. Par exemple, help(print) affiche la documentation de
la fonction print().

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 1.5 Syntaxe de base : commentaires, indentation, PEP 8 19

• exit() ou quit() : Ferme le shell.

• Ctrl+D (Linux/macOS) ou Ctrl+Z (Windows) : Alternative pour quitter le shell.

1.5 Syntaxe de base : commentaires, indentation, PEP 8

La syntaxe de Python est l’ensemble des règles qui définissent comment écrire un programme
compréhensible par l’interpréteur. Sa simplicité et sa lisibilité font de Python un langage idéal pour
les débutants, mais il est important de respecter certaines conventions pour éviter les erreurs et
produire un code clair.

1.5.1 Les commentaires

Les commentaires sont des annotations dans le code qui ne sont pas exécutées par l’interpréteur. Ils
servent à expliquer le fonctionnement du programme, à documenter les intentions ou à désactiver
temporairement des instructions. En Python, il existe deux types de commentaires :
• Commentaires sur une ligne : Commencent par # et s’étendent jusqu’à la fin de la ligne.
• Commentaires sur plusieurs lignes : Bien que Python n’ait pas de syntaxe dédiée, on
utilise souvent des chaînes de caractères multilignes (délimitées par """ ou '''), également
appelées docstrings, pour cet usage, surtout pour documenter des fonctions ou des modules.
Voici un programme utilisant des commentaires :
1 # Calcul de l'aire d'un rectangle
2 longueur = 6 # Longueur en mètres
3 largeur = 4 # Largeur en mètres
4 aire = longueur * largeur
5 print("L'aire est", aire, "mètres carrés")
6 """
7 Ce programme peut être étendu pour inclure
8 d'autres formes géométriques à l'avenir.
9 """

Sortie dans le terminal :

L'aire est 24 mètres carrés

Note. Les commentaires doivent être concis et pertinents. Trop de commentaires inutiles peuvent
encombrer le code. Utilisez-les pour clarifier des intentions complexes ou des choix spécifiques.

1.5.2 L’indentation
L’indentation est une caractéristique distinctive de Python : elle délimite les blocs de code, comme
les corps des boucles, des conditions ou des fonctions. Contrairement à d’autres langages qui
utilisent des accolades ({}), Python utilise des espaces ou des tabulations pour indiquer la hiérarchie
des instructions. Une indentation standard est de quatre espaces par niveau.

Un bloc de code ou bloc d’instructions est un ensemble d’instructions regroupées sous une même
structure, comme une condition ou une boucle. En Python, toutes les instructions d’un bloc doivent
avoir le même niveau d’indentation.
L’indentation signifie décaler certaines lignes de code vers la droite en ajoutant des espaces (ou
des tabulations) au début de la ligne. C’est une règle obligatoire en Python : elle sert à montrer
visuellement quels morceaux de code sont liés ensemble. Même si pour l’instant nous n’avons pas

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 20 Chapitre 1. Introduction à Python

encore vu les cas où elle est nécessaire (comme les conditions ou les répétitions), il est important
de savoir qu’en Python, l’indentation sert à organiser le code de manière visuelle et fonctionnelle,
garantissant que l’interpréteur Python comprenne quelles instructions appartiennent à un même
groupe. Oublier l’indentation ou se tromper empêche le programme de fonctionner.
Note. Une indentation incorrecte provoque une erreur (IndentationError). Par exemple, mélanger
des espaces et des tabulations ou indenter une ligne de manière incohérente interrompt l’exécution.

1.5.3 PEP 8 : Guide de style pour Python

PEP 8 est la norme officielle de style pour le code Python, définie dans le Python Enhancement
Proposal numéro 8 4 . Elle fournit des recommandations pour rendre le code lisible et cohérent,
ce qui est essentiel lorsque vous travaillez en équipe ou partagez votre code. Voici les principales
règles de PEP 8 pertinentes pour les débutants :
• Noms des variables : Utilisez des noms explicites en minuscules, avec des underscores pour
séparer les mots (par exemple, aire_rectangle au lieu de ar ou AireRectangle).
• Indentation : Utilisez quatre espaces par niveau d’indentation et évitez les tabulations.
• Longueur des lignes : Limitez les lignes à 79 caractères pour faciliter la lecture. Si une ligne
est trop longue, divisez-la avec un retour à la ligne et alignez les éléments.
• Espaces : Ajoutez des espaces autour des opérateurs (par exemple, x = 2 + 3 au lieu de
x=2+3) et après les virgules (par exemple, print(x, y)).
• Commentaires : Placez les commentaires sur une ligne séparée pour les explications longues,
ou en fin de ligne pour les annotations brèves. Laissez deux espaces avant un commentaire
en fin de ligne.

1.6 Erreurs courantes : SyntaxError, NameError, TypeError

Lors de l’apprentissage de Python, rencontrer des erreurs est une étape naturelle et incontournable.
Ces erreurs, signalées par des messages de l’interpréteur, indiquent que quelque chose dans le code
ne respecte pas les règles du langage ou ne peut pas être exécuté correctement. Comprendre et
corriger ces erreurs renforce votre maîtrise de la programmation.

1.6.1 Qu’est-ce qu’une erreur en Python ?

Une erreur en Python est une interruption de l’exécution d’un programme causée par une violation
des règles du langage ou une opération impossible. Lorsqu’une erreur survient, l’interpréteur affiche
un message d’erreur (ou traceback) qui indique :
• Le type d’erreur (par exemple, SyntaxError).
• La ligne où l’erreur s’est produite.
• Une description de la cause.

Un traceback est un rapport généré par Python lorsqu’une erreur survient, montrant la pile d’appels
(les instructions exécutées) et des détails sur l’erreur. Lire le traceback est essentiel pour identifier
et corriger les problèmes.

1.6.2 Erreur 1 : SyntaxError

Une SyntaxError survient lorsque le code ne respecte pas les règles syntaxiques de Python, comme
une parenthèse manquante, une indentation incorrecte ou un mot-clé mal orthographié. C’est l’une
4. [Link]

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 1.6 Erreurs courantes : SyntaxError, NameError, TypeError 21

des erreurs les plus courantes pour les débutants.

Considérons ce programme avec une erreur de syntaxe :
1 # Programme avec une SyntaxError
2 print("Bonjour"

Exécution :
File "[Link]", line 2
print("Bonjour"
^
SyntaxError: '(' was never closed

Analyse :
• Le message indique une SyntaxError à la ligne 2.
• La cause est '(' was never closed, signifiant qu’une parenthèse a été ouverte et n’a jamais
été fermée.
Pour corriger cette erreur, il suffit d’ajouter la parenthèse fermante.

1.6.3 Erreur 2 : NameError

Une NameError se produit lorsque Python rencontre un nom (variable, fonction, etc.) qui n’a pas
été défini avant son utilisation. Cela arrive souvent si une variable est mal orthographiée ou utilisée
avant sa déclaration.
Considérons ce programme :
1 # Programme avec une NameError
2 print(age)

Exécution :
Traceback (most recent call last):
File "[Link]", line 2, in <module>
print(age)
^^^
NameError: name 'age' is not defined

Analyse :
• Le message indique une NameError à la ligne 2.
• La cause est name 'age' is not defined, car la variable age n’a pas été définie avant
d’être utilisée.
Note. Une NameError peut aussi survenir si vous faites une faute de frappe (par exemple, Age au
lieu de age, car Python est sensible à la casse) ou si vous utilisez une variable dans un mauvais
contexte.

1.6.4 Erreur 3 : TypeError

Une TypeError survient lorsque vous effectuez une opération sur des données de types incompa-
tibles, comme additionner une chaîne de caractères et un nombre ou appeler une fonction avec un
argument inapproprié.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

22 Chapitre 1. Introduction à Python

Considérons ce programme :
1 # Programme avec une TypeError
2 nombre = 5
3 texte = "Bonjour"
4 resultat = nombre + texte
5 print(resultat)

Exécution :
Traceback (most recent call last):
File "[Link]", line 4, in <module>
resultat = nombre + texte
~~~~~~~^~~~~~~
TypeError: unsupported operand type(s) for +: 'int' and 'str'

Analyse :
• Le message indique une TypeError à la ligne 4.
• La cause est unsupported operand type(s) for +: 'int' and 'str', car Python ne
peut pas additionner un entier (int) et une chaîne (str).
Pour corriger ce type d’erreur, il est important de vérifier que les deux éléments que l’on veut
additionner sont du même type. Dans cet exemple, on pourrait soit convertir le nombre en chaîne
de caractères, soit convertir la chaîne en nombre (si c’est possible et logique). La conversion de
type ("transtypage" ou "casting") permet de transformer une valeur d’un type vers un autre.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 2. Variables, types et entrées/sorties

Après avoir exploré les bases de Python, comme la syntaxe et les erreurs courantes, il est temps
de plonger dans les concepts fondamentaux qui permettent de manipuler des données dans un
programme. Ce chapitre se concentre sur les variables, les types de données et les mécanismes
d’entrées/sorties. Ces notions sont essentielles pour construire des programmes capables de stocker,
traiter et afficher des informations.

2.1 Variables et types

Une variable est un outil de base en programmation, permettant de stocker des données pour les
utiliser ou les modifier ultérieurement. Les types de données définissent la nature des informations
stockées (nombres, textes, etc.) et les opérations possibles sur celles-ci. Cette section introduit la
déclaration et l’affectation des variables, puis présente les types fondamentaux de Python. Les
concepts abordés ici sont la base de toute manipulation de données dans vos programmes.

2.1.1 Déclaration et affectation

Une variable est comme une boîte étiquetée dans laquelle vous stockez une valeur. En Python,
déclarer une variable consiste à lui donner un nom et à lui associer une valeur à l’aide de l’opérateur
d’affectation =. Contrairement à d’autres langages, Python ne nécessite pas de déclarer explicitement
le type d’une variable, car il utilise un typage dynamique : le type est déterminé automatiquement
en fonction de la valeur assignée.

L’affectation est l’action d’associer une valeur à une variable avec l’opérateur =. Le nom de la
variable est à gauche et la valeur (ou une expression) est à droite. Une variable peut être réaffectée
à une nouvelle valeur à tout moment.

[Link] Règles pour nommer les variables

Pour que les noms de variables soient valides et conformes aux bonnes pratiques, respectez ces
règles :

• Caractères autorisés : Lettres (a-z, A-Z), chiffres (0-9) et underscores (_). Les noms ne
peuvent pas commencer par un chiffre.
 24 Chapitre 2. Variables, types et entrées/sorties

• Sensibilité à la casse : age et Age sont deux variables distinctes.

• Mots réservés : Évitez les mots-clés et noms de fcontions de Python comme if, for ou
print. Une liste complète est disponible dans la documentation 1 .
• Clarté : Utilisez des noms descriptifs en minuscules, avec des underscores pour séparer les
mots (par exemple, nombre_etudiants au lieu de n).

[Link] Réaffectation et typage dynamique

Une variable peut être réaffectée à une nouvelle valeur et son type peut changer grâce au typage
dynamique. Cela simplifie l’écriture du code, mais nécessite de faire attention aux types lors des
opérations.
Testons la réaffectation dans le shell interactif :
>>> x = 10 # x est un entier
>>> x
10
>>> x = "Python" # x devient une chaîne
>>> x
'Python'

Le type de x change d’entier (int) à chaîne (str) sans déclaration explicite.

Notes.
1. La réaffectation écrase systématiquement l’ancienne valeur de la variable en la remplaçant
par la nouvelle valeur affectée.
2. Bien que le typage dynamique soit flexible, il peut causer des erreurs si vous perdez la trace
des types.
3. Il est possible d’affecter une même valeur à plusieurs variables en une seule opération.
>>> a = b = c = −1
>>> a
−1
>>> b
−1
>>> c
−1

[Link] Bonnes pratiques pour les variables

• Choisissez des noms qui reflètent la signification de la variable (par exemple, salaire_mensuel
plutôt que s).
• Évitez de réaffecter une variable à un type complètement différent dans le même programme,
sauf si cela est justifié, pour maintenir la clarté.
• Initialisez les variables avant de les utiliser pour éviter une NameError.

2.1.2 Types fondamentaux

En Python, chaque valeur a un type qui détermine les opérations possibles et la manière dont elle
est stockée en mémoire. Les types fondamentaux, utilisés dans la majorité des programmes, sont :
• int : Entiers (nombres sans décimales, comme 5, −10).
• float : Nombres à virgule flottante (nombres décimaux, comme 3.14, −0.001).

1. [Link]

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 2.1 Variables et types 25

• str : Chaînes de caractères (textes, comme "Bonjour", 'Python').

• bool : Booléens (valeurs logiques True ou False).

Un type de données définit les caractéristiques d’une valeur, telles que sa représentation, sa taille
en mémoire et les opérations autorisées. Le typage dynamique de Python attribue automatiquement
le type lors de l’affectation.
>>> entier = 42 # Type int
>>> entier
42
>>> decimal = 3.14159 # Type float
>>> decimal
3.14159
>>> texte = "Python" # Type str
>>> texte
'Python'
>>> vrai_ou_faux = True # Type bool
>>> vrai_ou_faux
True

[Link] Détails sur chaque type

• Entiers (int) : Représentent des nombres entiers positifs, négatifs ou zéro. Python 3 gère
des entiers de taille arbitraire, sans limite pratique (par exemple, 12345678901234567890
reste valide).
• Nombres à virgule (float) : Représentent des nombres décimaux. Notez que les float
peuvent introduire des approximations dans certains calculs (par exemple, 0.1 + 0.2 donne
0.30000000000000004 en raison de la représentation en virgule flottante 2 ).
• Chaînes (str) : Représentent du texte, délimité par des guillemets simples (' ') ou doubles
(" "), parfois par des docstrings. Les chaînes sont utilisées pour afficher des messages,
manipuler des données textuelles ou interagir avec l’utilisateur.
• Booléens (bool) : Représentent deux valeurs : True (vrai) ou False (faux). Ils sont utilisés
dans les conditions et les tests logiques.

[Link] Vérification des types avec type()

La fonction type() retourne le type d’une valeur ou d’une variable. C’est un outil précieux pour
diagnostiquer des erreurs ou vérifier le comportement du typage dynamique.
>>> x = 100
>>> type(x)
<class 'int'>
>>> x = 2.718
>>> type(x)
<class 'float'>
>>> x = "Bonjour"
>>> type(x)
<class 'str'>
>>> x = False
>>> type(x)
<class 'bool'>

Cela montre comment type() révèle le type actuel de x après chaque affectation.

2. [Link]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 26 Chapitre 2. Variables, types et entrées/sorties

[Link] Bonnes pratiques pour les types

• Vérifiez les types avec type() si une opération échoue de manière inattendue.
• Soyez conscient des limites des float pour les calculs nécessitant une haute précision.
• Utilisez des noms de variables qui suggèrent leur type (par exemple, distance_km pour un
float, nom_utilisateur pour un str).

2.1.3 Opérations arithmétiques

Les opérations arithmétiques permettent de réaliser des calculs mathématiques sur les types nu-
mériques (int et float), comme l’addition, la multiplication ou la division. Ces opérations sont
essentielles pour manipuler des données dans des programmes.

Un opérateur arithmétique est un symbole (comme + ou *) qui effectue une opération mathéma-
tique sur deux opérandes (valeurs ou variables). Le résultat dépend des types des opérandes (int
ou float).

[Link] Les opérateurs arithmétiques

Python propose les opérateurs suivants, classés par priorité décroissante :

• ** : Exponentiation (puissance, par exemple, 2 ** 3 donne 8).
• *, /, //, % : Multiplication, division, division entière, modulo.
• +, − : Addition, soustraction.
>>> 5 + 3 # Addition
8
>>> 5 − 3 # Soustraction
2
>>> 4 * 2 # Multiplication
8
>>> 10 / 2 # Division
5.0
>>> 10 // 3 # Division entière
3
>>> 10 % 3 # Modulo (reste)
1
>>> 2 ** 3 # Exponentiation
8

Note. La division retourne toujours un float, même si le résultat est entier.

[Link] Priorité et parenthèses

Les opérateurs sont évalués selon leur priorité, mais vous pouvez utiliser des parenthèses () pour
forcer un ordre spécifique, comme en mathématiques.
>>> 2 + 3 * 4 # * a priorité sur +
14
>>> (2 + 3) * 4 # Parenthèses changent l'ordre
20

Sans parenthèses, 3 * 4 est calculé en premier, puis + 2. Avec parenthèses, 2 + 3 est évalué
d’abord.
Note. Omettre des parenthèses dans une expression complexe peut donner un résultat inattendu.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 2.1 Variables et types 27

Par exemple, 10 / 2 * 5 donne 25.0, car / et * ont la même priorité et sont évalués de gauche à
droite. Utilisez des parenthèses pour clarifier vos intentions, comme 10 / (2 * 5) pour obtenir
1.0.

[Link] Utilisation avec des variables

Les opérateurs peuvent être appliqués à des variables, ce qui est courant dans des programmes plus
structurés.
1 # Calcul de la surface d'un rectangle
2 longueur = 6
3 largeur = 4
4 surface = longueur * largeur
5 print(surface)

24

Ici, * est utilisé pour multiplier les valeurs des variables longueur et largeur.

[Link] Opérateurs d’affectation composée

En plus des opérateurs arithmétiques de base, Python propose des opérateurs d’affectation
composée qui combinent une opération arithmétique avec une affectation. Ces opérateurs, comme
+=, −=, *=, /=, //=, %= et **=, permettent de modifier une variable en place.

Un opérateur d’affectation composée effectue une opération arithmétique sur une variable et
réassigne le résultat à cette même variable.
>>> x = 10
>>> x += 5 # Équivaut à x = x + 5
>>> x
15
>>> x *= 2 # Équivaut à x = x * 2
>>> x
30
>>> x /= 3 # Équivaut à x = x / 3
>>> x
10.0
>>> x //= 2 # Équivaut à x = x // 2
>>> x
5.0

Note. Les opérateurs d’affectation composée modifient la variable directement. Assurez-vous que
la variable est définie avant de l’utiliser.

[Link] Comportement avec différents types

Les opérateurs arithmétiques fonctionnent différemment selon les types :

• int + int donne un int (par exemple, 5 + 3 donne 8).
• float + float ou int + float donne un float (par exemple, 5.0 + 3 donne 8.0).
• Opérer sur un int ou float avec un str provoque une TypeError, sauf pour la multiplication
(*) avec une chaîne.

>>> 5 + 3.0 # int + float

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 28 Chapitre 2. Variables, types et entrées/sorties

8.0
>>> 5 + "3" # int + str
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'

Pour additionner 5 et "3", une conversion de type est nécessaire.

2.1.4 Conversion de types

Les conversions de types, encore appelé transtypage ou casting, permettent de transformer une
valeur d’un type à un autre, par exemple convertir une chaîne en entier pour effectuer un calcul.
Python fournit des fonctions intégrées comme int(), float(), str() et bool() pour effectuer ces
conversions.

La conversion de type est l’opération qui change le type d’une valeur, en utilisant une fonction
comme int() ou str(). Elle est nécessaire lorsque les types des opérandes ne sont pas compatibles
avec l’opération souhaitée.

[Link] Les fonctions de conversion

• int(x) : Convertit x en entier. Accepte des float (en tronquant la partie décimale), des str
représentant des entiers (par exemple, "123") ou des bool.
• float(x) : Convertit x en nombre à virgule. Accepte des int, des str représentant des
nombres (par exemple, "3.14") ou des bool.
• str(x) : Convertit x en chaîne. Fonctionne avec tous les types (int, float, bool).
• bool(x) : Convertit x en booléen. Les règles sont spécifiques (voir ci-dessous).
>>> int(3.7) # float vers int (tronque)
3
>>> float("2.5") # str vers float
2.5
>>> str(42) # int vers str
'42'
>>> bool(0) # int vers bool
False

Observations :
• int(3.7) tronque la partie décimale, donnant 3.
• float("2.5") convertit la chaîne "2.5" en 2.5.
• str(42) produit la chaîne "42".
• bool(0) donne False, car 0 est considéré comme faux.

[Link] Règles pour bool()

La conversion en booléen suit des règles précises :

• Faux : 0, 0.0, "" (chaîne vide), False, None.
• Vrai : Tout autre valeur, comme 1, 3.14, "texte", True.
>>> bool(5)
True
>>> bool("")
False

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 2.1 Variables et types 29

>>> bool("Python")
True

Les conversions sont souvent nécessaires pour :

• Combiner des types dans une opération (par exemple, concaténer un nombre avec une chaîne).
• Traiter des entrées utilisateur, qui sont toujours des chaînes.
• Garantir la compatibilité des types dans des calculs.
Note. Certaines conversions échouent et provoquent une ValueError. Par exemple, int("abc")
ou float("3.14.15") ne sont pas valides, car "abc" n’est pas un nombre et "3.14.15" n’est pas
un format décimal correct. Vérifiez toujours la validité des données avant de convertir, surtout pour
les entrées utilisateur.

2.1.5 Notation scientifique

Pour manipuler efficacement les données en Python, il est essentiel de comprendre certaines
conventions, comme la notation scientifique pour les nombres et d’utiliser des fonctions intégrées
qui fournissent des informations sur les variables

[Link] Notation scientifique

La notation scientifique est utilisée pour représenter des nombres très grands ou très petits de
manière compacte, en utilisant un exposant. En Python, un nombre en notation scientifique s’écrit
sous la forme aEb, où a est la mantisse, E (ou e) indique l’exposant et b est la puissance de 10.
>>> 1.5e3 # 1.5 x 10^3
1500.0
>>> 2.7e−2 # 2.7 x 10^(−2)
0.027
>>> −4e5 # −4 x 10^5
−400000.0

Observations :
• Les résultats sont des float, même si on ne met que des entiers à gauche et à droite du
symbole e.
• e peut être suivi d’un exposant positif ou négatif.

[Link] Séparateur numérique (_)

Depuis Python 3.6, le séparateur _ peut être utilisé pour améliorer la lisibilité des nombres longs,
qu’ils soient en notation décimale, scientifique ou autre. Les underscores sont ignorés par l’interpré-
teur et servent uniquement à grouper visuellement les chiffres, comme des virgules ou des espaces
dans l’écriture manuelle.
>>> 10_000_000
10000000
>>> 1_234.56_78
1234.5678

Le séparateur _ rend les nombres composés de beaucoup de chiffres beaucoup plus lisibles, surtout
dans les calculs scientifiques ou financiers.
Note. Le séparateur _ ne change pas la valeur du nombre. Cependant, il ne peut pas être placé au

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 30 Chapitre 2. Variables, types et entrées/sorties

début, à la fin ou consécutivement (par exemple, 123_ ou 123__456 provoque une SyntaxError).

2.2 Chaînes de caractères

Les chaînes de caractères (str) sont utilisées pour représenter et manipuler du texte, comme des
messages, des noms ou des données saisies par l’utilisateur. Leur flexibilité en fait un outil central
dans la programmation.

Une chaîne de caractères est une séquence de caractères (lettres, chiffres, symboles) entourée de
guillemets simples (') ou doubles ("). Les chaînes sont immuables, c’est-à-dire que leur contenu ne
peut pas être modifié après création.

2.2.1 Définition, délimiteurs, échappement, chaînes brutes

[Link] Définition et délimiteurs

Une chaîne est définie en plaçant du texte entre guillemets simples (') ou doubles ("). Les deux
sont équivalents, mais le choix peut dépendre du contenu de la chaîne. Jetons un œil à l’exemple
ci-dessous.
>>> "Bonjour"
'Bonjour'
>>> 'Python 3'
'Python 3'
>>> message = "C'est une chaîne"
>>> message
"C'est une chaîne"

Si une chaîne contient des guillemets, utilisez l’autre type de délimiteur ou un caractère d’échappe-
ment.

[Link] Caractères d’échappement

Les caractères d’échappement permettent d’inclure des caractères spéciaux (comme des guille-
mets ou des retours à la ligne) dans une chaîne en utilisant une barre oblique inverse (\). Les plus
courants sont :

• \n : Retour à la ligne.
• \t : Tabulation.
• \" ou \' : Guillemet double ou simple.
• \\ : Barre oblique inverse (antislash).

>>> texte = "Ligne 1\nLigne 2"

>>> print(texte)
Ligne 1
Ligne 2
>>> citation = "Il a dit : \"Python est génial !\""
>>> print(citation)
Il a dit : "Python est génial !"
>>> citation = 'Il a dit : "Python est génial !"'
>>> print(citation)
Il a dit : "Python est génial !"

\n crée un saut de ligne et \" permet d’inclure des guillemets doubles.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 2.2 Chaînes de caractères 31

Note. Oublier un caractère d’échappement pour un guillemet dans une chaîne provoque une
SyntaxError. Par exemple, "Il dit "Python"" est incorrect. Utilisez donc l’échappement ou
changez les délimiteurs ('Il dit "Python"').

[Link] Chaînes brutes

Les chaînes brutes désactivent l’interprétation des caractères d’échappement en ajoutant un r avant
les guillemets. Elles sont utiles pour des expressions comme des chemins de fichiers (Windows) ou
des expressions régulières 3 .
>>> print("C:\\nouveau\\dossier")
C:\nouveau\dossier
>>> print(r"C:\nouveau\dossier")
C:\nouveau\dossier

Dans une chaîne normale, \n est interprété comme un retour à la ligne. Dans une chaîne brute (r),
\nest traité littéralement.
Note. Les chaînes brutes ne peuvent pas se terminer par une barre oblique inverse seule (r"texte\"
provoque une SyntaxError). Utilisez des chaînes normales ou doublez la barre (r"texte\\") si
nécessaire.

[Link] Chaînes multilignes

Les chaînes multilignes, entourées de triples guillemets (''' ou """), permettent d’écrire du texte
sur plusieurs lignes sans utiliser \n explicitement.
>>> texte = '''Ligne 1
... Ligne 2
... Ligne 3
... Ligne 4
... Ligne 5
... '''
>>> print(texte)
Ligne 1
Ligne 2
Ligne 3
Ligne 4
Ligne 5

Les triples guillemets permettent de préserver la mise en forme.

2.2.2 Opérations sur les chaînes : concaténation, répétition, indexation, décou-

page
Les chaînes de caractères (str) en Python sont bien plus que de simples textes : elles supportent des
opérations puissantes pour les manipuler, comme les combiner, les répéter ou extraire des parties
spécifiques.

[Link] Concaténation

La concaténation combine deux ou plusieurs chaînes en une seule à l’aide de l’opérateur +.

>>> prenom = "Alice"

3. [Link]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 32 Chapitre 2. Variables, types et entrées/sorties

>>> nom = "Dupont"

>>> prenom + nom
'AliceDupont'
>>> prenom + " " + nom
'Alice Dupont'

[Link] Répétition

La répétition utilise l’opérateur * pour répéter une chaîne un nombre donné de fois.
>>> prenom = "Alice"
>>> prenom * 5
'AliceAliceAliceAliceAlice'

prenom * 5 répète le prénom cinq fois.

[Link] Indexation

L’indexation permet d’accéder à un caractère spécifique d’une chaîne en utilisant son indice, noté
entre crochets [i]. Les indices commencent à 0 pour le premier caractère et peuvent être négatifs
pour compter à partir de la fin (−1 est le dernier caractère). L’indexation extrait un caractère à
l’indice donné, retournant une nouvelle chaîne d’un seul caractère.
>>> texte = "Python"
>>> texte[0]
'P'
>>> texte[2]
't'
>>> texte[−1]
'n'
>>> texte[−3]
'h'

Note. Accéder à un indice inexistant provoque une IndexError. Par exemple, texte[10] pour
texte = "Python" échoue, car la chaîne a seulement 6 caractères (indices de 0 à 5).

[Link] Découpage (Slicing)

Le découpage (ou slicing) permet d’extraire une sous-chaîne à partir d’une chaîne en spécifiant une
plage d’indices, c’est-à-dire une partie d’une chaîne de caractères. Pour le faire, on a les différentes
syntaxes suivantes :
• chaine[début:fin]} : Extrait les caractères de l’indice début (inclus) à l’indice fin (exclu).
• chaine[:fin] : Extrait les caractères du début jusqu’à l’indice fin (exclu).
• chaine[début:] : Extrait les caractères de l’indice début (inclus) jusqu’à la fin.
• chaine[début:fin:pas] : Extrait les caractères de l’indice début (inclus) à l’indice fin
(exclu) avec un pas spécifié.
>>> texte = "Programmation"
>>> texte[0:4] # Du 1er au 4e caractère
'Prog'
>>> texte[4:8] # Du 5e au 8e caractère
'ramm'
>>> texte[:5] # Du début au 5e caractère
'Progr'
>>> texte[8:] # Du 9e caractère à la fin

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 2.2 Chaînes de caractères 33

'ation'
>>> texte[::2] # Tous les caractères, un sur deux
'Pormain'
>>> texte[::−1] # Tous les caractères, dans l'ordre inverse
'noitammargorP'

Note. Les chaînes sont immuables : vous ne pouvez pas modifier un caractère via l’indexation (par
exemple, texte[0] = 'X' provoque une TypeError).

[Link] Méthodes courantes

Les chaînes Python disposent de nombreuses méthodes intégrées pour les manipuler. Les plus
courantes pour le traitement de texte sont listées dans le tableau 2.1.
Voici quelques illustrations de ces méthodes :
>>> texte = " Bonjour, Python ! "
>>> print([Link]())
bonjour, python !
>>> print([Link]())
BONJOUR, PYTHON !
>>> print([Link]())
Bonjour, Python !
>>> print([Link]("Python"))
11
>>> print([Link]("Java"))
−1
>>> print([Link]("Python", "Java"))
Bonjour, Java !
>>> mots = [Link]()
>>> print(mots)
['Bonjour,', 'Python', '!']
>>> phrase = "−".join(mots)
>>> print(phrase)
Bonjour,−Python−!

Dans cet exemple, strip() supprime les espaces autour de la chaîne, find("Python") retourne
l’indice 10, split() divise la chaîne en mots et join() recombine les mots avec un tiret comme
séparateur.
Notes.
1. Les méthodes comme lower(), strip() ou replace() ne modifient pas la chaîne originale,
car les chaînes sont immuables. Elles retournent une nouvelle chaîne modifiée. Pour conserver
le résultat, affectez-le à une variable, par exemple : texte = [Link]().
2. Il existe une multitude de méthodes permettant d’effectuer des traitements sur les chaînes.
Pour plus de détails, consultez la documentation officielle sur les méthodes des chaînes de
caractères 4 .

2.2.3 Formatage : format(), f-strings

Le formatage des chaînes permet d’insérer des valeurs (nombres, variables, etc.) dans un texte de
manière dynamique, rendant les affichages plus clairs et personnalisés. Python propose plusieurs
méthodes de formatage, mais cette section se concentre sur deux approches modernes : la méthode
format() et les f-strings (introduites en Python 3.6). Ces techniques sont idéales pour créer des

4. [Link]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

34 Chapitre 2. Variables, types et entrées/sorties

TABLE 2.1 – Méthodes courantes des chaînes Python pour le traitement de texte

Méthode Description
lower() Convertit tous les caractères alphabétiques en minuscules (par
exemple, "Bonjour" devient "bonjour").
upper() Convertit tous les caractères alphabétiques en majuscules (par
exemple, "Bonjour" devient "BONJOUR").
islower() Retourne True si tous les caractères alphabétiques sont en minus-
cules et qu’il y a au moins un caractère alphabétique, sinon False.
isupper() Retourne True si tous les caractères alphabétiques sont en majus-
cules et qu’il y a au moins un caractère alphabétique, sinon False.
isdecimal() Retourne True si tous les caractères sont des chiffres décimaux
(0-9), sinon False (par exemple, "123" retourne True, "12a"
retourne False).
isdigit() Retourne True si tous les caractères sont des chiffres (inclut des
chiffres Unicode), sinon False. Similaire à isdecimal(), mais
plus large.
isalpha() Retourne True si tous les caractères sont alphabétiques (lettres
uniquement) et qu’il y a au moins un caractère, sinon False.
isalnum() Retourne True si tous les caractères sont alphanumériques (lettres
ou chiffres) et qu’il y a au moins un caractère, sinon False.
capitalize() Convertit la première lettre en majuscule et le reste en minuscules
(par exemple, "bonjour" devient "Bonjour").
title() Convertit la première lettre de chaque mot en majuscule et le reste
en minuscules (par exemple, "bonjour tout le monde" devient
"Bonjour Tout Le Monde").
swapcase() Inverse la casse : les minuscules deviennent majuscules et vice
versa (par exemple, "Bonjour" devient "bONJOUR").
strip() Supprime les espaces et les caractères de saut de ligne (\n, \t) au
début et à la fin de la chaîne.
rstrip() Supprime les espaces et les caractères de saut de ligne à la fin de
la chaîne uniquement.
find(sub)| Retourne l’indice de la première occurrence de la sous-chaîne sub
dans la chaîne, ou −1 si sub n’est pas trouvé.
replace(ancien, nouveau) Remplace toutes les occurrences de la sous-chaîne ancien par
nouveau dans la chaîne.
split(sep) Divise la chaîne en une liste de sous-chaînes, en utilisant sep
comme délimiteur (par exemple, "a,b,c".split(",") donne ['
a', 'b', 'c']).
join(iterable) Concatène les éléments d’un itérable (par exemple, une liste) en
une seule chaîne, en utilisant la chaîne comme séparateur (par
exemple, ",".join(['a', 'b', 'c']) donne "a,b,c").

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 2.2 Chaînes de caractères 35

messages lisibles.

Le formatage consiste à intégrer des valeurs dans une chaîne en utilisant des espaces réservés ou
des expressions. Cela améliore la lisibilité par rapport à la concaténation manuelle.

[Link] Méthode format()

La méthode format() insère des valeurs dans une chaîne en remplaçant des espaces réservés {}.
Les valeurs sont passées comme arguments à format().
1 # Formatage avec format()
2 nom = "Bob"
3 age = 25
4 message = "Bonjour, {} ! Vous avez {} ans.".format(nom, age)
5 print(message)

Bonjour, Bob ! Vous avez 25 ans.

Vous pouvez spécifier des indices dans les espaces réservés pour contrôler l’ordre ou réutiliser des
valeurs.
>>> "x={1}, y={0}, x+y={2}".format(3, 4, 7)
'x=4, y=3, x+y=7'

{1} prend la deuxième valeur (4), {0} la première (3) et {2} la troisième (7).

[Link] F-strings

Les f-strings, ou littérales de chaînes formatées, introduites en Python 3.6, offrent une méthode
concise pour intégrer des valeurs et des expressions directement dans une chaîne de caractères.
En préfixant une chaîne par f ou F, vous pouvez insérer des expressions entre accolades {}, qui
sont évaluées à l’exécution et remplacées par leurs résultats. Cette approche est plus lisible que la
concaténation ou la méthode format(), car elle permet d’écrire le code de manière naturelle, en
plaçant les variables ou expressions exactement là où elles apparaissent dans le texte. Les f-strings
sont adaptées pour créer des messages dynamiques, comme des affichages personnalisés.
>>> prenom = "Charlie"
>>> note = 15.5
>>> print(f"{prenom} a obtenu {note}/20 à l'examen.")
Charlie a obtenu 15.5/20 à l'examen.
>>> x = 10
>>> y = 20
>>> f"Somme : {x + y}"
'Somme : 30'

Dans le premier exemple, prenom et note sont insérés directement dans la chaîne. Dans le second,
l’expression x + y est évaluée et le résultat 30 est intégré. Les f-strings permettent ainsi d’inclure
non seulement des variables, mais aussi des calculs ou des appels de fonctions.

Une limitation importante est que les f-strings ne peuvent pas être vides ou contenir des accolades
non appariées. Par exemple, f"{}" provoquent une SyntaxError, car l’interpréteur attend une
expression valide entre les accolades. Si on veut afficher des accolades littérales avec les f-strings,

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 36 Chapitre 2. Variables, types et entrées/sorties

il faut les doubler pour échapper au formatage.

>>> print(f"Affichage des accolades {{}} avec f−strings")
Affichage des accolades {} avec f−strings

[Link] Contrôle du formatage

Le formatage des f-strings permet de personnaliser la présentation des valeurs, comme l’alignement,
la précision des nombres ou l’affichage de formats spécifiques (par exemple, pourcentages ou
hexadécimal). En ajoutant un spécificateur de format après une expression, séparé par deux-points
(:), vous pouvez contrôler comment la valeur est affichée.
Formatage des nombres
Pour les nombres (int et float), vous pouvez spécifier la précision, ajouter des séparateurs de
milliers ou utiliser des notations comme la notation scientifique ou les pourcentages.
>>> pi = 3.1415926535
>>> print(f"Pi arrondi: {pi:.2f}")
Pi arrondi: 3.14
>>> nombre = 1234567
>>> print(f"Nombre formaté: {nombre:,}")
Nombre formaté: 1,234,567
>>> print(f"Nombre formaté e: {nombre:.3e}")
Nombre formaté e: 1.235e+06
>>> pourcentage = 0.378
>>> print(f"Taux: {pourcentage:.1%}")
Taux: 37.8%

Explications :
• {pi:.2f} affiche pi avec deux décimales, arrondi à 3.14.
• {nombre:,} ajoute des virgules comme séparateurs de milliers.
• {nombre:.3e} écrit nombre en notation scientifique.
• {pourcentage:.1%} convertit 0.378 en pourcentage avec une décimale, soit 37.8%.

Alignement et remplissage
Les f-strings permettent de contrôler l’alignement (< pour gauche, > pour droite, ^ pour centré) et
d’ajouter un caractère de remplissage pour atteindre une largeur donnée. Par défaut, l’espace est le
caractère qui sert de remplissage.
>>> texte = "Python"
>>> print(f"Centré: |{texte:^10}|")
Centré: | Python |
>>> print(f"Rempli: |{texte:*>10}|")
Rempli: |****Python|

Explications :
• {texte:^10} centre Python dans un espace de 10 caractères, avec des espaces comme
remplissage.
• {texte:*>10} aligne à droite et remplit avec des * à gauche.

Expressions dans les spécificateurs

Les spécificateurs de format peuvent eux-mêmes contenir des expressions, ce qui permet un

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 2.3 Entrées/sorties 37

formatage dynamique.
>>> largeur = 12
>>> precision = 3
>>> valeur = 12.34567
>>> print(f"Résultat: {valeur:{largeur}.{precision}f}")
Résultat: 12.346

Ici, largeur et precision sont évalués pour définir le format 12.3f, alignant 12.346 à droite sur
12 caractères.

Notes.
1. Les spécificateurs de format doivent respecter la syntaxe correcte. Par exemple, {pi:.2g}
pour un float est valide, mais {texte:.2f} pour une chaîne provoque une ValueError.
2. Les f-strings sont généralement préférées à format() pour leur clarté et leur concision. Elles
sont particulièrement utiles pour les affichages dynamiques dans des programmes interactifs.
Par ailleurs, les possibilités offertes par les f-strings pour le formatage sont vastes : formats
numériques (hexadécimal, octal, binaire), alignements personnalisés, formats spécifiques
comme les dates, etc. Vous pouvez consulter la documentation 5 6 ou ce mémo 7 pour explorer
toutes les options et pour avoir des détails approfondis sur leur syntaxe et leurs applications.

2.3 Entrées/sorties
Les programmes Python ne se contentent pas d’effectuer des calculs internes : ils interagissent
souvent avec l’utilisateur en affichant des résultats ou en collectant des données. Les opérations
d’entrées/sorties (E/S) permettent cette communication. La sortie consiste à afficher des informa-
tions, généralement à l’écran, tandis que l’entrée permet de lire des données saisies par l’utilisateur,
comme du texte ou des nombres. Ces mécanismes de base des entrées/sorties en Python sont assurés
par la fonction print() pour les sorties et la fonction input() pour les entrées.

2.3.1 Fonction print() : paramètres sep, end

La fonction print() est l’outil principal pour afficher des données à l’écran, que ce soit du texte,
des nombres ou des résultats de calculs. Nous l’avons déjà utilisée dans les sections précédentes.
Elle est flexible et permet de personnaliser la présentation des sorties grâce à des paramètres comme
sep et end.

[Link] Affichage de base

Par défaut, print() affiche ses arguments séparés par une espace 8 et termine par un saut de ligne
(\n). Cela permet d’afficher plusieurs valeurs dans une seule instruction.
>>> nom = "Alice"
>>> age = 20
>>> print(nom, age)
Alice 20

5. [Link]
6. [Link]
7. [Link]
8. On parle de « une espace » au féminin lorsqu’il s’agit du caractère typographique (et non d’un lieu ou d’une
surface).

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 38 Chapitre 2. Variables, types et entrées/sorties

Ici, nom et age sont affichés avec une espace entre eux, suivie d’un saut de ligne. Le shell affiche
chaque appel à print() sur une nouvelle ligne.

[Link] Paramètre sep

Le paramètre sep (séparateur) définit la chaîne utilisée pour séparer plusieurs arguments dans
un même appel à print(). Par défaut, sep=" " (une espace), mais vous pouvez le modifier pour
personnaliser l’affichage.
>>> print("01", "01", "1970", sep="−")
01−01−1970
>>> print("x", "y", "z", sep=", ")
x, y, z

Dans le premier cas, sep="−" joint les valeurs avec des tirets, simulant un format de date. Dans le
second, sep=", " utilise une virgule et une espace pour une liste claire.

[Link] Paramètre end

Le paramètre end spécifie ce qui est ajouté à la fin de l’affichage. Par défaut, end="\n" (saut de
ligne), mais vous pouvez le remplacer par une autre chaîne pour modifier le comportement.
1 print("En cours", end="...")
2 print("Terminé")

En cours...Terminé

Ici, end="..." supprime le saut de ligne après "En cours" et le prochain print() continue sur la
même ligne. Sans end="...", "Terminé" aurait été affiché sur une nouvelle ligne.

2.3.2 Fonction input() : lecture de chaînes

La fonction input() permet à un programme de lire des données saisies par l’utilisateur via
le clavier. Elle est utile pour collecter des informations qui peuvent ensuite être traités dans
le programme. Plus simplement, la fonction input(prompt) affiche un message (le prompt) à
l’utilisateur, attend qu’il saisisse du texte et appuie sur Entrée, puis retourne la saisie sous forme de
chaîne de caractères (str). Si aucun prompt n’est fourni, input() attend simplement la saisie sans
afficher de message.

[Link] Utilisation de base

La fonction input() est simple à utiliser : elle affiche le prompt (facultatif), attend la saisie de
l’utilisateur et retourne la chaîne entrée. Cette chaîne peut être stockée dans une variable pour un
traitement ultérieur.
>>> nom = input("Entrez votre nom : ")
Entrez votre nom : Alice
>>> print(f"Bonjour {nom}")
Bonjour Alice

Ici, input("Entrez votre nom : ") affiche le message, l’utilisateur tape Alice et la chaîne
"Alice" est assignée à nom. Le print() suivant utilise cette valeur pour un message personnalisé.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 2.3 Entrées/sorties 39

[Link] Conversion des entrées

Puisque input() retourne toujours une chaîne, vous devez souvent convertir la saisie en un autre
type (comme int ou float) pour effectuer des calculs numériques. Cela nécessite l’utilisation des
fonctions de conversion (int(), float(), etc.).
1 # Calcul de l'âge l'année prochaine
2 age = input("Entrez votre âge : ")
3 age = int(age) # Conversion en entier
4 print(f"Dans un an, vous aurez {age + 1} ans.")

Sortie (en supposant que l’utilisateur entre 20) :

Entrez votre âge : 20
Dans un an, vous aurez 21 ans.

La saisie "20" est convertie en 20 (entier) avec int(), ce qui permet d’effectuer l’addition age + 1.
Il faut également noter que les lignes 2 et 3 peuvent être combinées en une seule.
1 # Calcul de l'âge l'année prochaine
2 age = int(input("Entrez votre âge : "))
3 print(f"Dans un an, vous aurez {age + 1} ans.")

De cette manière, l’entrée est directement convertie en un entier avant que sa valeur ne soit assignée
à la variable age.
Note. La conversion des saisies peut échouer si l’utilisateur entre une valeur non valide. Par
exemple, int("abc") ou float("3.14.15") provoquent une ValueError. À ce stade, supposez
que les entrées sont correctes, mais une gestion des erreurs d’entrée sera nécessaire : on ne fait
jamais confiance aux entrées utilisateur.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 3. Structures de contrôle

Jusqu’à présent, vos programmes Python ont suivi une exécution linéaire : chaque instruction était
exécutée séquentiellement, de haut en bas. Cependant, dans la réalité, les programmes doivent
souvent prendre des décisions, répéter des actions ou réagir différemment selon les données ou
les entrées utilisateur. Les structures de contrôle permettent de diriger le flux d’exécution d’un
programme en fonction de conditions ou de boucles. Ce chapitre introduit les outils fondamen-
taux pour rendre vos programmes dynamiques : les opérateurs de comparaison et logiques, les
instructions conditionnelles et les boucles. Vous apprendrez également à contrôler les boucles et à
gérer les erreurs avec une introduction aux exceptions. Ces concepts sont essentiels pour créer des
programmes interactifs, capables de s’adapter à différentes situations.

3.1 Opérateurs de comparaison et logiques

Pour qu’un programme puisse prendre des décisions, il doit être capable de comparer des valeurs et
de combiner des conditions. Les opérateurs de comparaison permettent de vérifier des relations
entre des valeurs, tandis que les opérateurs logiques combinent plusieurs conditions pour former
des expressions complexes. Ces opérateurs produisent des valeurs booléennes (True ou False) qui
servent de base aux structures conditionnelles et aux boucles.

3.1.1 Opérateurs de comparaison

Les opérateurs de comparaison comparent deux valeurs et retournent un booléen indiquant si la
relation spécifiée est vraie ou fausse. Autrement dit, un opérateur de comparaison évalue la relation
entre deux opérandes (valeurs ou expressions) et retourne True si la condition est satisfaite, False
sinon. Ces opérateurs sont utilisés pour construire des conditions dans les structures de contrôle.
Voici la liste des opérateurs de comparaison en Python :
• == : Égalité.
• != : Différence.
• < : Strictement inférieur.
• > : Strictement supérieur.
• <= : Inférieur ou égal.
• >= : Supérieur ou égal.
 42 Chapitre 3. Structures de contrôle

>>> x = 10
>>> y = 20
>>> x == y
False
>>> x != y
True
>>> x < y
True
>>> x >= 10
True
>>> −1 < x < 10
False

Les opérateurs de comparaison fonctionnent avec différents types, comme les nombres (int, float)
et les chaînes (str), mais leur comportement dépend du type. Pour les nombres, la comparaison
suit l’ordre mathématique. Pour les chaînes, la comparaison est lexicographique (suivant l’ordre
alphabétique.), basée sur l’ordre Unicode des caractères (par exemple, "A" précède "B" et "ananas"
précède "banane").
>>> mot1 = "chat"
>>> mot2 = "chien"
>>> mot1 < mot2
True
>>> "Z" < "a"
True

Ici, mot1 < mot2 est True, car "chat" précède "chien" dans l’ordre lexicographique. De même,
"Z" < "a" est True, car les majuscules (Unicode plus bas) précèdent les minuscules. L’ordre est
comme suit : 0−9A−Za−z puis les caractères accentués.
Note. Comparer des types différents, comme un entier et une chaîne, peut provoquer une TypeError
, sauf pour == et !=, qui retournent généralement False ou True. Par exemple, 5 == "5" retourne
False, mais 5 < "5" provoque une erreur. Assurez-vous que les opérandes sont compatibles avant
de comparer. De plus, faites bien attention à ne pas confondre l’opérateur d’affectation = qui
affecte une valeur à une variable et l’opérateur de comparaison == qui compare les valeurs de
deux variables.

3.1.2 Opérateurs logiques

Les opérateurs logiques permettent de combiner plusieurs conditions pour former des expressions
booléennes complexes. Ils sont utiles lorsque vous devez vérifier plusieurs critères à la fois, comme
dans une instruction conditionnelle. Voici les trois opérateurs logiques en Python :
• and : Retourne True si les deux conditions sont vraies.
• or : Retourne True si au moins une condition est vraie.
• not : Inverse la valeur booléenne (True devient False, et vice versa).
Ces opérateurs sont évalués dans l’ordre suivant : not, and, or, mais des parenthèses peuvent être
utilisées pour changer cet ordre.
>>> age = 25
>>> salaire = 30000
>>> age >= 18 and salaire > 20000
True
>>> age < 18 or salaire > 20000
True
>>> not (age == 25)

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 3.2 Instructions conditionnelles 43

False

Explications :
• age >= 18 and salaire > 20000 est True, car age >= 18 (True) et salaire > 20000
(True) sont tous deux satisfaits.
• age < 18 or salaire > 20000 est True, car salaire > 20000 est True, même si age <
18 est False.
• not (age == 25) est False, car age == 25 est True et not True donne False.
Les opérateurs logiques peuvent être combinés pour créer des conditions complexes. Pour éviter
toute ambiguïté, utilisez des parenthèses pour clarifier l’ordre d’évaluation, surtout lorsque and, or
et not sont mélangés.
Note. Les opérateurs logiques en Python utilisent une évaluation paresseuse (ou short-circuit
evaluation). Par exemple, dans A and B, si A est False, B n’est pas évalué, car le résultat sera
False quoi qu’il arrive. De même, dans A or B, si A est True, B n’est pas évalué. Cette propriété
peut améliorer les performances et éviter des erreurs, comme vérifier qu’une variable existe avant
de l’utiliser.

3.1.3 Opérateur in
L’opérateur in est un opérateur spécial qui vérifie si une valeur est présente dans une séquence,
comme une chaîne, une liste ou un tuple (les listes et tuples seront abordés dans le chapitre 4). Il
retourne True si la valeur est trouvée, False sinon. L’opérateur not in est son inverse, vérifiant
l’absence d’une valeur.
>>> texte = "Bonjour"
>>> "jour" in texte
True
>>> "soir" in texte
False
>>> "Bon" not in texte
False

Explications :
• "jour" in texte est True, car la sous-chaîne "jour" apparaît dans "Bonjour".
• "soir" in texte est False, car "soir" n’est pas présent.
• "Bon" not in texte est False, car "Bon" est bien dans "Bonjour".
Note. L’opérateur in est sensible à la casse pour les chaînes. Par exemple, "bon" in "Bonjour"
retourne False, car "bon" (minuscule) diffère de "Bon" (majuscule).

3.2 Instructions conditionnelles

Les instructions conditionnelles permettent à un programme de prendre des décisions en exécutant
différentes parties du code selon que certaines conditions sont vraies ou fausses. En Python, les
instructions if, elif et else constituent le mécanisme principal pour gérer ces décisions. Ces
instructions s’appuient sur les opérateurs de comparaison et logiques pour évaluer des conditions
booléennes.

Une instruction conditionnelle évalue une condition (une expression booléenne) et exécute un
bloc de code si la condition est True. En Python, une instruction conditionnelle commence par if,

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 44 Chapitre 3. Structures de contrôle

peut inclure des clauses elif (pour vérifier d’autres conditions) et se termine optionnellement par
else (pour gérer tous les cas restants).

3.2.1 Syntaxe de base

La structure d’une instruction conditionnelle suit ce modèle général :
1 if condition:
2 # Bloc de code exécuté si condition est True
3 elif autre_condition: # Facultatif, peut être répété
4 # Bloc de code exécuté si autre_condition est True
5 else: # Facultatif
6 # Bloc de code exécuté si aucune condition précédente n'est True

Quelques points clés :

• La condition est une expression qui retourne True ou False.
• Les lignes qui contiennent les clauses if, elif ou else se terminent par le caractère deux-
points (:). C’est obligatoire.
• Les blocs de code sont indentés (généralement 4 espaces) pour indiquer qu’ils appartiennent
à la clause if, elif ou else.
• elif permet de tester des conditions supplémentaires si la première est False.
• else capture tous les cas non couverts par les conditions précédentes.
>>> age = 20
>>> if age >= 18:
... print("Vous êtes majeur.")
...
Vous êtes majeur.

Ici, age >= 18 est True, donc le bloc indenté sous if s’exécute et affiche le message. Si age était
inférieur à 18, rien ne s’afficherait, car il n’y a pas de else.

3.2.2 Utilisation de else

La clause else est utilisée pour exécuter un bloc de code lorsque la condition du if est False. Elle
est facultative mais utile pour gérer les cas alternatifs.
Ajoutons une clause else dans notre précédent exemple :
>>> age = 16
>>> if age >= 18:
... print("Vous êtes majeur.")
... else:
... print("Vous êtes mineur.")
...
Vous êtes mineur.

Puisque age >= 18 est False, le bloc sous else s’exécute. Cela garantit qu’un message est toujours
affiché, quel que soit l’âge.

3.2.3 Utilisation de elif

Pour tester plusieurs conditions, utilisez elif. Une fois qu’une condition est True, son bloc
s’exécute et les clauses suivantes (elif ou else) sont ignorées.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 3.2 Instructions conditionnelles 45

Prenons ce programme qui évalue une note :

1 # Évaluation d'une note
2 note = float(input("Entrez votre note (0−20) : "))
3 if note >= 16:
4 print("Très Bien !")
5 elif note >= 14:
6 print("Bien.")
7 elif note >= 12:
8 print("Assez Bien.")
9 elif note >= 10:
10 print("Passable.")
11 else:
12 print("Insuffisant.")

Sortie pour différentes saisies :

• Saisie 17 :
Entrez votre note (0−20) : 17
Très Bien !

• Saisie 10 :
Entrez votre note (0−20) : 10
Passable.

Explications :
• Les conditions sont testées dans l’ordre : si note >= 16 est True, "Très Bien !" s’affiche
et le reste est ignoré.
• Si note >= 16 est False, Python passe à note >= 14, et ainsi de suite.
• else capture les notes inférieures à 10.

3.2.4 Conditions imbriquées

Vous pouvez imbriquer des instructions if à l’intérieur d’autres pour gérer des cas plus complexes.
Cependant, trop d’imbrications rendent le code difficile à lire et des alternatives comme and ou or
sont souvent préférables.
>>> age = 20
>>> permis = "oui"
>>> if age >= 18:
... if permis == "oui":
... print("Vous pouvez conduire.")
... else:
... print("Vous êtes majeur, mais sans permis.")
... else:
... print("Vous êtes mineur.")
...
Vous pouvez conduire.

La condition extérieure age >= 18 est testée en premier. Si elle est True, la condition imbriquée
permis == "oui" détermine le message affiché.

Notes.
1. L’indentation est très importante dans les instructions conditionnelles, ainsi que dans les

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 46 Chapitre 3. Structures de contrôle

structures comme les boucles ou les fonctions, comme vous le verrez plus loin. Une mauvaise
indentation provoque une IndentationError ou change la logique du programme. Prenons,
par exemple :
1 if True:
2 print("Ceci s'exécute")
3 print("Ceci aussi") # Dans le bloc if
4 print("Ceci est hors du if")

Si vous désindentez incorrectement, comme print("Ceci aussi") hors du bloc, le com-

portement change. Utilisez toujours 4 espaces par niveau d’indentation, conformément à la
norme PEP 8. De plus, évitez d’écrire des conditions trop complexes ou trop imbriquées ;
simplifiez-les avec des opérateurs logiques.
2. Les instructions if sont au cœur de la programmation, car elles permettent à vos programmes
de réagir intelligemment aux données. À mesure que vous progressez, vous combinerez if
avec des boucles et des fonctions pour créer des programmes plus puissants. Si une condition
devient trop complexe, envisagez de la décomposer en plusieurs if ou elifpour plus de
clarté.

3.3 Boucles
Les boucles permettent à un programme de répéter une série d’instructions plusieurs fois, ce qui est
essentiel pour automatiser des tâches répétitives, comme traiter une liste de données ou effectuer
des calculs itératifs. En Python, deux types de boucles principales sont utilisés : la boucle for qui
itère sur une séquence prédéfinie et la boucle while qui répète un bloc d’instructions tant qu’une
condition est vraie.

3.3.1 Boucle for et fonction range()

La boucle for est conçue pour parcourir une séquence, c’est-à-dire un ensemble ordonné d’éléments,
comme une liste, une chaîne de caractères ou une plage de nombres générée par la fonction range().
Elle est adaptée lorsque vous connaissez à l’avance le nombre d’itérations ou les éléments à traiter.
La boucle for attribue successivement chaque élément de la séquence à une variable qui peut être
utilisée dans le bloc de code indenté.
La syntaxe de la boucle for est :
1 for variable in sequence:
2 # Bloc de code exécuté pour chaque élément

La fonction range() génère une séquence de nombres, souvent utilisée pour contrôler le nombre
d’itérations dans une boucle for. Elle peut être utilisée de trois façons :
• range(n) : Génère les nombres de 0 à n−1 avec un incrément de 1.
• range(debut, fin) : Génère les nombres de debut à fin−1 avec un incrément de 1.
• range(debut, fin, pas) : Génère les nombres de debut à fin−1 avec un incrément de
pas.

>>> for i in range(5):

... print(i)
...
0
1
2

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

3.3 Boucles 47

3
4

Ici, range(5) génère les nombres 0, 1, 2, 3, 4, et la variable i prend chaque valeur successive-
ment. Le bloc indenté affiche chaque nombre.
Voici un autre exemple pour compter à rebours :
>>> for seconde in range(10, 0, −1):
... print(f"T−{seconde} secondes")
... print("Décollage !")
...
T−10 secondes
T−9 secondes
...
T−1 secondes
Décollage !

range(10, 0, −1) génère les nombres de 10 à 1 en décrémentant de 1 à chaque itération.

Note. range() ne fonctionne pas directement avec les nombres flottants, par exemple, range(0,
1, 0.1) provoque une erreur. Les paramètres debut, fin et pas doivent tous être des entiers ou
des variables de type entier. Pour des paramètres non entiers, utilisez une boucle while.
En plus des nombres, une boucle for peut parcourir une chaîne de caractères en traitant chaque
caractère comme un élément de la séquence. Cela est utile pour analyser du texte, compter des
lettres ou effectuer des transformations caractère par caractère. Une chaîne est vue comme une
séquence ordonnée de caractères et la boucle attribue chaque caractère à la variable d’itération.
>>> mot = "Python"
>>> for lettre in mot:
... print(f"Caractère : {lettre}")
...
Caractère : P
Caractère : y
Caractère : t
Caractère : h
Caractère : o
Caractère : n

Chaque caractère de "Python" est assigné à lettre et le bloc affiche chaque caractère sur une
nouvelle ligne.

Parfois, vous voulez accéder à la fois à l’élément d’une séquence et à sa position (ou index) dans
la boucle. La fonction enumerate() est un outil intégré qui génère des paires (index, élément)
pour chaque itération. Cela rend le code plus clair que l’utilisation manuelle d’un compteur. Bien
que enumerate() soit souvent utilisé avec des listes, il fonctionne parfaitement avec des chaînes
ou range().
>>> texte = "code"
>>> for index, caractere in enumerate(texte):
... print(f"Position {index} : {caractere}")
...
Position 0 : c
Position 1 : o
Position 2 : d
Position 3 : e

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 48 Chapitre 3. Structures de contrôle

enumerate(texte) produit des paires (0, 'c'), (1, 'o'), (2, 'd'), (3, 'e'), décomposées
dans les variables index et caractere. Cela permet de suivre la position de chaque caractère sans
gérer un compteur manuellement.
Un détail subtil mais important concerne la variable de boucle (comme i ou lettre des exemples
précédents). Après l’exécution d’une boucle for, cette variable n’est pas supprimée ; elle conserve
la dernière valeur qu’elle a prise dans la boucle. Cela peut être utile pour vérifier l’état final, mais
cela peut aussi causer des erreurs si vous réutilisez la variable sans la réinitialiser.
Observons la persistance dans le shell :
>>> for i in range(4):
... print(i)
...
0
1
2
3
>>> print(f"Dernière valeur de i : {i}")
Dernière valeur de i : 3

Après la boucle, i vaut 3, la dernière valeur de range(4). Si la boucle est vide (par exemple,
range(0)), i n’est pas définie, ce qui peut provoquer une NameError si vous tentez de l’utiliser.

Note. La persistance de la variable de boucle peut entraîner des erreurs si vous supposez qu’elle
est réinitialisée ou non définie après la boucle. Par exemple, réutiliser i dans une autre boucle sans
le savoir peut fausser les résultats. Pour éviter cela, initialisez explicitement vos variables avant de
les utiliser ailleurs ou utilisez des noms de variables distincts pour chaque boucle.
Il est également capital de souligner l’importance de l’indentation en Python. Telle qu’introduite
dans le chapitre 1, une indentation incorrecte peut provoquer une IndentationError ou altérer
la logique du programme, entraînant des résultats inattendus. Par exemple, une instruction mal
indentée pourrait être exécutée en dehors de la boucle, changeant complètement le comportement
du programme. Vous devez donc vérifier soigneusement l’alignement de chaque ligne dans vos
boucles.
De plus, une indentation incohérente, comme mélanger des espaces et des tabulations, provoque
une TabError. Utilisez toujours 4 espaces par niveau d’indentation, conformément à la norme
PEP 8. Assurez-vous donc toujours que toutes les lignes d’un même bloc ont exactement le même
niveau d’indentation pour éviter des erreurs ou des comportements imprévus.

3.3.2 Boucle while

La boucle while répète un bloc de code tant qu’une condition booléenne reste True sans dépendre
d’une séquence prédéfinie. Si la condition devient False, la boucle s’arrête et l’exécution passe à
l’instruction suivante. Elle est utile lorsque le nombre d’itérations n’est pas connu à l’avance, par
exemple pour attendre une entrée utilisateur valide ou atteindre un seuil. Cependant, elle nécessite
une attention particulière pour éviter les boucles infinies.
La syntaxe est :
1 while condition:
2 # Bloc de code exécuté tant que condition est True

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

3.3 Boucles 49

Dans l’exemple qui suit, la boucle continue tant que compte < 3. À chaque itération, compte est
incrémenté avec += 1. Lorsque compte atteint 3, la condition devient False et la boucle s’arrête.
>>> compte = 0
>>> while compte < 3:
... print(f"Itération {compte}")
... compte += 1
...
Itération 0
Itération 1
Itération 2

On peut également utiliser la boucle while pour contrôler l’entrée utilisateur. Voici un exemple
pour demander une entrée valide :
1 # Demande un nombre positif
2 nombre = float(input("Entrez un nombre strictement positif : "))
3 while nombre <= 0:
4 print("Erreur : le nombre doit être strictement positif.")
5 nombre = float(input("Entrez un nombre strictement positif : "))
6 print(f"Merci, vous avez entré {nombre}.")

Sortie (pour les saisies −5, 0, 42) :

Entrez un nombre strictement positif : −5
Erreur : le nombre doit être strictement positif.
Entrez un nombre strictement positif : 0
Erreur : le nombre doit être strictement positif.
Entrez un nombre strictement positif : 42
Merci, vous avez entré 42.0.

La boucle while continue de demander une saisie tant que nombre <= 0. Une fois que nombre > 0,
la boucle s’arrête.

Une boucle while peut devenir infinie si la condition ne devient jamais False. Cela peut survenir si
vous oubliez de modifier une variable dans la boucle ou si la condition est mal définie. Par exemple,
while True: sans mécanisme de sortie (comme break) exécutera le programme indéfiniment, ce
qui peut bloquer votre terminal ou consommer des ressources.
Voici une boucle infinie accidentelle :
>>> n = 3
>>> while n > 0:
... print(n)
... # Oubli de décrémenter n
...
3
3
3
... (continue indéfiniment)

Pour éviter les boucles infinies, vérifiez toujours que la condition de votre boucle while peut
devenir False à un moment donné.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 50 Chapitre 3. Structures de contrôle

3.4 Contrôle des boucles : break, continue

Les boucles for et while suivent un déroulement prévisible, mais parfois, vous devez intervenir
pour modifier leur comportement : arrêter la boucle avant qu’elle ne se termine ou ignorer certaines
itérations sans affecter les autres. Les instructions break et continue offrent ce contrôle précis.
Elles agissent comme des interrupteurs dans une chaîne de production : break arrête la machine,
tandis que continue saute une étape sans arrêter le processus.
• break : Interrompt immédiatement la boucle en cours (for ou while) et passe à l’instruction
suivante après la boucle.
• continue : Ignore le reste du bloc de code pour l’itération actuelle et passe à l’itération
suivante.
Ces instructions, utilisées judicieusement, rendent vos boucles plus flexibles, mais elles nécessitent
une attention particulière pour éviter de compliquer la logique de votre programme.

3.4.1 Utilisation de break

L’instruction break est comme une sortie de secours : elle met fin à la boucle dès qu’une condition
spécifique est remplie en évitant de parcourir inutilement le reste de la séquence ou de continuer à
évaluer la condition. Elle est souvent utilisée pour arrêter une recherche, quitter un menu interactif
ou gérer des conditions d’erreur.
>>> mot = "Bonjour"
>>> for lettre in mot:
... if lettre == "j":
... print("Trouvé 'j' !")
... break
... print(f"Vérification de '{lettre}'")
...
Vérification de 'B'
Vérification de 'o'
Vérification de 'n'
Trouvé 'j' !

Dès que lettre == "j", break interrompt la boucle et les caractères restants (o, u, r) ne sont pas
vérifiés.
Un autre exemple avec la boucle while :
1 # Boucle avec option de quitter
2 while True:
3 reponse = input("Entrez un mot (ou 'quitter' pour arrêter) : ")
4 if reponse == "quitter":
5 break
6 print(f"Vous avez entré : {reponse}")
7 print("Programme terminé.")

Sortie (pour les saisies bonjour, python, quitter) :

Entrez un mot (ou 'quitter' pour arrêter) : bonjour
Vous avez entré : bonjour
Entrez un mot (ou 'quitter' pour arrêter) : python
Vous avez entré : python
Entrez un mot (ou 'quitter' pour arrêter) : quitter
Programme terminé.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 3.5 Introduction aux exceptions 51

La boucle while True est potentiellement infinie, mais break l’arrête lorsque l’utilisateur entre
quitter.

3.4.2 Utilisation de continue

L’instruction continue agit comme un filtre : elle permet de sauter le reste du bloc de code pour
une itération spécifique en passant immédiatement à l’itération suivante. Elle est utile pour ignorer
des cas non pertinents, comme des entrées invalides ou des valeurs qui ne répondent pas à un critère,
tout en poursuivant la boucle.
>>> for i in range(6):
... if i % 2 == 0:
... continue
... print(f"Nombre impair : {i}")
...
Nombre impair : 1
Nombre impair : 3
Nombre impair : 5

Lorsque i est pair (i % 2 == 0), continue saute l’instruction print() et seuls les nombres impairs
sont affichés.

Note. Un usage excessif de break et continue peut compliquer la lisibilité du code, car ils
introduisent des sauts dans le flux naturel de la boucle. Une boucle avec de multiples continue peut
être difficile à suivre, car il faut vérifier quelles instructions sont sautées. Préférez des conditions
explicites dans la boucle while ou des séquences filtrées dans une boucle for lorsque possible. Par
exemple, au lieu de continue pour ignorer les nombres pairs, vous pourriez utiliser range(1, 6,
2) pour ne parcourir que les impairs.

3.5 Introduction aux exceptions

Dans vos programmes, des erreurs peuvent survenir lorsque des opérations échouent, comme
convertir une chaîne invalide en nombre ou diviser par zéro. Ces erreurs, appelées exceptions
en Python, interrompent l’exécution normale du programme si elles ne sont pas gérées. Jusqu’à
présent, vous avez peut-être vu des messages comme ValueError ou TypeError dans le shell,
accompagnés d’une trace d’erreur (traceback). Plutôt que de laisser ces exceptions arrêter votre
programme, Python offre un mécanisme pour les capturer et les traiter de manière contrôlée : les
blocs try et except. Cette section introduit les bases de la gestion des exceptions.

3.5.1 Qu’est-ce qu’une exception ?

Une exception est une interruption dans le flux normal d’un programme, déclenchée lorsqu’une
erreur survient pendant l’exécution. C’est un événement d’erreur qui interrompt l’exécution d’un
programme. En Python, une telle erreur lève une exception, qui, si elle n’est pas gérée, arrête le
programme et affiche un message d’erreur. On retrouve parmi les exceptions les plus courantes :

• ValueError : Levée lorsqu’une fonction reçoit une valeur inappropriée, comme int("abc").
• TypeError : Levée lorsqu’une opération est appliquée à des types incompatibles, comme
"5" + 3.
• ZeroDivisionError : Levée lors d’une division par zéro, comme 10 / 0.

Les blocs try et except permettent de capturer (catch) ces exceptions pour les traiter sans arrêter

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 52 Chapitre 3. Structures de contrôle

le programme en offrant une alternative à l’arrêt brutal.

3.5.2 Syntaxe de try-except

La gestion des exceptions repose sur deux blocs principaux : try, où vous placez le code susceptible
de lever une exception et except, où vous définissez comment réagir si une exception survient. La
structure de base est :
1 try:
2 # Bloc de code susceptible de lever une exception
3 except TypeException:
4 # Bloc de code exécuté si TypeException est levée

Points clés :
• Le bloc try contient les instructions que vous voulez surveiller pour des erreurs. Si une
exception est levée dans ce bloc, l’exécution s’arrête immédiatement à l’instruction fautive et
Python passe au bloc except correspondant.
• Le bloc except spécifie le type d’exception à capturer (par exemple, ValueError). Si
l’exception levée correspond, le bloc except s’exécute ; sinon, l’exception n’est pas capturée
et peut arrêter le programme.
• L’indentation est essentielle : les instructions sous try et except doivent être correctement
alignées pour indiquer leur appartenance à chaque bloc.
Testons un bloc try−except pour gérer une conversion risquée :
>>> try:
... nombre = int(input("Entrez un entier : "))
... print(f"Vous avez entré : {nombre}")
... except ValueError:
... print("Erreur : veuillez entrer un entier valide.")
...
Entrez un entier : 42
Vous avez entré : 42
Entrez un entier : abc
Erreur : veuillez entrer un entier valide.

Explications :
• Dans le bloc try, int(input(...)) tente de convertir l’entrée en entier.
• Si l’entrée est valide (par exemple, "42"), la conversion réussit et print() affiche le résultat.
• Si l’entrée est invalide (par exemple, "abc"), int() lève une ValueError et le bloc except
ValueError s’exécute, affichant un message d’erreur.

3.5.3 Capturer plusieurs exceptions

Un bloc try peut être suivi de plusieurs blocs except pour gérer différents types d’exceptions.
Cela permet de personnaliser la réponse selon la nature de l’erreur, comme afficher un message
spécifique pour une ValueError et un autre pour une ZeroDivisionError. L’ordre des except est
important : Python teste chaque bloc dans l’ordre, de haut en bas et le premier correspondant est
exécuté.
Voici un programme qui gère plusieurs exceptions :
1 # Gestion de multiples exceptions
2 try:

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 3.5 Introduction aux exceptions 53

3 nombre = int(input("Entrez un entier : "))

4 resultat = 100 / nombre
5 print(f"100 divisé par {nombre} vaut {resultat}")
6 except ValueError:
7 print("Erreur : veuillez entrer un entier valide.")
8 except ZeroDivisionError:
9 print("Erreur : division par zéro impossible.")
10 print("Le programme continue.")

Sortie pour différentes saisies :

• Saisie 5 :
Entrez un entier : 5
100 divisé par 5 vaut 20.0
Le programme continue.

• Saisie abc :
Entrez un entier : abc
Erreur : veuillez entrer un entier valide.
Le programme continue.

• Saisie 0 :
Entrez un entier : 0
Erreur : division par zéro impossible.
Le programme continue.

Explications :
• Le bloc try tente une conversion (int()) et une division (100 / nombre).
• Si int() échoue, ValueError est capturé et un message approprié s’affiche.
• Si nombre est 0, ZeroDivisionError est capturé pour la division.

3.5.4 Capturer toutes les exceptions (approche générique)

Il est possible d’utiliser un bloc except sans spécifier de type d’exception, ce qui capture toutes
les exceptions. Cependant, cette approche est déconseillée, car elle peut masquer des erreurs
inattendues en rendant le débogage difficile. À ce stade, il est préférable de l’utiliser avec prudence,
uniquement lorsque vous êtes certain des exceptions possibles.
>>> try:
... nombre = int(input("Entrez un entier : "))
... resultat = 10 / nombre
... except:
... print("Une erreur s'est produite.")
...
Entrez un entier : abc
Une erreur s'est produite.
Entrez un entier : 0
Une erreur s'est produite.

Ce bloc capture à la fois ValueError et ZeroDivisionError, mais le message est vague, ne

distinguant pas les causes. Une gestion spécifique, comme dans l’exemple précédent, est plus
informative.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 54 Chapitre 3. Structures de contrôle

Note. Capturer toutes les exceptions avec un except générique peut cacher des erreurs graves
ou inattendues, comme une KeyboardInterrupt (lorsque l’utilisateur interrompt le programme
avec Ctrl+C). Privilégiez des blocs except spécifiques pour garder le contrôle sur les erreurs
gérées. De plus, si plusieurs blocs except sont utilisés, placez les exceptions spécifiques avant
un except générique, car Python exécute le premier bloc correspondant. Par exemple, except
ValueError doit précéder except, sinon le except générique capturera tout en rendant ValueError
inaccessible.

3.5.5 Subtilités et bonnes pratiques

Voici quelques subtilités et recommandations pour utiliser try−except efficacement :
• Limitez le code dans try. Incluez uniquement les instructions susceptibles de lever une
exception. Placer trop de code dans try rend difficile l’identification de la source de l’erreur.
Par exemple, au lieu de mettre toute une boucle dans try, protégez seulement l’opération
risquée à l’intérieur.
• Fournissez des messages clairs. Les messages dans except doivent guider l’utilisateur, par
exemple, "Veuillez entrer un entier valide." au lieu de "Erreur.". Cela améliore
l’expérience utilisateur et facilite le débogage.
• Évitez de masquer les erreurs. Ne laissez pas un bloc except vide (except: pass), car
cela ignore l’erreur sans indication, ce qui peut compliquer la détection de problèmes.
• Testez les cas limites. Essayez des entrées comme "" (chaîne vide), "3.14" (décimal) ou 0
pour vous assurer que votre gestion des exceptions couvre tous les scénarios probables.
Illustration :
1 while True:
2 try:
3 num = int(input("Entrez le numérateur (entier) : "))
4 den = int(input("Entrez le dénominateur (entier) : "))
5 resultat = num / den
6 print(f"{num} divisé par {den} vaut {resultat}")
7 break # Sort de la boucle si la division réussit
8 except ValueError:
9 print("Erreur : les deux entrées doivent être des entiers.")
10 except ZeroDivisionError:
11 print("Erreur : le dénominateur ne peut pas être zéro.")

Entrez le numérateur (entier) : 10

Entrez le dénominateur (entier) : abc
Erreur : les deux entrées doivent être des entiers.
Entrez le numérateur (entier) : 10
Entrez le dénominateur (entier) : 0
Erreur : le dénominateur ne peut pas être zéro.
Entrez le numérateur (entier) : 10
Entrez le dénominateur (entier) : 2
10 divisé par 2 vaut 5.0

Explications :
• Le bloc try protège uniquement les opérations risquées (int() et /), cela limite la portée de
la gestion d’erreurs.
• Les messages d’erreur sont spécifiques et informatifs en guidant l’utilisateur.
Note. À ce stade, try−except est un outil simple mais puissant pour gérer les erreurs courantes,
comme les entrées invalides ou les divisions par zéro. Il remplace les vérifications manuelles par

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

3.5 Introduction aux exceptions 55

une approche plus élégante en permettant au programme de "tenter" une opération et de réagir si
elle échoue. Consultez la documentation officielle 1 ou Real Python 2 si vous souhaitez explorer
des fonctionnalités avancées, comme les clauses else et finally, la levée d’exceptions avec
raise et la création d’exceptions personnalisées. Pour l’instant, concentrez-vous sur la capture des
exceptions courantes avec des blocs spécifiques et des messages clairs.

1. [Link]
2. [Link]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 4. Collections de données

Avant ce chapitre, vos programmes ont manipulé des données simples, comme des nombres, des
chaînes ou des booléens, stockés dans des variables individuelles. Cependant, dans de nombreuses
situations, vous devez gérer des ensembles de données organisées, comme une liste de notes, une
série de noms ou une collection de mesures. Les collections en Python permettent de regrouper
plusieurs valeurs dans une seule structure, facilitant leur manipulation et leur traitement. Dans ce
chapitre, nous étudierons les principales collections que sont les listes, les tuples, les dictionnaires
et les ensembles. Chaque type a ses propres caractéristiques, usages et méthodes qui vous offrent
des outils puissants pour structurer et analyser des données.

4.1 Listes
Les listes sont des collections ordonnées, modifiables et capables de contenir des éléments de
différents types (nombres, chaînes ou même d’autres listes). Elles sont idéales pour stocker des
données séquentielles.

4.1.1 Création, indexation, slicing

Une liste est une collection ordonnée et modifiable d’éléments, délimitée par des crochets [] et
séparée par des virgules. Chaque élément est accessible par un index (position, commençant à 0).
Les listes sont l’une des structures de données les plus utilisées en Python en raison de leur
simplicité.

[Link] Création d’une liste

Pour créer une liste, placez les éléments entre crochets [], séparés par des virgules. Une liste peut
être vide ou contenir des éléments de types variés, comme des entiers, des flottants, des chaînes ou
des booléens.
>>> nombres = [1, 2, 3, 4]
>>> mots = ["chat", "chien", "oiseau"]
>>> mixte = [42, "Python", 3.14, True]
>>> vide = []
>>> print(nombres, mots, mixte, vide)
 58 Chapitre 4. Collections de données

[1, 2, 3, 4] ['chat', 'chien', 'oiseau'] [42, 'Python', 3.14, True] []

Chaque liste est définie par ses éléments. vide est une liste sans éléments, utile comme point
de départ pour accumuler des données. Les éléments de mixte montrent que les listes peuvent
mélanger différents types sans restriction.

[Link] Indexation

Les éléments d’une liste sont accessibles via leur indice (ou index), un entier indiquant leur position.
Les indices commencent à 0 pour le premier élément, 1 pour le second et ainsi de suite. Python
permet également une indexation négative, comme vu avec les chaînes de caractères, où −1 désigne
le dernier élément, −2 l’avant-dernier, etc.
>>> fruits = ["pomme", "banane", "orange"]
>>> print(fruits[0])
pomme
>>> print(fruits[2])
orange
>>> print(fruits[−1])
orange
>>> print(fruits[−2])
banane

Explications :

• fruits[0] accède au premier élément, "pomme".

• fruits[2] accède au troisième élément, "orange".
• fruits[−1] accède au dernier élément, "orange".
• fruits[−2] accède à l’avant-dernier, "banane".

Vous pouvez également modifier un élément en assignant une nouvelle valeur à un index spécifique,
car les listes sont mutables (ou modifiables), contrairement aux chaînes de caractères qui sont
immuables.
Testons la modification via indexation :
>>> fruits = ["pomme", "banane", "orange"]
>>> fruits[1] = "ananas"
>>> print(fruits)
['pomme', 'ananas', 'orange']

fruits[1] = "ananas" remplace "banane" par "ananas". Cette opération ne change pas la taille
de la liste, seulement l’élément à l’index spécifié.
Note. Accéder à un index inexistant provoque une IndexError. Par exemple, fruits[3] dans une
liste de 3 éléments échoue, car les indices valides sont 0, 1, 2. De même, les indices négatifs
doivent rester dans les limites : fruits[−4] échoue pour une liste de 3 éléments.
>>> fruits = ["pomme", "banane"]
>>> print(fruits[2])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 4.1 Listes 59

[Link] Découpage (slicing)

Le découpage permet d’extraire une sous-liste en spécifiant une plage d’indices sous la forme
[debut:fin], où debut est inclus et fin est exclu. Vous pouvez également inclure un pas pour
sauter des éléments : [debut:fin:pas]. Si debut ou fin sont omis, Python utilise les valeurs par
défaut (début de la liste ou fin). On se rend compte que la syntaxe est la même que celle utilisée sur
les chaînes de caractères.
>>> nombres = [0, 1, 2, 3, 4, 5]
>>> print(nombres[1:4])
[1, 2, 3]
>>> print(nombres[:3])
[0, 1, 2]
>>> print(nombres[2:])
[2, 3, 4, 5]
>>> print(nombres[::2])
[0, 2, 4]
>>> print(nombres[::−1])
[5, 4, 3, 2, 1, 0]

Explications :

• nombres[1:4] extrait les éléments des indices 1 à 3 (1, 2, 3).

• nombres[:3] extrait du début à l’index 2 (0, 1, 2).
• nombres[2:] extrait de l’index 2 à la fin (2, 3, 4, 5).
• nombres[::2] prend tous les éléments avec un pas de 2 (0, 2, 4).
• nombres[::−1] inverse la liste avec un pas de -1.

Le découpage peut également être utilisé pour modifier plusieurs éléments à la fois en assignant
une nouvelle liste à une plage d’indices.
>>> nombres = [0, 1, 2, 3, 4]
>>> nombres[1:3] = [10, 20]
>>> print(nombres)
[0, 10, 20, 3, 4]
>>> nombres[1:3] = [25, 35, 45]
>>> print(nombres)
[0, 25, 35, 45, 3, 4]

nombres[1:3] remplace [1, 2] par [10, 20]. La nouvelle liste n’a pas besoin d’avoir la même
longueur, ce qui peut modifier la taille de la liste.
Note. Le slicing est une fonctionnalité puissante des listes pour extraire ou modifier des sous-
ensembles. Cependant, un découpage mal défini (par exemple, [5:2] sans pas négatif) retourne une
liste vide, car la plage est invalide. Testez vos découpages avec des cas limites pour comprendre
leur comportement.

[Link] Opérations sur les listes

En plus de la création manuelle avec des crochets, les listes supportent plusieurs opérations
qui permettent de les manipuler de manière efficace : concaténation pour fusionner des listes,
multiplication pour répéter des éléments, conversion d’autres types en listes avec la fonction
list() et calculs statistiques avec des fonctions comme min(), max() et sum().

Concaténation avec + et extend()

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

60 Chapitre 4. Collections de données

La concaténation combine deux listes pour en former une nouvelle contenant tous leurs éléments
dans l’ordre. L’opérateur + crée une nouvelle liste, tandis que la méthode extend() modifie une
liste existante en ajoutant les éléments d’une autre.
>>> liste1 = [1, 2, 3]
>>> liste2 = [4, 5]
>>> nouvelle_liste = liste1 + liste2
>>> print(nouvelle_liste)
[1, 2, 3, 4, 5]
>>> print(liste1, liste2)
[1, 2, 3] [4, 5]

L’opérateur + crée nouvelle_liste en combinant liste1 et liste2, sans modifier les originales.
Maintenant, utilisons extend() :
>>> liste1 = [1, 2, 3]
>>> liste2 = [4, 5]
>>> [Link](liste2)
>>> print(liste1)
[1, 2, 3, 4, 5]
>>> print(liste2)
[4, 5]

[Link](liste2) ajoute les éléments de liste2 à liste1 en modifiant directement liste1

, tandis que liste2 reste inchangée.
Note. L’opérateur + crée une nouvelle liste, ce qui peut consommer plus de mémoire pour de
grandes listes, tandis que extend() est plus efficace, car il modifie la liste en place. Cependant,
extend() altère la liste originale, ce qui peut être indésirable si vous souhaitez la préserver. De
plus, la concaténation ne fonctionne qu’entre listes ; tenter de concaténer une liste avec un autre
type (par exemple, [1, 2] + 3) provoque une TypeError. Assurez-vous que les opérandes sont
des listes avant d’utiliser + ou extend().
>>> [1, 2] + 3
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate list (not "int") to list

Multiplication avec *
L’opérateur * répète les éléments d’une liste un nombre spécifié de fois en créant une nouvelle liste.
>>> items = ["stylo", "cahier"]
>>> repete = items * 3
>>> print(repete)
['stylo', 'cahier', 'stylo', 'cahier', 'stylo', 'cahier']
>>> print(items)
['stylo', 'cahier']

items * 3 crée une nouvelle liste avec les éléments de items répétés trois fois. La liste originale
items reste inchangée.

Vous pouvez également utiliser * pour initialiser une liste avec des valeurs répétées, comme une
liste de zéros.
>>> zeros = [0] * 5

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

4.1 Listes 61

>>> print(zeros)
[0, 0, 0, 0, 0]

[0] * 5 crée une liste de 5 zéros, utile pour initialiser des compteurs ou des tableaux.
Note. L’opérateur * crée une nouvelle liste, donc liste * 2 ne modifie pas liste à moins de
réassigner le résultat. De plus, multiplier par un entier négatif ou zéro produit une liste vide ([]).
Par exemple, [1, 2] * 0 donne [].

Fonction list()
La fonction list() convertit un objet itérable (comme une chaîne, un tuple ou un objet range) en
une liste. Elle est particulièrement utile pour transformer des séquences générées, comme celles
produites par range(), en listes manipulables.
>>> liste_nombres = list(range(5))
>>> print(liste_nombres)
[0, 1, 2, 3, 4]
>>> texte = "abc"
>>> liste_caracteres = list(texte)
>>> print(liste_caracteres)
['a', 'b', 'c']

Note. La fonction list() est essentielle pour travailler avec range(), car un objet range n’est
pas une liste et ne supporte pas directement l’indexation ou les méthodes de liste. Par exemple,
range(5)[0] provoque une erreur, mais list(range(5))[0] retourne 0. Il faut également retenir
que la fonction list() ne s’applique qu’aux objets séquentiels, i.e. aux collections ordonnées
d’éléments comme les chaînes de caractères, les tuples (qu’on abordera dans la section suivante),
les ranges, etc.

Fonctions min(), max() et sum()

Les fonctions intégrées min(), max() et sum() permettent d’analyser le contenu d’une liste en
calculant respectivement la valeur minimale, la valeur maximale et la somme des éléments. Ces
fonctions sont utiles pour les listes de nombres, mais min() et max() fonctionnent aussi sur des
chaînes (en utilisant l’ordre lexicographique).
>>> notes = [12, 15, 9, 18]
>>> print(min(notes))
9
>>> print(max(notes))
18
>>> print(sum(notes))
54
>>> mots = ["chat", "âne", "bœuf"]
>>> print(min(mots))
bœuf
>>> print(max(mots))
âne

Note. Les fonctions min() et max() nécessitent que les éléments soient comparables. Une liste
mixte (par exemple, [1, "deux"]) provoque une TypeError, car Python ne peut pas comparer
un entier et une chaîne. sum() ne fonctionne que sur des listes de nombres (entiers ou flottants) ;
l’utiliser sur des chaînes ou des booléens échoue. De plus, appliquer min(), max() ou sum() à une

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 62 Chapitre 4. Collections de données

liste vide provoque une ValueError (pour min() et max()) ou retourne 0 (pour sum()).
>>> min([1, "deux"])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: '<' not supported between instances of 'str' and 'int'
>>> max([])
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: max() iterable argument is empty
>>> sum([])
0

4.1.2 Méthodes de listes

Les listes sont accompagnées de méthodes, des fonctions intégrées qui permettent de manipuler
leur contenu, comme ajouter, supprimer ou trier des éléments. Une méthode de liste a déjà été
abordée dans la section précédente (extend()).

Une méthode de liste est une fonction associée à un objet liste, invoquée avec la syntaxe liste.
methode(arguments). Les méthodes modifient souvent la liste directement (in-place) ou renvoient
une information à son sujet.
Voici les méthodes principales :
• append(element) : Ajoute un élément à la fin de la liste.
• insert(index, element) : Ajoute un élément à un indice spécifique de la liste.
• pop(index) : Supprime et retourne l’élément à l’index spécifié (ou le dernier si aucun index
n’est donné).
• sort() : Trie la liste en place, par ordre croissant.
• reverse() : Inverse l’ordre des éléments en place.
• len(liste) : Retourne le nombre d’éléments (fonction intégrée, pas une méthode).
• count(element) : Compte les occurrences d’un élément.
• clear() : Supprime tous les éléments, laissant une liste vide.

[Link] append et ajout d’éléments

La méthode append() ajoute un élément à la fin de la liste, cela augmente sa longueur de 1.

>>> courses = ["pain", "lait"]
>>> [Link]("œufs")
>>> print(courses)
['pain', 'lait', 'œufs']

append("œufs") ajoute "œufs" à la fin. La liste est modifiée directement, sans besoin de réassi-
gnation.

[Link] pop et suppression d’éléments

La méthode pop() supprime un élément à un index donné et le retourne, permettant de l’utiliser

ailleurs. Sans argument, pop() supprime et retourne le dernier élément.
>>> fruits = ["pomme", "banane", "orange"]
>>> dernier = [Link]()
>>> print(dernier, fruits)

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 4.1 Listes 63

orange ['pomme', 'banane']

>>> premier = [Link](0)
>>> print(premier, fruits)
pomme ['banane']

pop() sans argument supprime "orange" et pop(0) supprime "pomme". La liste est modifiée et les
éléments supprimés sont retournés.
Note. Appeler pop() sur une liste vide ou avec un index invalide provoque une IndexError. Par
exemple, [].pop() ou [Link](5) pour une liste de 3 éléments échoue.

[Link] sort et reverse

La méthode sort() trie la liste en place, par défaut, par ordre croissant pour les nombres ou
lexicographique pour les chaînes. Mais un argument reverse permet de contrôler l’ordre (True
pour décroissant). La méthode reverse() inverse l’ordre des éléments, sans nécessairement trier.
>>> nombres = [3, 1, 4, 2]
>>> [Link]()
>>> print(nombres)
[1, 2, 3, 4]
>>> [Link](reverse=True)
>>> print(nombres)
[4, 3, 2, 1]
>>> mots = ["chat", "âne", "bœuf"]
>>> [Link]()
>>> print(mots)
['bœuf', 'chat', 'âne']
>>> [Link]()
>>> print(mots)
['âne', 'chat', 'bœuf']

sort() organise nombres en ordre croissant et mots en ordre lexicographique (Unicode). Lorsque
l’argument reverse=True, le tri se fait par ordre décroissant. reverse() inverse l’ordre actuel,
indépendamment du tri.
Note. sort() ne fonctionne que sur des listes homogènes (par exemple, nombres uniquement ou
chaînes uniquement). Trier une liste mixte (comme [1, "deux", 3]) provoque une TypeError, car
Python ne peut pas comparer des types différents. Assurez-vous que les éléments sont comparables
avant d’appeler sort().

[Link] len, count, clear

La fonction len() retourne la longueur de la liste. count() compte combien de fois un élément
apparaît. clear() vide la liste, la laissant avec zéro élément.
>>> notes = [10, 15, 10, 12]
>>> print(len(notes))
4
>>> print([Link](10))
2
>>> [Link]()
>>> print(notes)
[]

len(notes) donne 4, count(10) indique que 10 apparaît deux fois et clear() supprime tous les

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 64 Chapitre 4. Collections de données

éléments.

4.1.3 Listes imbriquées et copie de listes

Les listes ne se limitent pas à contenir des éléments simples comme des nombres ou des chaînes ;
elles peuvent également contenir d’autres listes, formant des listes imbriquées. De plus, copier une
liste nécessite une attention particulière, car une simple assignation peut créer des références non
souhaitées.

[Link] Listes imbriquées

Une liste imbriquée est une liste contenant une ou plusieurs listes comme éléments. Cela crée une
structure hiérarchique, comme une matrice ou un tableau à deux dimensions, utile pour représenter
des données complexes, comme des coordonnées ou des tables de valeurs.
>>> matrice = [[1, 2], [3, 4], [5, 6]]
>>> print(matrice)
[[1, 2], [3, 4], [5, 6]]
>>> print(matrice[1])
[3, 4]
>>> print(matrice[1][0])
3

Explications :
• matrice contient trois sous-listes : [1, 2], [3, 4], [5, 6].
• matrice[1] accède à la deuxième sous-liste, [3, 4].
• matrice[1][0] accède au premier élément de la deuxième sous-liste, 3.
Les listes imbriquées peuvent être modifiées comme des listes simples, en utilisant l’indexation
pour accéder aux sous-listes et à leurs éléments.
>>> grille = [[0, 0], [0, 0]]
>>> grille[0][1] = 1
>>> print(grille)
[[0, 1], [0, 0]]

grille[0][1] = 1 modifie le deuxième élément de la première sous-liste.

[Link] Copie de listes

Copier une liste peut sembler simple, mais une assignation directe (par exemple, liste2 = liste1)
ne crée pas une nouvelle liste : elle crée une référence à la même liste. Modifier liste2 affecte
alors liste1, ce qui peut entraîner des erreurs logiques.
Observons le problème de la référence :
>>> liste1 = [1, 2, 3]
>>> liste2 = liste1
>>> liste2[0] = 99
>>> print(liste1, liste2)
[99, 2, 3] [99, 2, 3]

liste2 = liste1 fait que liste2 pointe vers la même liste. Modifier liste2 change liste1.
Pour créer une copie indépendante, utilisez la méthode copy() ou le découpage [:]. Voici une
copie correcte :

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 4.1 Listes 65

>>> liste1 = [1, 2, 3]

>>> liste2 = [Link]()
>>> liste2[0] = 99
>>> print(liste1, liste2)
[1, 2, 3] [99, 2, 3]

copy() crée une nouvelle liste et modifier liste2 n’affecte pas liste1. Le découpage liste2 =
liste1[:] produit le même résultat.

Note. La méthode copy() et le découpage [:] créent une copie superficielle (shallow copy) qui ne
copie que la liste extérieure. Si la liste contient des sous-listes (imbriquées), les sous-listes restent
des références. Modifier une sous-liste dans la copie affecte l’originale. Par exemple :
>>> original = [[1, 2], [3, 4]]
>>> copie = [Link]()
>>> copie[0][0] = 99
>>> print(original, copie)
[[99, 2], [3, 4]] [[99, 2], [3, 4]]

Pour copier des listes imbriquées, une copie profonde (deep copy) est nécessaire utilisant le module
copy qui sera abordé dans la section [Link] du chapitre 6. Pour l’instant, soyez prudents avec les
listes imbriquées lors de la copie.

4.1.4 Parcours des listes avec la boucle for

Une boucle for sur une liste itère directement sur les éléments de la liste, en assignant chaque
élément à la variable d’itération à chaque tour de boucle. C’est le moyen le plus simple de parcourir
une liste. La syntaxe générale est :
1 for element in liste:
2 # Instructions utilisant element

Considérons une liste contenant des noms :

>>> noms = ["Alice", "Bob", "Charlie"]
>>> for nom in noms:
... print(nom)
...
Alice
Bob
Charlie

Dans cet exemple, la variable nom prend successivement la valeur de chaque élément de la liste
noms ("Alice", "Bob", puis "Charlie").

Note. Lorsque vous parcourez une liste directement avec for element in liste, vous accédez
uniquement aux éléments, pas à leurs indices. Si vous avez besoin des indices, vous devrez utiliser
une méthode différente, comme la fonction enumerate() déjà étudiée dans le chapitre des structures
de contrôle.
Pour rappel, la fonction enumerate() permet de parcourir simultanément les indices et les éléments
d’une liste. Elle renvoie des paires (indice, élément) à chaque itération.
Affichons les éléments d’une liste avec leur position :

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 66 Chapitre 4. Collections de données

>>> fruits = ["pomme", "banane", "orange"]

>>> for indice, fruit in enumerate(fruits):
... print(f"Fruit {indice + 1} : {fruit}")
...
Fruit 1 : pomme
Fruit 2 : banane
Fruit 3 : orange

Note. Par défaut, enumerate() commence à compter les indices à partir de 0. Vous pouvez modifier
ce comportement en spécifiant un indice de départ avec l’argument start. Par exemple :
>>> fruits = ["pomme", "banane", "orange"]
>>> for indice, fruit in enumerate(fruits, start=1):
... print(f"Fruit {indice} : {fruit}")
...
Fruit 1 : pomme
Fruit 2 : banane
Fruit 3 : orange

Bien que le parcours direct ou avec enumerate() soit généralement préférable, il est également
possible de parcourir une liste en utilisant les indices avec la fonction range() et la fonction len().
Cette approche est moins courante mais peut être utile dans certains cas, notamment si vous devez
modifier la liste pendant le parcours.
Affichons les éléments d’une liste en utilisant les indices :
>>> couleurs = ["rouge", "vert", "bleu"]
>>> for i in range(len(couleurs)):
... print(f"Couleur à l'indice {i} : {couleurs[i]}")
...
Couleur à l'indice 0 : rouge
Couleur à l'indice 1 : vert
Couleur à l'indice 2 : bleu

Ici, range(len(couleurs)) génère les indices 0, 1, 2 et couleurs[i] accède à l’élément corres-

pondant à chaque indice.
Note. L’utilisation de range(len(liste)) est souvent moins lisible que le parcours direct ou avec
enumerate(). Préférez les méthodes plus simples sauf si vous avez une raison spécifique d’utiliser
les indices.

4.2 Tuples
Les tuples constituent une autre structure de données fondamentale en Python, utilisée pour stocker
une collection ordonnée d’éléments. Contrairement aux listes étudiées dans la section précédente,
les tuples sont immuables, c’est-à-dire que leur contenu ne peut pas être modifié après leur création.
Cette propriété d’immuabilité confère aux tuples des avantages spécifiques, notamment en termes
de performance et de sécurité dans certains contextes. Vous découvrirez dans cette section comment
créer, manipuler et utiliser les tuples, ainsi que leurs cas d’usage typiques.

Un tuple est une collection ordonnée et immuable d’éléments qui peuvent être de types différents
(nombres, chaînes, autres tuples, etc.). Les tuples sont généralement délimités par des parenthèses
() et les éléments sont séparés par des virgules.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 4.2 Tuples 67

4.2.1 Création et syntaxe

Pour créer un tuple, il suffit de lister les éléments entre parenthèses, séparés par des virgules. Par
exemple, un tuple contenant un entier, une chaîne de caractères et un booléen s’écrit ainsi :
>>> mon_tuple = (42, "Python", True)
>>> print(mon_tuple)
(42, 'Python', True)

Quelques points importants concernant la syntaxe des tuples doivent être notés :
• Un tuple vide est créé avec des parenthèses vides : mon_tuple = () ou avec la fonction
tuple() : mon_tuple = tuple().
• Un tuple avec un seul élément nécessite une virgule finale pour éviter d’être interprété comme
une simple expression entre parenthèses. Par exemple :
>>> tuple_un_element = (5,) # Tuple avec un seul élément
>>> pas_un_tuple = (5) # Juste un entier, pas un tuple
>>> type(tuple_un_element)
<class 'tuple'>
>>> type(pas_un_tuple)
<class 'int'>

• Les parenthèses sont souvent facultatives, sauf pour clarifier la syntaxe ou pour un tuple vide.
Ainsi, a = 1, 2, 'a' crée un tuple implicite (1, 2, 'a').
Note. Omettre la virgule finale pour un tuple à un seul élément est une erreur courante. Assurez-
vous de toujours inclure la virgule, comme dans (5,), pour que Python reconnaisse correctement
le tuple.

4.2.2 Immutabilité des tuples

L’immutabilité est la caractéristique principale qui distingue les tuples des listes. Une fois créé,
un tuple ne peut pas être modifié : il est impossible d’ajouter, de supprimer ou de modifier ses
éléments. Cette propriété garantit que les données stockées dans un tuple restent constantes tout au
long de l’exécution du programme, ce qui peut être utile pour protéger des données critiques.
Considérons l’exemple suivant :
>>> mon_tuple = (1, 2, 3)
>>> mon_tuple[0] = 4 # Tentative de modification
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Cet exemple montre que tenter de modifier un élément d’un tuple provoque une erreur TypeError.
Cette immutabilité fait des tuples un choix idéal pour représenter des données qui ne doivent pas
changer, comme les coordonnées d’un point dans l’espace ou les jours de la semaine.
Note. Bien que les tuples soient immuables, ils peuvent contenir des objets mutables, comme
des listes. Dans ce cas, le contenu de ces objets peut être modifié, mais la structure du tuple (les
références aux objets) reste fixe. Par exemple :
>>> tuple_avec_liste = ([1, 2], "fixe")
>>> tuple_avec_liste[0][0] = 99
>>> print(tuple_avec_liste)
([99, 2], 'fixe')

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 68 Chapitre 4. Collections de données

4.2.3 Accès aux éléments et slicing

Comme pour les listes, les éléments d’un tuple sont accessibles via leur indice, en commençant par
0 pour le premier élément. Le slicing permet également d’extraire une sous-partie du tuple.
Considérons un tuple représentant les mois de l’année :
>>> mois = ("janvier", "février", "mars", "avril")
>>> print(mois[0])
janvier
>>> print(mois[−1])
avril
>>> print(mois[1:3])
('février', 'mars')

• Accéder au premier élément : mois[0] renvoie 'janvier'.

• Accéder au dernier élément : mois[−1] renvoie 'avril'.
• Extraire une sous-partie : mois[1:3] renvoie ('février', 'mars').
Le slicing suit les mêmes règles que pour les listes : [début:fin:pas], où début est inclus, fin
est exclu et pas est optionnel.

4.2.4 Déballage des tuples

Une fonctionnalité puissante des tuples est le déballage (ou unpacking) qui permet d’assigner les
éléments d’un tuple à plusieurs variables en une seule ligne. Cette technique est utile pour simplifier
le code et le rendre plus lisible.
Supposons un tuple représentant les coordonnées d’un point en 2D :
>>> point = (3, 4)
>>> x, y = point # Déballage du tuple
>>> print(x)
3
>>> print(y)
4

Le déballage est également utilisé dans des contextes comme l’échange de variables sans variable
temporaire :
>>> a = 10
>>> b = 20
>>> a, b = b, a # Échange des valeurs via un tuple implicite
>>> print(a, b)
20 10

Note. Le nombre de variables à gauche du signe = doit correspondre au nombre d’éléments dans le
tuple, sinon une erreur ValueError est levée. Par exemple :
>>> x, y = (1, 2, 3) # Trop d'éléments
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: too many values to unpack (expected 2)

Si certains éléments ne vous intéressent pas, vous pouvez utiliser l’underscore (_) pour les ignorer :
>>> x, _, z = (1, 2, 3)

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 4.2 Tuples 69

>>> print(x, z)
1 3

On peut aussi ignorer plusieurs élémentes :

>>> _, y, _ = (4, 5, 6)
>>> print(y)
5

Cela permet de ne pas créer de variables inutiles pour des éléments que l’on souhaite simplement
ignorer.

4.2.5 Cas d’usage des tuples

Les tuples sont utilisés dans plusieurs contextes en Python en raison de leur immutabilité et de leur
légèreté en mémoire par rapport aux listes. Voici quelques cas d’usage courants :
• Représentation de données fixes : Les tuples conviennent pour regrouper des données
hétérogènes qui ne doivent pas être modifiées.
• Retour multiple de fonctions : Les fonctions Python utilisent souvent des tuples pour
retourner plusieurs valeurs.
• Optimisation des performances : Les tuples consomment moins de mémoire et sont plus
rapides à créer et à gérer que les listes, car leur immutabilité simplifie les opérations internes
de Python. Cela est avantageux pour de grandes collections de données fixes.
Un tuple peut représenter une entrée dans un carnet d’adresses :
>>> contact = ("Alice", "Dupont", 30, "[Link]@[Link]")
>>> prenom, nom, age, email = contact
>>> print(f"{prenom} {nom} a {age} ans.")
Alice Dupont a 30 ans.

Cet exemple illustre comment le déballage facilite l’accès aux informations stockées dans le tuple.

4.2.6 Opérations sur les tuples

Bien que les tuples soient immuables, certaines opérations sont possibles, similaires à celles des
listes :
• Concaténation : L’opérateur + combine deux tuples.
• Répétition : L’opérateur * répète un tuple un certain nombre de fois.
• Vérification d’appartenance : L’opérateur in vérifie si un élément est présent dans le tuple.
• Longueur : La fonction len() retourne le nombre d’éléments.
Les fonctions len(), min(), max() et sum() s’appliquent aux tuples comme aux listes. Les mé-
thodes count() et index() sont les seules disponibles pour les tuples : count(element) retourne
le nombre d’occurrences et index(element) donne l’index de la première occurrence. En raison
de leur immutabilité, les tuples n’ont pas de méthodes équivalentes à append(), pop() ou sort().
La fonction list() convertit un tuple en liste, permettant des modifications. Inversement, tuple()
convertit une liste ou un autre itérable en tuple, ce qui est utile pour figer des données.
Illustrons ces opérations :
>>> tuple1 = (1, 2)
>>> tuple2 = (3, 4, 5)

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 70 Chapitre 4. Collections de données

>>> tuple1 + tuple2

(1, 2, 3, 4, 5)
>>> tuple1 = (1, 2)
>>> tuple2 = (3, 4, 5)
>>> tuple2 + tuple1
(3, 4, 5, 1, 2)
>>> tuple1 * 2
(1, 2, 1, 2)
>>> list(tuple2)
[3, 4, 5]
>>> liste = ["a", 0, 5.6]
>>> tuple(liste)
('a', 0, 5.6)

Note. Choisir entre une liste et un tuple dépend du contexte. Si les données doivent rester constantes,
optez pour un tuple. Si elles doivent être modifiées, une liste est plus appropriée.

4.3 Dictionnaires
Les dictionnaires sont une structure de données puissante en Python qui permet de stocker des
données sous forme de paires clé-valeur. Contrairement aux listes et aux tuples qui utilisent des
indices numériques pour accéder aux éléments, les dictionnaires associent chaque valeur à une clé
unique, ce qui facilite la recherche et la manipulation de données.

Un dictionnaire est une collection ordonnée (depuis Python 3.7) 1 , mutable et non indexée numéri-
quement, qui stocke des paires clé-valeur. Les clés doivent être immuables (comme des chaînes,
des nombres ou des tuples) et uniques, tandis que les valeurs peuvent être de n’importe quel type.
Les dictionnaires sont délimités par des accolades {} et les paires sont séparées par des virgules.

4.3.1 Création et syntaxe

Un dictionnaire peut être créé en listant des paires clé-valeur entre accolades {} où chaque clé est
séparée de sa valeur par deux-points :. Par exemple, un dictionnaire représentant les informations
d’une personne pourrait être :
>>> personne = {"nom": "Alice", "age": 25, "ville": "Bohicon"}
>>> print(personne)
{'nom': 'Alice', 'age': 25, 'ville': 'Bohicon'}

Quelques points essentiels concernant la syntaxe des dictionnaires :

• Un dictionnaire vide est créé avec mon_dict = {} ou mon_dict = dict().
• Les clés doivent être uniques ; si une clé est spécifiée plusieurs fois, seule la dernière valeur
associée est conservée :
>>> dict_exemple = {"a": 1, "a": 2} # La clé "a" est écrasée
>>> print(dict_exemple)
{'a': 2}

• Les clés peuvent être de types immuables comme str, int, float ou tuple, mais pas de
1. Jusqu’à la version 3.6 de Python, un dictionnaire était affiché sans ordre particulier. C’était une collection non
ordonnée, c’est-à-dire que l’ordre d’affichage des éléments n’était pas forcément le même que celui dans lequel il avait
été rempli. Pour plus de détails, consultez : [Link]
iscovering-dictionary-order-in-python.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 4.3 Dictionnaires 71

types mutables comme list.

4.3.2 Accès aux valeurs

Les valeurs d’un dictionnaire sont accessibles en utilisant la clé correspondante entre crochets [].
Par exemple :
>>> personne = {"nom": "Alice", "age": 25, "ville": "Bohicon"}
>>> print(personne["nom"])
Alice

Si la clé n’existe pas, une erreur KeyError est levée :

>>> print(personne["pays"]) # Clé inexistante
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
KeyError: 'pays'

Pour éviter cette erreur, la méthode get() est une alternative sûre, renvoyant None (ou une valeur
par défaut spécifiée) si la clé n’existe pas :
>>> print([Link]("pays")) # Renvoie None
None
>>> print([Link]("pays", "Bénin")) # Renvoie "Bénin" par défaut
Bénin

Note. Utiliser dict[clé] pour accéder à une valeur est rapide mais risque une KeyError. Préférez
[Link](clé) pour un accès sécurisé, surtout lorsque la présence de la clé n’est pas garantie.

4.3.3 Modification et ajout

Les dictionnaires sont mutables, ce qui signifie que vous pouvez modifier les valeurs associées
à des clés existantes ou ajouter de nouvelles paires clé-valeur. Pour modifier une valeur, il suffit
d’assigner une nouvelle valeur à une clé existante :
>>> personne = {"nom": "Alice", "age": 25}
>>> personne["age"] = 26
>>> print(personne)
{'nom': 'Alice', 'age': 26}

Pour ajouter une nouvelle paire, assignez une valeur à une clé inexistante :
>>> personne["ville"] = "Bohicon"
>>> print(personne)
{'nom': 'Alice', 'age': 26, 'ville': 'Bohicon'}

La méthode update() permet de modifier ou d’ajouter plusieurs paires à la fois :

>>> [Link]({"age": 27, "pays": "Bénin"})
>>> print(personne)
{'nom': 'Alice', 'age': 27, 'ville': 'Bohicon', 'pays': 'Bénin'}

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 72 Chapitre 4. Collections de données

4.3.4 Suppression d’éléments

Plusieurs méthodes permettent de supprimer des paires clé-valeur d’un dictionnaire :
• pop(clé) : Supprime la clé spécifiée et renvoie sa valeur.
• popitem() : Supprime et renvoie la dernière paire clé-valeur (depuis Python 3.7).
• clear() : Vide complètement le dictionnaire.
• del : Supprime une clé spécifique ou le dictionnaire entier.

Illustrons ces méthodes :

>>> mon_dict = {"a": 1, "b": 2, "c": 3}
>>> valeur = mon_dict.pop("a")
>>> print(valeur)
1
>>> derniere_paire = mon_dict.popitem()
>>> print(derniere_paire)
('c', 3)
>>> del mon_dict["b"]
>>> print(mon_dict)
{}

Note. L’utilisation de pop(clé) ou del avec une clé inexistante provoque une KeyError. Pour
pop(), vous pouvez spécifier une valeur par défaut : mon_dict.pop("clé", None).

4.3.5 Itération sur les dictionnaires

Les dictionnaires peuvent être parcourus à l’aide d’une boucle for, en accédant aux clés, aux valeurs
ou aux paires clé-valeur. Les méthodes keys(), values() et items() facilitent ces itérations :
• keys() : Renvoie une vue des clés.
• values() : Renvoie une vue des valeurs.
• items() : Renvoie une vue des paires clé-valeur.
>>> mon_dict = {"a": 1, "b": 2, "c": 3}
>>> mon_dict.keys()
dict_keys(['a', 'b', 'c'])
>>> mon_dict.values()
dict_values([1, 2, 3])
>>> mon_dict.items()
dict_items([('a', 1), ('b', 2), ('c', 3)])

Les mentions dict_keys, dict_values et dict_items indiquent que nous avons à faire à des
objets un peu particuliers. Ils ne sont pas indexables (on ne peut pas retrouver un élément par indice,
par exemple mon_dict.keys()[0] renverra une erreur). Si besoin, nous pouvons les transformer
en liste avec la fonction list() :
>>> mon_dict = {"a": 1, "b": 2, "c": 3}
>>> list(mon_dict.keys())
['a', 'b', 'c']

Toutefois, ces trois objets sont itérables : on peut itérer dessus dans une boucle.
Considérons un dictionnaire de scores :
1 scores = {"Alice": 90, "Bob": 85, "Charlie": 88}
2 # Parcourir les clés
3 for nom in [Link]():

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 4.4 Ensembles 73

4 print(f"Clé : {nom}")
5 # Parcourir les valeurs
6 for score in [Link]():
7 print(f"Score : {score}")
8 # Parcourir les paires
9 for nom, score in [Link]():
10 print(f"{nom} a obtenu {score}")

L’exécution de ce programme résultera en :

Clé : Alice
Clé : Bob
Clé : Charlie
Score : 90
Score : 85
Score : 88
Alice a obtenu 90
Bob a obtenu 85
Charlie a obtenu 88

Note. Parcourir directement un dictionnaire avec for clé in dict est équivalent à for clé in
[Link](). Cependant, utiliser keys() explicitement améliore la lisibilité du code.

4.3.6 Comparaison avec les listes et tuples

Pour mieux comprendre les dictionnaires, comparons-les aux listes et tuples :

TABLE 4.1 – Comparaison entre listes, tuples et dictionnaires

Caractéristique Liste Tuple Dictionnaire

Syntaxe Crochets : [ ] Parenthèses : ( ) Accolades : { }
Immutabilité Mutable Immuable Mutable
Accès Par indice Par indice Par clé (immuables)
Ordre Ordonné Ordonné Ordonné (depuis Python 3.7)
Cas d’usage Séquences modifiables Données fixes Données associatives

Note. Choisir entre une liste, un tuple ou un dictionnaire dépend du problème. Utilisez un
dictionnaire lorsque vous devez associer des clés à des valeurs pour un accès rapide.

4.4 Ensembles
Les ensembles, ou sets en Python, sont une structure de données conçue pour stocker une collection
d’éléments uniques, sans ordre défini. Inspirés des ensembles mathématiques, ils sont particu-
lièrement utiles pour effectuer des opérations ensemblistes comme l’union, l’intersection ou la
différence, ainsi que pour éliminer les doublons dans une collection.

Un ensemble est une collection non ordonnée, mutable et ne contenant que des éléments uniques et
immuables (comme des nombres, des chaînes ou des tuples). Les ensembles sont délimités par des
accolades {} et ne permettent pas de doublons.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 74 Chapitre 4. Collections de données

4.4.1 Création et syntaxe

Un ensemble peut être créé de deux manières : en utilisant des accolades {} ou la fonction set().
Par exemple, un ensemble de nombres peut s’écrire ainsi :
>>> mon_ensemble = {1, 2, 3, 2}
>>> print(mon_ensemble)
{1, 2, 3}

Quelques points clés concernant la création des ensembles :

• Les doublons sont automatiquement éliminés ; dans l’exemple ci-dessus, le second 2 est
ignoré.
• Un ensemble vide doit être créé avec set(), car {} crée un dictionnaire vide.
• Les éléments d’un ensemble doivent être immuables (par exemple, int, str, tuple), mais
pas des listes ou d’autres ensembles.
• Les ensembles peuvent être créés à partir d’autres collections, comme une liste :
>>> liste = [1, 1, 2, 3]
>>> ensemble_de_liste = set(liste)
>>> print(ensemble_de_liste)
{1, 2, 3}

• Les ensembles peuvent être transformés en liste ou en tuple :

>>> ensemble = {1, 1, 2, 3}
>>> liste = list(ensemble)
>>> print(ensemble_de_liste)
[1, 2, 3]

• Les sets ne sont pas indexables, il est donc impossible de récupérer un élément par sa position.
Il est également impossible de modifier un de ses éléments par l’indexation.
>>> mon_ensemble = {1, 2, 3, 2}
>>> mon_ensemble[0]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'set' object is not subscriptable
>>> mon_ensemble[0] = 0
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'set' object does not support item assignment

Note. Confondre {} pour un ensemble vide avec un dictionnaire vide est une erreur courante.
Utilisez toujours set() pour créer un ensemble vide.

4.4.2 Ajout et suppression d’éléments

Les ensembles sont mutables, il est donc possible d’ajouter ou de supprimer des éléments après
leur création. Les méthodes principales sont :
• add(élément) : Ajoute un élément à l’ensemble (ignoré si l’élément est déjà présent).
• remove(élément) : Supprime un élément ; provoque une KeyError si l’élément n’existe pas.
• discard(élément) : Supprime un élément sans erreur si l’élément n’existe pas.
• pop() : Supprime et renvoie un élément arbitraire (les ensembles n’étant pas ordonnés).
• clear() : Vide l’ensemble.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 4.4 Ensembles 75

>>> fruits = {"pomme", "banane"}

>>> [Link]("orange")
>>> [Link]("banane")
>>> fruits
{'orange', 'pomme'}
>>> [Link]("ananas") # Suppression sans erreur
>>> element = [Link]()
>>> fruits
{'pomme'}
>>> element
'orange'
>>>

Note. La méthode pop() renvoie un élément arbitraire, car les ensembles ne garantissent pas un
ordre spécifique. Utilisez-la avec prudence.

4.4.3 Opérations ensemblistes

Les ensembles excellent dans les opérations ensemblistes, qui permettent de manipuler des collec-
tions d’éléments de manière intuitive. Les principales opérations sont :
• Union (| ou union()) : Combine tous les éléments de deux ensembles, sans doublons.
• Intersection (& ou intersection()) : Renvoie les éléments communs aux deux ensembles.
• Différence (− ou difference()) : Renvoie les éléments présents dans un ensemble mais pas
dans l’autre.
• Différence symétrique (^ ou symmetric_difference()) : Renvoie les éléments présents
dans l’un ou l’autre ensemble, mais pas dans les deux.
Considérons deux ensembles représentant des étudiants inscrits à des cours :
>>> maths = {"Alice", "Bob", "Charlie"}
>>> informatique = {"Bob", "David", "Eve"}
>>> union = maths | informatique
>>> union
{'Alice', 'Charlie', 'David', 'Eve', 'Bob'}
>>> intersection = [Link](informatique)
>>> intersection
{'Bob'}
>>> difference1 = maths − informatique
>>> difference2
{'Alice', 'Charlie'}
>>> sym_diff = maths ^ informatique
>>> sym_diff
{'Alice', 'Charlie', 'Eve', 'David'}

Note. [Link](b) retourne un nouvel ensemble avec des éléments présents dans a mais pas
dans b. Ainsi, [Link](b) != [Link](a). Cependant, a.symmetric_difference(
b) == b.symmetric_difference(a).

4.4.4 Tests d’appartenance et relations

Les ensembles permettent de vérifier rapidement si un élément appartient à l’ensemble avec
l’opérateur in, ainsi que de tester des relations entre ensembles :
• in : Vérifie si un élément est présent.
• issubset() (<=) : Vérifie si un ensemble est un sous-ensemble d’un autre.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 76 Chapitre 4. Collections de données

• issuperset() (>=) : Vérifie si un ensemble contient un autre.

• isdisjoint() : Vérifie si deux ensembles n’ont aucun élément commun.
Testons ces opérations :
>>> ensemble1 = {1, 2, 3}
>>> ensemble2 = {1, 2}
>>> 1 in ensemble1
True
>>> [Link](ensemble1)
True
>>> [Link]({4, 5})
True

Note.
Il existe d’autres méthodes que nous n’abordons pas ici, mais qui peuvent être consultées sur la
documentation officielle de Python 2 ou en tapant help(set) dans le shell.

4.4.5 Frozenset : ensembles immuables

Python propose également les frozensets, une variante immuable des ensembles. Un frozenset ne
peut pas être modifié après sa création. Ainsi, un set peut contenir des frozensets mais pas l’inverse.
À quoi servent-ils ? Comme la différence entre tuple et liste, l’immutabilité des frozensets donne
l’assurance de ne pas pouvoir les modifier par erreur. Pour créer un frozenset on utilise la fonction
interne frozenset() qui prend en argument un objet itérable et le convertit (opération de casting) :
>>> frozen1 = frozenset([3, 3, 5, 1, 3, 4, 1, 1, 4, 4])
>>> frozen2 = frozenset([3, 0, 5, 3, 3, 1, 1, 1, 2, 2])
>>> frozen1
frozenset({1, 3, 4, 5})
>>> frozen2
frozenset({0, 1, 2, 3, 5})
>>> [Link](5)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'frozenset' object has no attribute 'add'
>>> [Link](frozen2)
frozenset({0, 1, 2, 3, 4, 5})
>>> [Link](frozen2)
frozenset({1, 3, 5})

Note. Les frozensets supportent les mêmes opérations ensemblistes que les sets, mais aucune
méthode de modification comme add(), remove() ou discard(), puisqu’ils sont non modifiables.
Les frozensets peuvent également être convertis en liste ou en tuple, à l’instar des sets.

4.4.6 Cas d’usage des ensembles

Les ensembles sont particulièrement adaptés pour :
• Élimination des doublons : Convertir une liste en ensemble supprime automatiquement les
éléments redondants.
• Opérations ensemblistes : Comparer des collections, comme trouver des éléments communs
ou uniques.
• Modélisation mathématique : Représenter des ensembles dans des problèmes de théorie

2. [Link]

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 4.5 Utilitaires et compréhensions 77

des ensembles ou de probabilité.

>>> reponses = ["oui", "non", "oui", "peut−être", "non"]

>>> reponses_uniques = set(reponses)
>>> reponses_uniques
{'non', 'oui', 'peut−être'}
>>> texte = "ananas"
>>> lettres_uniques = set(texte)
>>> print(lettres_uniques)
{'n', 's', 'a'}

Cet exemple montre comment un ensemble simplifie l’élimination des doublons.

Note. Choisissez un ensemble lorsque vous avez besoin d’éliminer les doublons ou d’effectuer des
opérations ensemblistes. Pour des données ordonnées ou associatives, préférez les listes, tuples ou
dictionnaires.

4.5 Utilitaires et compréhensions

Les collections de données, telles que les listes, tuples, dictionnaires et ensembles, sont souvent
manipulées à l’aide d’outils et de techniques qui simplifient les opérations complexes. Les utili-
taires comme zip(), enumerate() et map(), ainsi que les compréhensions, une syntaxe concise,
permettent de créer ou de transformer des collections.

4.5.1 Fonctions utilitaires

Plusieurs fonctions intégrées facilitent la manipulation des collections en Python. Vous avez déjà
rencontré enumerate() dans les sections 3.3 et 4.1.4 pour parcourir les listes avec leurs indices.
Nous allons donc introduire zip() et map(), deux autres fonctions essentielles.

[Link] La fonction zip()

La fonction zip() combine plusieurs itérables (comme des listes, tuples ou ensembles) en un
itérateur de tuples, où chaque tuple contient les éléments correspondants des itérables d’entrée.
Cette fonction permet ainsi de parcourir plusieurs collections en parallèle.

La fonction zip(iterable1, iterable2, ...) prend plusieurs itérables en entrée et renvoie un

itérateur de tuples, où le i-ème tuple contient le i-ème élément de chaque itérable. Si les itérables
ont des longueurs différentes, zip() s’arrête à la longueur du plus court.
Supposons que vous souhaitiez associer des noms à des scores :
>>> noms = ["Alice", "Bob", "Charlie"]
>>> scores = [90, 85, 88]
>>> paires = zip(noms, scores)
>>> print(list(paires))
[('Alice', 90), ('Bob', 85), ('Charlie', 88)]

Dans cet exemple, zip(noms, scores) crée un itérateur de tuples ('Alice', 90), ('Bob', 85),
etc. La conversion en liste avec list() permet d’afficher le résultat.
On peut directement parcourir les paires créées sans les convertir en une liste :
>>> for nom, score in zip(noms, scores):
... print(f"{nom} a {score} points.")

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 78 Chapitre 4. Collections de données

...
Alice a 90 points.
Bob a 85 points.
Charlie a 88 points.

Ici, zip() permet de déballer chaque tuple directement dans la boucle for.
Note. Si les itérables passés à zip() ont des longueurs différentes, les éléments excédentaires du
plus long itérable sont ignorés. Par exemple :
>>> noms = ["Alice", "Bob", "Charlie"]
>>> scores = [90, 85, 88]
>>> ages = [25, 30]
>>> print(list(zip(noms, ages, scores)))
[('Alice', 25, 90), ('Bob', 30, 85)]

[Link] La fonction map()

La fonction map() applique une fonction à chaque élément d’un itérable en renvoyant un itérateur
des résultats. Elle est utile pour transformer des collections sans écrire de boucle explicite.

La fonction map(fonction, iterable) applique fonction à chaque élément de iterable et

renvoie un itérateur des résultats. La fonction peut être une fonction intégrée, une fonction définie
par l’utilisateur ou une fonction anonyme.
Pour convertir une liste de nombres en valeur absolue :
>>> nombres = [5, −2.6, −12, 0]
>>> nombres_abs = map(abs, nombres)
>>> print(list(nombres_abs))
[5, 2.6, 12, 0]

Ici, la fonction intégrée abs (qui calcule la valeur absolue d’un nombre) est appliquée à chaque
élément de nombres et list() convertit l’itérateur en liste.
Note. Les fonctions zip() et map() (ainsi qu’enumerate()) renvoient des itérateurs qui sont
évalués paresseusement (lazily). Cela veut dire qu’ils ne calculent pas tout d’un coup ; ils produisent
les résultats au fur et à mesure quand on les demande. Pour faire court, c’est lorsqu’on parcourt
l’itérateur que Python calcule. Cela permet d’économiser la mémoire et le temps pour de grandes
collections. Pour calculer tous les éléments, convertissez les itérateurs en liste. Mais rappelez-vous
que cela consomme de la mémoire.

4.5.2 Compréhensions de listes

Les compréhensions de listes 3 offrent une syntaxe concise pour créer des listes à partir d’itérables,
en remplaçant souvent des boucles for explicites. Elles sont à la fois puissantes et lisibles, mais
doivent être utilisées avec modération pour éviter de compliquer le code.

Une compréhension de liste crée une nouvelle liste en appliquant une expression à chaque élément
d’un itérable, éventuellement avec une condition.
La syntaxe la plus simple est :

3. [Link]

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

4.5 Utilitaires et compréhensions 79

1 [expression for élément in itérable]

On peut également ajouter une condition if :

1 [expression for élément in itérable if condition]

Pour chaque élément de l’itérable, l’expression est appliquée si la condition (facultative) est
vérifiée. Tous les résultats sont alors regroupés immédiatement dans une nouvelle liste.
Pour créer une liste des carrés des nombres de 1 à 5 :
>>> carres = [x**2 for x in range(1, 6)]
>>> print(carres)
[1, 4, 9, 16, 25]

Cette compréhension est équivalente à :

1 carres = []
2 for x in range(1, 6):
3 [Link](x**2)

Pour filtrer les nombres pairs d’une liste :

>>> nombres = [1, 2, 3, 4, 5, 6]
>>> pairs = [x for x in nombres if x % 2 == 0]
>>> print(pairs)
[2, 4, 6]

La condition if x % 2 == 0 limite la liste aux nombres divisibles par 2.

Il est possible d’utiliser une structure if−else dans une compréhension de liste. Cependant, il faut
respecter la bonne syntaxe :

• Lorsque if est utilisé seul (sans else), il se place après la boucle for.
• Lorsque if−else sont utilisés ensemble, ils doivent apparaître avant la boucle for.

Supposons que l’on veuille créer une liste des caractères de 'ananas' en remplaçant les consonnes
par '*'.
>>> voyelles = [x for x in 'ananas' if x in 'aeiou' else '*']
File "<stdin>", line 1
voyelles = [x for x in 'ananas' if x in 'aeiou' else '*']
^^^^
SyntaxError: invalid syntax

Nous avons une SyntaxError. Python ne comprend pas où placer else car if appliqué après le
for est censé être une simple condition de filtrage, sans clause alternative. La bonne syntaxe est
alors :
1 >>> voyelles = [x if x in 'aeiou' else '*' for x in 'ananas']
2 >>> print(voyelles)
3 ['a', '*', 'a', '*', 'a', '*']

Pour chaque caractère x dans 'ananas' ; si x est une voyelle, on garde x ; sinon, on met '*'.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 80 Chapitre 4. Collections de données

Note. Les compréhensions de listes sont puissantes, mais une utilisation excessive peut rendre le
code difficile à lire. Préférez une boucle for explicite si la compréhension devient trop complexe
ou imbriquée.

4.5.3 Compréhensions de dictionnaires et d’ensembles

Les compréhensions ne se limitent pas aux listes ; elles s’appliquent également aux dictionnaires et
aux ensembles avec une syntaxe similaire.

[Link] Compréhensions de dictionnaires

Une compréhension de dictionnaire crée un dictionnaire en spécifiant des paires clé-valeur à partir
d’un itérable.
Pour créer un dictionnaire associant des nombres à leurs carrés :
>>> carres_dict = {x: x**2 for x in range(1, 5)}
>>> print(carres_dict)
{1: 1, 2: 4, 3: 9, 4: 16}

Comme avec une compréhension de liste, nous pouvons utiliser une instruction conditionnelle (if
/if−else) à l’intérieur de la compréhension de dictionnaire pour produire uniquement les éléments
du dictionnaire répondant à certains critères.
>>> notes = {"Alice": 90, "Bob": 85, "Charlie": 88}
>>> fortes_notes = {nom: score for nom, score in [Link]() if score >= 88}
>>> print(fortes_notes)
{'Alice': 90, 'Charlie': 88}

[Link] Compréhensions d’ensembles

Une compréhension d’ensemble crée un ensemble en appliquant une expression à un itérable tout
en éliminant automatiquement les doublons.
Pour créer un ensemble des longueurs uniques de mots :
>>> mots = ["bonjour", "python", "code", "bon", "oui"]
>>> longueurs = {len(mot) for mot in mots}
>>> print(longueurs)
{3, 4, 6, 7}

Gardez à l’esprit que les ensembles ne sont pas ordonnés. Cela signifie que l’ordre des résultats
dans l’ensemble peut différer de celui présenté dans les exemples ci-dessus.
Notes.
1. Il est également possible d’utiliser une instruction conditionnelle (if/if−else) à l’intérieur
de la compréhension d’ensemble.
2. Il n’existe pas de compréhension pour les tuples, car les tuples sont immuables.
3. Le choix entre boucles et compréhensions dépend de la lisibilité et de la complexité de la
tâche. Pour les débutants, les boucles explicites sont souvent plus simples à utiliser, tandis
que les compréhensions deviennent naturelles avec la pratique.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 5. Fonctions

Les fonctions constituent un pilier essentiel de la programmation en Python. Elles permettent

de structurer le code, de le rendre réutilisable et de résoudre des problèmes complexes en les
décomposant en tâches plus petites. Une fonction encapsule un ensemble d’instructions qui peut
être exécuté à la demande, souvent avec des données d’entrée spécifiques, pour produire un résultat.
Ce chapitre décrit la déclaration et l’utilisation des fonctions en Python. Ce chapitre aborde la
création, l’utilisation et les subtilités des fonctions. Vous découvrirez comment elles améliorent la
lisibilité et la modularité de vos programmes, préparant le terrain pour des concepts plus avancés
comme les générateurs et les décorateurs.

5.1 Définition et appel

Une fonction est un bloc de code conçu pour accomplir une tâche spécifique et que vous pouvez
invoquer à plusieurs reprises dans votre programme. Les fonctions en Python permettent ainsi
d’organiser le code de manière structurée, réutilisable et modulaire pour effectuer un ensemble
d’actions. Elles simplifient le processus de codage, évitent les répétitions de logique et rendent le
code plus facile à comprendre.
Python dispose de nombreuses fonctions intégrées comme print(), input(), len() que nous
avons étudiées dans les chapitres précédents. En plus de ces fonctions intégrées, vous pouvez aussi
créer vos propres fonctions pour accomplir des tâches plus spécifiques.
En Python, les fonctions sont définies avec le mot-clé def, suivies d’un nom, de paramètres
(optionnels) mis entre parenthèses et d’un corps d’instructions. La syntaxe générale pour définir
une fonction est :
1 def nom_de_la_fonction(paramètres):
2 # Instructions
3 return valeur # Optionnel

Le corps de la fonction est indenté sous la ligne de définition (l’indentation est obligatoire). Le
mot-clé return est utilisé pour renvoyer un résultat, bien qu’il soit facultatif si la fonction ne
produit pas de valeur. Une fois définie, une fonction peut être appelée en utilisant son nom suivi
d’arguments et exécute une tâche spécifique. L’appel d’une fonction consiste à invoquer son nom
avec des arguments : nom_de_la_fonction(arguments).
 82 Chapitre 5. Fonctions

Définissons une fonction qui calcule le carré d’un nombre :

1 def carre(nombre):
2 resultat = nombre ** 2
3 return resultat
4
5 resultat = carre(5)
6 print(resultat)

La fonction nommée carre prend un paramètre nombre, calcule son carré et renvoie le résultat
avec return. Les arguments fournis lors de l’appel remplacent les paramètres dans le corps de la
fonction. C’est ce qui a été fait à la ligne 5 : l’appel carre(5) passe l’argument 5 au paramètre
nombre. La fonction calcule 5 ** 2 et renvoie 25 qui est stocké dans resultat.

Notez qu’une fonction peut être appelée plusieurs fois avec différents arguments (ce qui constitue
l’intérêt même de leur utilisation) :
1 print(carre(3))
2 print(carre(10))

Notez également qu’une fonction ne prend pas forcément un argument et ne renvoie pas forcément
une valeur, par exemple :
1 def saluer():
2 print("Bonjour !")
3
4 saluer()

Bonjour !

Dans ce cas, la fonction hello() se contente d’afficher la chaîne de caractères "Bonjour !" à
l’écran. Elle ne prend aucun argument et ne renvoie rien. Par conséquent, cela n’a pas de sens de
vouloir récupérer dans une variable le résultat renvoyé par une telle fonction. Si on essaie tout de
même, Python affecte la valeur None qui signifie rien en anglais :
1 def saluer():
2 print("Bonjour !")
3
4 resultat = saluer()
5 print(resultat)

Bonjour !
None

Note. Le nom d’une fonction doit être descriptif et suivre les conventions de nommage de Python
(PEP 8). Évitez les noms réservés comme print ou len, car cela peut écraser les fonctions intégrées.

5.2 Paramètres
Les paramètres d’une fonction permettent de transmettre des données spécifiques lors de son appel.
Python offre plusieurs façons de définir et d’utiliser les paramètres, y compris les paramètres
positionnels, les paramètres par mot-clé, les valeurs par défaut et les paramètres variables.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 5.2 Paramètres 83

5.2.1 Paramètres positionnels, mot-clé, valeurs par défaut

Les paramètres peuvent être définis de manière positionnelle (l’ordre des arguments compte) ou
par mot-clé (les arguments sont associés explicitement aux noms des paramètres). Les paramètres
peuvent également avoir des valeurs par défaut.

• Paramètres positionnels : Les arguments sont passés dans l’ordre exact des paramètres
définis dans la fonction, chaque argument correspondant au paramètre à la même position.
• Paramètres par mot-clé : Les arguments sont passés en spécifiant explicitement le nom du
paramètre, ce qui permet de les passer dans n’importe quel ordre.
• Valeurs par défaut : Un paramètre peut avoir une valeur prédéfinie utilisée si aucun argument
correspondant n’est fourni lors de l’appel.

[Link] Paramètres positionnels

Les paramètres positionnels sont le moyen le plus courant de passer des arguments à une fonction.
Lors de l’appel, les arguments doivent être fournis dans le même ordre que les paramètres définis
dans la déclaration de la fonction.
Considérons une fonction qui affiche les informations d’un étudiant :
>>> def afficher_etudiant(nom, age, cours):
... print(f"{nom} a {age} ans et suit le cours {cours}.")
...

Pour appeler cette fonction, les arguments doivent être passés dans l’ordre nom, age, cours :
>>> afficher_etudiant("Alice", 20, "Programmation Python")
Alice a 20 ans et suit le cours Programmation Python.

Dans cet exemple, "Alice" est assigné à nom, 20 à age et "Programmation Python" à cours en
suivant l’ordre des paramètres.
Si les arguments sont passés dans un ordre incorrect, le résultat peut être incohérent ou provoquer
une erreur logique :
>>> afficher_etudiant(20, "Alice", "Programmation Python")
20 a Alice ans et suit le cours Programmation Python.

Note. L’ordre des arguments positionnels est très important. Une erreur dans l’ordre peut entraîner
des résultats inattendus ou des erreurs si les types des arguments ne correspondent pas aux attentes
de la fonction. Par exemple, passer une chaîne là où un nombre est attendu peut provoquer une
TypeError dans certaines opérations.

[Link] Paramètres par mot-clé

Les paramètres par mot-clé permettent de passer des arguments en spécifiant explicitement le nom
du paramètre, ce qui élimine la nécessité de respecter l’ordre des paramètres. Les arguments par
mot-clé améliorent la lisibilité, surtout pour les fonctions avec plusieurs paramètres.
Reprenons la fonction afficher_etudiant :
>>> afficher_etudiant(age=20, nom="Alice", cours="Programmation Python")
Alice a 20 ans et suit le cours Programmation Python.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 84 Chapitre 5. Fonctions

Ici, les arguments sont passés en utilisant les noms des paramètres et l’ordre n’a pas d’importance. Le
résultat est identique à l’appel positionnel afficher_etudiant("Alice", 20, "Informatique
").

Les paramètres par mot-clé peuvent être combinés avec des paramètres positionnels, mais les
arguments positionnels doivent toujours être fournis en premier :
>>> afficher_etudiant("Alice", age=20, cours="Programmation Python")
Alice a 20 ans et suit le cours Programmation Python.

Notes.

1. Si un argument positionnel est fourni après un argument par mot-clé dans le même appel,
Python lève une SyntaxError. Par exemple :
>>> afficher_etudiant(nom="Alice", 20, "Programmation Python")
File "<stdin>", line 1
afficher_etudiant(nom="Alice", 20, "Programmation Python")
^
SyntaxError: positional argument follows keyword argument

2. L’utilisation des paramètres par mot-clé est utile pour les fonctions avec de nombreux
paramètres ou lorsque certains paramètres ont des valeurs par défaut, car elle clarifie l’inten-
tion du code. Par exemple, calculer_prix(prix=100, taxe=0.10) est plus explicite que
calculer_prix(100, 0.10).

[Link] Valeurs par défaut

Les paramètres avec des valeurs par défaut permettent de rendre certains arguments optionnels.
Si un argument correspondant à un paramètre avec une valeur par défaut n’est pas fourni lors de
l’appel, la valeur par défaut est utilisée.
Définissons une fonction pour calculer le coût d’un billet avec une réduction par défaut :
>>> def calculer_billet(prix_base, reduction=0.1):
... prix_final = prix_base * (1 − reduction)
... return prix_final
...
>>> print(calculer_billet(100))
90.0
>>> print(calculer_billet(100, 0.2))
80.0

Dans le premier appel, reduction prend la valeur par défaut 0.1. Dans le second, 0.2 est utilisé.
Les paramètres avec des valeurs par défaut doivent être placés après les paramètres sans valeur par
défaut dans la définition de la fonction, pour éviter des ambiguïtés lors de l’appel.
Une fonction avec plusieurs paramètres par défaut :
>>> def organiser_evenement(nom, date, lieu="Abomey", heure="18:00"):
... print(f"{nom} aura lieu le {date} à {lieu} à {heure}.")
...
>>> organiser_evenement("Conférence", "01/06/2025")
Conférence aura lieu le 01/06/2025 à Abomey à 18:00.
>>> organiser_evenement("Atelier", "01/07/2025", lieu="Cotonou", heure
="09:30")
Atelier aura lieu le 01/07/2025 à Cotonou à 09:30.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 5.2 Paramètres 85

Note. Les valeurs par défaut sont évaluées une seule fois, lors de la définition de la fonction et non
à chaque appel. Cela peut entraîner des comportements inattendus avec des objets mutables comme
les listes. Par exemple :
>>> def ajouter_element(element, liste=[]):
... [Link](element)
... return liste
...
>>> print(ajouter_element(1))
[1]
>>> print(ajouter_element(2))
[1, 2]

La liste par défaut [] est partagée entre les appels, car elle est créée une seule fois. Pour éviter ce
problème, utilisez None comme valeur par défaut et initialisez la liste dans la fonction :
>>> def ajouter_element(element, liste=None):
... if liste is None:
... liste = []
... [Link](element)
... return liste
...
>>> print(ajouter_element(1))
[1]
>>> print(ajouter_element(2))
[2]

5.2.2 Paramètres variables : *args, **kwargs

Certaines fonctions nécessitent de gérer un nombre variable d’arguments, c’est-à-dire un nombre
d’entrées qui peut changer d’un appel à l’autre. Python offre deux mécanismes pour répondre à
ce besoin : *args pour collecter un nombre arbitraire d’arguments positionnels et **kwargs pour
collecter un nombre arbitraire d’arguments par mot-clé. Ces outils permettent de concevoir des
fonctions capables de s’adapter à des situations variées, comme le traitement d’une liste d’éléments
de longueur inconnue.

• *args : Un paramètre spécial qui collecte tous les arguments positionnels supplémentaires
passés à une fonction dans un tuple. Le nom args est une convention, mais l’astérisque * est
obligatoire.
• **kwargs : Un paramètre spécial qui collecte tous les arguments par mot-clé supplémentaires
passés à une fonction dans un dictionnaire. Le nom kwargs (pour keyword arguments) est
une convention, mais les deux astérisques ** sont obligatoires.

[Link] Utilisation de *args

Le paramètre *args permet à une fonction d’accepter un nombre arbitraire d’arguments positionnels
qui sont regroupés dans un tuple à l’intérieur de la fonction. *args est utile pour des fonctions qui
doivent traiter des collections de données de taille variable, comme des sommes, des concaténations
ou des affichages multiples.
Définissons une fonction qui calcule le produit de plusieurs nombres :
>>> def produit(*nombres):
... resultat = 1
... for nombre in nombres:

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 86 Chapitre 5. Fonctions

... resultat *= nombre

... return resultat
...
>>> print(produit(2, 3, 4)) # Trois arguments
24
>>> print(produit(5, 6)) # Deux arguments
30
>>> print(produit()) # Aucun argument
1

Dans cet exemple, *nombres collecte tous les arguments positionnels dans un tuple. Par exemple,
l’appel produit(2, 3, 4) fait que nombres vaut (2, 3, 4). La boucle for multiplie chaque
élément pour calculer le produit. Si aucun argument n’est passé, le tuple est vide et la fonction
renvoie 1 (la valeur initiale de resultat).
Notes.
1. Le tuple créé par *args est immuable à l’intérieur de la fonction. Si vous devez modifier les
arguments, convertissez le tuple en liste, mais soyez prudents, car cela peut compliquer la
logique de la fonction.
2. Bien que args soit une convention, vous pouvez utiliser un autre nom, comme dans l’exemple
précédent. Cependant, *args est largement adopté dans la communauté Python pour sa clarté
et sa reconnaissance immédiate.

[Link] Utilisation de **kwargs

Le paramètre **kwargs permet à une fonction d’accepter un nombre arbitraire d’arguments par
mot-clé qui sont regroupés dans un dictionnaire où les clés sont les noms des arguments et les
valeurs sont leurs valeurs associées. **kwargs est idéal pour des fonctions qui doivent gérer des
options ou des attributs variés, comme la configuration d’un objet ou l’affichage d’informations
structurées.
Définissons une fonction qui affiche les attributs d’un produit :
>>> def afficher_produit(**attributs):
... for cle, valeur in [Link]():
... print(f"{cle} : {valeur}")
...
>>> afficher_produit(nom="Livre", prix=7000, categorie="Littérature")
nom : Livre
prix : 7000
categorie : Littérature
>>> afficher_produit(marque="Samsung", modele="Galaxy S25", couleur="Noir")
marque : Samsung
modele : Galaxy S25
couleur : Noir

Dans cet exemple, **attributs collecte les arguments par mot-clé dans un dictionnaire. Par
exemple, l’appel afficher_produit(nom="Livre", prix=7000, categorie="Littérature")
crée le dictionnaire {"nom": "Livre", "prix": 7000, "categorie": "Littérature"} que la
fonction parcourt pour afficher chaque paire clé-valeur.
Notes.
1. Les clés des arguments passés à **kwargs doivent être des chaînes valides pour des noms de
variables Python (pas d’espaces, pas de caractères spéciaux). Par exemple, **kwargs ne peut
pas accepter nom complet="John Doe" directement.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 5.3 Valeurs de retour 87

2. Comme pour *args, le nom kwargs est une convention. Vous pouvez utiliser un autre nom,
mais **kwargs est recommandé pour maintenir la cohérence avec les pratiques standards.

[Link] Combinaison de *args et **kwargs

Les paramètres *args et **kwargs peuvent être utilisés ensemble dans une même fonction, souvent
en combinaison avec des paramètres positionnels ou par mot-clé standards. Lors de la définition
d’une fonction, l’ordre des paramètres doit être respecté : paramètres positionnels obligatoires,
*args, paramètres avec valeurs par défaut puis **kwargs. Cette structure permet de couvrir une
grande variété de scénarios d’appel.
Une fonction qui combine tous les types de paramètres :
>>> def commande_client(client, produit, *extras, remise=0.0, **details):
... print(f"Client : {client}, Produit : {produit}")
... print(f"Extras : {extras}")
... print(f"Remise : {remise:.2%}")
... print("Détails supplémentaires :")
... for cle, valeur in [Link]():
... print(f" {cle} : {valeur}")
...
>>> commande_client("Alice", "Livre", "Cahier", "Stylo", remise=0.1, categorie
="Papeterie", stock=50)
Client : Alice, Produit : Livre
Extras : ('Cahier', 'Stylo')
Remise : 10.00%
Détails supplémentaires :
categorie : Papeterie
stock : 50

Dans cet exemple :

• client et produit sont des paramètres positionnels obligatoires.
• *extras collecte les arguments positionnels supplémentaires ("Cahier", "Stylo") dans un
tuple.
• remise est un paramètre avec une valeur par défaut.
• **details collecte les arguments par mot-clé (categorie="Papeterie", stock=50) dans
un dictionnaire.
Note. Lors de l’utilisation de *args et **kwargs ensemble, assurez-vous que les arguments passés
sont cohérents avec la logique de la fonction. Par exemple, passer des arguments par mot-clé qui ne
sont pas utilisés peut compliquer le débogage. Testez soigneusement les différents cas d’appel.

5.3 Valeurs de retour

Les fonctions en Python ne se contentent pas d’exécuter des instructions ; elles peuvent également
produire des résultats, appelés valeurs de retour, qui sont transmis à l’appelant pour être utilisés
dans le reste du programme. La possibilité de renvoyer des valeurs permet aux fonctions de jouer
un rôle central dans le traitement des données en transformant des entrées en sorties exploitables.

Une valeur de retour est le résultat produit par une fonction, transmis à l’appelant via le mot-clé
return. Une fonction peut renvoyer une seule valeur, plusieurs valeurs (sous forme de tuple) ou
aucune valeur (implicitement None). Rappelons la syntaxe générale déjà vue dans la section 5.1 :
1 def nom_fonction(paramètres):
2 # Instructions

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 88 Chapitre 5. Fonctions

3 return valeur # Ou plusieurs valeurs ou rien

5.3.1 Utilisation du mot-clé return

Le mot-clé return est utilisé pour spécifier la valeur (ou les valeurs) que la fonction doit renvoyer.
Lorsqu’une instruction return est exécutée, la fonction s’arrête immédiatement et le contrôle est
rendu à l’appelant avec la valeur spécifiée. Si aucune instruction return n’est présente ou si return
est utilisé sans argument, la fonction renvoie None par défaut.
Définissons une fonction qui calcule la moyenne de deux nombres :
>>> def moyenne(a, b):
... resultat = (a + b) / 2
... return resultat
...
>>> moy = moyenne(10, 20)
>>> print(moy)
15.0

Dans cet exemple, la fonction moyenne calcule (10 + 20) / 2 et renvoie 15.0 qui est stocké dans
la variable moy.
Une fonction peut contenir plusieurs instructions return pour gérer différents cas :
>>> def maximum(a, b):
... if a > b:
... return a
... return b
...
>>> print(maximum(5, 3))
5
>>> print(maximum(2, 7))
7

Ici, la fonction maximum renvoie a si a > b, sinon elle renvoie b. Dès qu’une instruction return est
exécutée, la fonction s’arrête.
Note. Tout code placé après une instruction return dans une fonction, appelé code mort, ne sera
jamais exécuté, car return termine immédiatement l’exécution de la fonction. Dans l’exemple
suivant, la ligne 3 ne sera jamais exécutée.
1 def erreur():
2 return 42
3 print("Ce message ne sera jamais affiché")

5.3.2 Retour d’une seule valeur

Le cas le plus simple est celui où une fonction renvoie une seule valeur, qui peut être de n’importe
quel type : un nombre, une chaîne, une liste, un dictionnaire, etc. Cette valeur peut être utilisée
directement dans une expression, assignée à une variable ou passée à une autre fonction.
Une fonction qui convertit une température de Celsius en Fahrenheit :
>>> def celsius_vers_fahrenheit(celsius):
... return celsius * 9/5 + 32

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 5.3 Valeurs de retour 89

...
>>> temp = celsius_vers_fahrenheit(25)
>>> print(f"25°C équivaut à {temp}°F")
25°C équivaut à 77.0°F

La fonction renvoie un nombre à virgule flottante qui est stocké dans temp et utilisé dans l’affichage.

5.3.3 Retour de plusieurs valeurs

Python permet à une fonction de renvoyer plusieurs valeurs en les séparant par des virgules dans
l’instruction return. Ces valeurs sont automatiquement regroupées dans un tuple qui peut être
déballé par l’appelant pour assigner chaque valeur à une variable distincte.
Une fonction qui renvoie les dimensions d’un rectangle après un ajustement :
>>> def ajuster_rectangle(longueur, largeur):
... nouvelle_longueur = longueur + 2
... nouvelle_largeur = largeur + 2
... return nouvelle_longueur, nouvelle_largeur
...
>>> long, larg = ajuster_rectangle(10, 5)
>>> print(f"Nouvelle longueur : {long}, Nouvelle largeur : {larg}")
Nouvelle longueur : 12, Nouvelle largeur : 7

Dans cet exemple, return nouvelle_longueur, nouvelle_largeur renvoie un tuple (12, 7)

qui est déballé dans les variables long et larg.
Le tuple retourné peut également être utilisé directement sans déballage :
>>> dimensions = ajuster_rectangle(10, 5)
>>> print(dimensions)
(12, 7)

Note. Le nombre de variables utilisées pour déballer un tuple retourné doit correspondre exactement
au nombre de valeurs dans le tuple, sinon une ValueError est levée. Par exemple :
>>> a, b, c = ajuster_rectangle(10, 5) # Trop de variables
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: not enough values to unpack (expected 3, got 2)

5.3.4 Fonctions sans retour explicite

Certaines fonctions sont conçues pour effectuer une action (comme afficher un message ou modifier
une variable globale) sans renvoyer de valeur. Dans ce cas, elles renvoient None par défaut, soit
parce qu’aucune instruction return n’est présente, soit parce que return est utilisé sans argument.
Ces fonctions ont été utilisées précédemment.
Note. Les fonctions qui renvoient None sont souvent appelées pour leurs effets secondaires (comme
l’affichage ou la modification d’un état) plutôt que pour leur valeur de retour. Cela contraste avec
les fonctions qui produisent des résultats à utiliser dans d’autres parties du programme.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 90 Chapitre 5. Fonctions

5.4 Portée des variables

La portée d’une variable détermine les parties d’un programme où cette variable est accessible et
peut être utilisée. Comprendre la portée est essentiel pour écrire des fonctions correctes et éviter
des erreurs liées à l’accès ou à la modification inappropriée des variables. En Python, la portée des
variables est régie par des règles précises, qui distinguent les variables locales, définies à l’intérieur
d’une fonction, des variables globales, définies à l’extérieur.

La portée d’une variable désigne la région du code où cette variable est accessible. En Python, les
portées principales sont :
• Portée locale : Une variable définie à l’intérieur d’une fonction est accessible uniquement
dans cette fonction.
• Portée globale : Une variable définie à l’extérieur de toute fonction est accessible dans tout
le module.
• Portée non locale : Une variable définie dans une fonction englobante (mais pas globale) est
accessible dans une fonction imbriquée.

5.4.1 Portée locale

Lorsqu’une variable est définie à l’intérieur d’une fonction, elle est considérée comme locale à
cette fonction, ce qui signifie qu’elle n’existe que pendant l’exécution de la fonction et n’est pas
accessible en dehors. Ainsi, les variables utilisées dans toutes nos fonctions précédemment écrites
sont locales à ces fonctions. Considérons la fonction suivante :
>>> def calculer_carre(nombre):
... resultat = nombre ** 2 # resultat est une variable locale
... return resultat
...
>>> print(calculer_carre(5))
25
>>> print(resultat) # Tentative d'accès à resultat
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'resultat' is not defined

Dans cet exemple, resultat est une variable locale à la fonction calculer_carre. Elle est créée
lors de l’appel de la fonction et détruite une fois la fonction terminée. Tenter d’accéder à resultat
en dehors de la fonction provoque une NameError, car la variable n’existe pas dans la portée
globale.
Note. Les paramètres d’une fonction, comme nombre dans l’exemple ci-dessus, sont également
considérés comme des variables locales. Ils sont initialisés avec les arguments passés lors de l’appel
et ne sont accessibles qu’à l’intérieur de la fonction.

5.4.2 Portée globale

Les variables définies à l’extérieur de toute fonction, au niveau du module, ont une portée globale.
Elles sont accessibles partout dans le module, y compris à l’intérieur des fonctions, à condition
qu’elles ne soient pas masquées par une variable locale du même nom.
>>> taux_taxe = 0.20 # Variable globale
>>> def calculer_prix_ttc(prix_ht):
... prix_ttc = prix_ht * (1 + taux_taxe)
... return prix_ttc

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 5.4 Portée des variables 91

...
>>> print(calculer_prix_ttc(100))
120.0

Ici, taux_taxe est une variable globale accessible dans la fonction calculer_prix_ttc. La fonc-
tion utilise taux_taxe pour calculer le prix toutes taxes comprises (TTC).
Cependant, si une fonction définit une variable locale avec le même nom qu’une variable globale,
la variable locale masque la variable globale à l’intérieur de la fonction.
>>> message = "Bonjour global" # Variable globale
>>> def afficher_message():
... message = "Bonjour local" # Variable locale
... print(message)
...
>>> afficher_message()
Bonjour local
>>> print(message)
Bonjour global

Dans la fonction afficher_message, la variable message locale prend la précédence sur la variable
message globale. En dehors de la fonction, la variable globale reste inchangée.

Note. Le masquage des variables globales par des variables locales est une source courante
d’erreurs. Évitez d’utiliser le même nom pour des variables locales et globales, sauf si cela est
intentionnel. Préférez des noms descriptifs et distincts pour clarifier l’intention du code.

5.4.3 Modification des variables globales avec global

Pour modifier une variable globale à l’intérieur d’une fonction, vous devez explicitement la déclarer
comme global. Sans cette déclaration, toute assignation à une variable dans une fonction crée une
nouvelle variable locale, même si une variable globale du même nom existe.
Tentons de modifier une variable globale sans global :
>>> compteur = 0 # Variable globale
>>> def incrementer():
... compteur = compteur + 1 # Crée une variable locale
... print(f"Compteur local : {compteur}")
...
>>> incrementer()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in incrementer
UnboundLocalError: cannot access local variable 'compteur' where it is not
associated with a value

On remarque que l’assignation compteur = compteur + 1 tente de créer une variable locale
compteur, mais la lecture de compteur avant son assignation provoque une UnboundLocalError.

En utilisant global, la fonction peut modifier la variable globale :

>>> compteur = 0 # Variable globale
>>> def incrementer():
... global compteur # Déclare compteur comme globale
... compteur += 1
... print(f"Compteur : {compteur}")
...

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 92 Chapitre 5. Fonctions

>>> incrementer()
Compteur : 1
>>> incrementer()
Compteur : 2
>>> print(f"Compteur global : {compteur}")
Compteur global : 2

La déclaration global compteur indique que la fonction doit utiliser la variable globale compteur
plutôt que d’en créer une locale. Chaque appel à incrementer modifie la variable globale.
Note. L’utilisation excessive de variables globales et du mot-clé global peut rendre le code difficile
à comprendre et à maintenir, car les fonctions deviennent dépendantes de l’état global. Préférez
passer les variables comme paramètres et renvoyer les résultats pour des fonctions plus prévisibles.

5.4.4 Portée non locale avec nonlocal

Dans le cas de fonctions imbriquées (une fonction définie à l’intérieur d’une autre), une variable
peut être définie dans la fonction englobante, mais pas au niveau global. Pour modifier une telle
variable depuis la fonction imbriquée, le mot-clé nonlocal est utilisé.
>>> def fonction_externe():
... compteur = 0 # Variable dans la portée englobante
... def fonction_interne():
... nonlocal compteur # Accède à la variable de la fonction
englobante
... compteur += 1
... print(f"Compteur interne : {compteur}")
... fonction_interne()
... print(f"Compteur externe : {compteur}")
...
>>> fonction_externe()
Compteur interne : 1
Compteur externe : 1

Dans cet exemple, compteur est défini dans fonction_externe et nonlocal compteur dans
fonction_interne permet de modifier cette variable. Sans nonlocal, une nouvelle variable locale
serait créée dans fonction_interne.
Note. Le mot-clé nonlocal est rarement utilisé dans les programmes simples.

5.4.5 Règle LEGB : Résolution des noms

Python suit la règle LEGB pour résoudre les noms des variables, c’est-à-dire pour déterminer quelle
variable est utilisée lorsqu’un nom est référencé. Cette règle est une sorte de guide que Python
utilise pour fouiller dans différentes boîtes (les portées) jusqu’à trouver la variable demandée. Les
portées sont vérifiées dans l’ordre suivant :
1. Local : Portée locale à la fonction actuelle : Python cherche d’abord dans la portée locale
de la fonction où la variable est utilisée.
2. Enclosing : Portée des fonctions englobantes : si la variable n’est pas trouvée localement,
Python cherche dans les fonctions englobantes, c’est-à-dire les fonctions imbriquées.
3. Global : Portée globale du module : ensuite, Python cherche dans la portée globale du
module, c’est-à-dire les variables définies en dehors de toute fonction.
4. Built-in : Portée des noms prédéfinis : enfin, s’il ne trouve toujours pas, Python regarde dans
les fonctions et noms prédéfinis du langage (comme print ou len).

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 5.5 Fonctions récursives 93

5.5 Fonctions récursives

Les fonctions récursives offrent une approche puissante pour résoudre certains problèmes en pro-
grammation, en permettant à une fonction de s’appeler elle-même pour traiter des sous-problèmes
plus petits. Cette technique, inspirée des mathématiques, est adaptée aux tâches qui peuvent être
décomposées en étapes répétitives, comme le calcul de suites ou la navigation dans des structures
arborescentes. Cependant, la récursivité nécessite une compréhension claire de son fonctionnement
pour éviter des erreurs comme des boucles infinies.

Une fonction récursive est une fonction qui s’appelle elle-même pour résoudre un problème en le
divisant en sous-problèmes plus petits. Toute fonction récursive doit comporter :
• Un cas de base : Une condition qui arrête la récursivité en renvoyant un résultat sans nouvel
appel.
• Un cas récursif : Une étape où la fonction s’appelle avec des arguments modifiés pour
progresser vers le cas de base.
La récursivité repose sur l’idée qu’un problème complexe peut être résolu en le réduisant à des
instances plus simples du même problème, jusqu’à atteindre une solution directe (le cas de base).
Une analogie utile est celle d’une poupée russe : chaque grande poupée contient une version
plus petite d’elle-même, et on continue à ouvrir les poupées jusqu’à atteindre la plus petite qui
ne contient plus rien. Cette dernière représente le cas de base, simple et directement résolu. La
récursivité suit un processus similaire, où chaque appel traite une partie du problème et passe le
reste à un nouvel appel.
Considérons une fonction récursive pour calculer la factorielle d’un nombre n, définie comme
n! = n × (n − 1) × · · · × 1 :
>>> def factorielle(n):
... # Cas de base : 0! = 1
... if n == 0:
... return 1
... # Cas récursif : n! = n * (n−1)!
... return n * factorielle(n − 1)
...
>>> print(factorielle(5))
120

Dans cet exemple :

• Le cas de base est n == 0, où la fonction renvoie 1 sans s’appeler.
• Le cas récursif est n * factorielle(n − 1), où la fonction s’appelle avec un argument
réduit (n − 1).
Pour factorielle(5), le calcul se déroule ainsi :
• factorielle(5) = 5 * factorielle(4)
• factorielle(4) = 4 * factorielle(3)
• factorielle(3) = 3 * factorielle(2)
• factorielle(2) = 2 * factorielle(1)
• factorielle(1) = 1 * factorielle(0)
• factorielle(0) = 1 (cas de base)
Les résultats sont ensuite combinés : 1 × 1 × 2 × 3 × 4 × 5 = 120.
Note. Sans cas de base ou avec un cas récursif qui ne converge pas vers le cas de base, une fonction
récursive peut provoquer une boucle infinie, entraînant une erreur RecursionError. Par exemple :

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 94 Chapitre 5. Fonctions

>>> def boucle_infinie(n):

... return boucle_infinie(n) # Pas de cas de base
...
>>> boucle_infinie(1)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in boucle_infinie
File "<stdin>", line 2, in boucle_infinie
File "<stdin>", line 2, in boucle_infinie
[Previous line repeated 996 more times]
RecursionError: maximum recursion depth exceeded

5.6 Fonctions anonymes

Les fonctions anonymes, également appelées fonctions lambda en Python, offrent un moyen concis
de définir des fonctions simples sans leur donner un nom explicite. Contrairement aux fonctions
classiques définies avec le mot-clé def, les fonctions lambda sont souvent utilisées pour des
tâches ponctuelles, comme passer une fonction en argument à une autre fonction ou effectuer
des transformations rapides de données. Leur syntaxe compacte en fait un outil précieux dans
des contextes comme le traitement des collections ou la programmation fonctionnelle, mais leur
simplicité impose des limites.

5.6.1 Syntaxe et création

Une fonction anonyme (ou fonction lambda) est une fonction définie en une seule ligne à l’aide
du mot-clé lambda. La plupart du temps, elle est non reliée à un nom (d’où le terme anonyme),
puisqu’elle s’utilise en général à la volée. Elle est utilisée pour des expressions simples et suit la
syntaxe :
1 lambda arguments: expression

Une fonction lambda peut prendre plusieurs arguments, mais elle ne peut contenir qu’une seule
expression, dont le résultat est implicitement renvoyé. L’évaluation de l’expression constitue donc
la valeur de retour de la fonction.
Les fonctions lambda sont principalement conçues pour être utilisées directement là où elles
sont définies, sans être assignées à une variable. Cela reflète leur objectif : fournir une fonction
temporaire pour un calcul ou une opération immédiate. En enveloppant une fonction lambda dans
des parenthèses et en lui passant immédiatement des arguments, vous pouvez exécuter le calcul en
une seule expression, ce qui est à la fois concis et clair pour des tâches simples.
Voici quelques exemples :
>>> (lambda x: x ** 2)(5)
25
>>> (lambda x: x % 2 == 0)(6)
True
>>> (lambda x, y, z: max(x, y, z))(10, 5, 8)
10

Commentaires

• lambda x: x ** 2 définit une fonction anonyme qui prend un argument x et renvoie son

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 5.6 Fonctions anonymes 95

carré. Les parenthèses (lambda x: x ** 2) créent la fonction et (5) l’appelle immédiate-

ment avec l’argument 5 en produisant 25. La fonction est utilisée une seule fois et disparaît
après l’exécution.
• La fonction lambda x: x % 2 == 0 renvoie True si l’argument x est pair et False sinon.
L’appel (6) produit True.
• La fonction lambda x, y, z: max(x, y, z) utilise la fonction intégrée max() pour ren-
voyer le plus grand des trois arguments.
Note. Même avec plusieurs arguments, une fonction lambda reste limitée à une seule expression.
Si le calcul devient complexe ou nécessite plusieurs étapes, envisagez une fonction nommée avec
def pour maintenir la clarté.

[Link] Assignation d’un nom (déconseillée)

Il est techniquement possible d’assigner une fonction lambda à une variable, ce qui lui donne un
nom, mais cette pratique est fortement déconseillée par le PEP 8 1 . Lorsqu’une fonction lambda est
assignée à une variable, elle devient similaire à une fonction nommée définie avec def, mais avec
des inconvénients significatifs, notamment des difficultés pour le débogage. Une fonction définie
avec def est alors préférable, car elle offre une meilleure lisibilité et des messages d’erreur plus
explicites.
Illustrons une fonction lambda assignée à une variable (à éviter) :
>>> carre = lambda x: x ** 2
>>> print(carre(5))
25

Cette fonction lambda est assignée à la variable carre, ce qui fonctionne, mais une définition avec
def est recommandée :

>>> def carre(x):

... return x ** 2
...
>>> print(carre(5))
25

La version avec def est plus claire et est conforme aux conventions.
Voici quelques raisons pour éviter d’assigner un nom à une fonction lambda, comme stipulé dans le
PEP 8 :
• Une fonction définie avec def est plus explicite avec un nom descriptif.
• Les fonctions lambda apparaissent comme <lambda> dans les traces d’erreur, ce qui rend
l’identification de l’erreur plus difficile. Une fonction nommée affiche son nom, cela facilite
le diagnostic.
• Assigner un nom à une fonction lambda suggère qu’elle est destinée à un usage répété, ce
qui contredit son rôle de fonction temporaire. Cela peut prêter à confusion pour les autres
programmeurs.
Une trace d’erreur montre les limites des fonctions lambda nommées :
>>> division = lambda x: x / 0
>>> print(division(5))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>

1. [Link]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 96 Chapitre 5. Fonctions

File "<stdin>", line 1, in <lambda>

ZeroDivisionError: division by zero

La traceback mentionne <lambda>, ce qui est peu informatif. De plus, l’indication de la ligne
pour l’erreur dans la fonction lambda (line 1) correspond à celle de l’appel et non à celle de la
définition.
Avec une fonction nommée :
>>> def division(x):
... return x / 0
...
>>> print(division(5))
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 2, in division
ZeroDivisionError: division by zero

Le nom division aide à repérer l’origine de l’erreur. Et, cette fois-ci, la traceback indique bien la
bonne ligne (line 2) dans la fonction.
Alors, conformément au PEP 8, évitez d’assigner des fonctions lambda à des variables. Si une
fonction doit être réutilisée ou nommée, utilisez def pour définir une fonction nommée, ce qui
améliore la lisibilité, facilite le débogage et respecte les conventions de Python. Les fonctions
lambda sont destinées à des usages temporaires, comme les calculs immédiats illustrés ci-dessous.

5.6.2 Utilisation avec les fonctions intégrées

Les fonctions lambda sont très utiles dans la programmation fonctionnelle 2 , souvent utilisées avec
des fonctions intégrées comme map(), filter() ou sorted() qui acceptent une fonction comme
argument pour traiter des collections. Ces cas d’usage exploitent la concision des fonctions lambda
pour effectuer des transformations ou des sélections rapides.

[Link] Utilisation avec map()

La fonction map() prend une fonction et un itérable, applique cette fonction à chaque élément de
l’itérable et produit un itérateur contenant les résultats. Une fonction lambda permet de définir une
transformation simple à appliquer à chaque élément, cela évite la nécessité de créer une fonction
nommée pour une tâche ponctuelle.
Soit cet exemple pour calculer le carré de chaque nombre dans une liste :
>>> nombres = [1, 2, 3, 4]
>>> carres = map(lambda x: x ** 2, nombres)
>>> print(list(carres))
[1, 4, 9, 16]

Dans cet exemple, lambda x: x ** 2 est une fonction anonyme qui prend un argument x et renvoie
son carré. La fonction map() applique cette lambda à chaque élément de nombres et list(carres)
convertit l’itérateur résultant en une liste. Chaque élément de nombres est transformé en son carré :
1 devient 1, 2 devient 4, et ainsi de suite.

Note. La fonction map() renvoie un itérateur, ce qui est efficace pour traiter de grandes collections
sans charger tous les résultats en mémoire immédiatement. Pour voir les résultats, il est nécessaire
2. [Link]

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 5.6 Fonctions anonymes 97

de convertir l’itérateur en une liste avec list(), comme montré dans l’exemple.

[Link] Utilisation avec filter()

La fonction filter() prend une fonction et un itérable et ne conserve que les éléments pour
lesquels la fonction renvoie True. Cela produit un itérateur des éléments sélectionnés. Une fonction
lambda est souvent utilisée pour définir le critère de sélection.
Par exemple, pour sélectionner les nombres pairs dans une liste :
>>> nombres = [1, 2, 3, 4, 5, 6]
>>> pairs = filter(lambda x: x % 2 == 0, nombres)
>>> print(list(pairs))
[2, 4, 6]

Dans cet exemple, lambda x: x % 2 == 0 renvoie True pour les nombres pairs et False sinon.
La fonction filter() conserve uniquement les éléments pour lesquels la lambda renvoie True.
Prenons un autre exemple : sélectionner les chaînes de longueur supérieure à 3 :
>>> mots = ["chat", "chien", "rat", "éléphant"]
>>> longs = filter(lambda x: len(x) > 3, mots)
>>> print(list(longs))
['chat', 'chien', 'éléphant']

La fonction lambda x: len(x) > 3 renvoie True pour les chaînes dont la longueur dépasse 3
caractères et filter() conserve ces éléments.
Note. La fonction passée à filter() doit renvoyer une valeur booléenne (True ou False). Une
fonction lambda qui renvoie une valeur non booléenne peut produire des résultats inattendus, car
Python interprète les valeurs non nulles comme True. Par exemple, lambda x: x conserve tous les
éléments non nuls, ce qui peut ne pas être l’intention.

[Link] Utilisation avec sorted()

La fonction sorted() trie les éléments d’un itérable et accepte un paramètre optionnel key qui
spécifie une fonction pour déterminer l’ordre de tri. Une fonction lambda est souvent utilisée
comme argument key pour définir un critère de tri personnalisé. Cela permet de trier selon des
attributs spécifiques des éléments.
Pour trier une liste de chaînes par leur longueur :
>>> fruits = ["pastèque", "banane", "orange", "pomme"]
>>> tries = sorted(fruits, key=lambda x: len(x))
>>> print(tries)
['pomme', 'banane', 'orange', 'pastèque']

Ici, lambda x: len(x) renvoie la longueur de chaque chaîne et sorted() utilise ces longueurs
pour trier la liste en plaçant les chaînes les plus courtes en premier ("pomme" avec 5 lettres, puis
"banane" avec 6 lettres, etc.).

Un autre exemple pour trier une liste de tuples par leur second élément :
>>> paires = [(1, "b"), (3, "a"), (2, "c")]
>>> tries = sorted(paires, key=lambda x: x[1])
>>> print(tries)
[(3, 'a'), (1, 'b'), (2, 'c')]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

98 Chapitre 5. Fonctions

La fonction lambda x: x[1] extrait le second élément de chaque tuple (les lettres "b", "a", "c")
et sorted() trie les tuples selon ces valeurs en produisant un ordre alphabétique basé sur le second
élément.
Note. La fonction sorted() renvoie une nouvelle liste triée, laissant l’itérable original inchangé.
Cela diffère de la méthode sort() des listes qui modifie la liste en place. Une fonction lambda
utilisée avec key doit renvoyer une valeur comparable, comme un nombre ou une chaîne, pour
garantir un tri cohérent.

En conclusion, l’utilisation des fonctions lambda offre plusieurs avantages significatifs : elles
évitent de définir une fonction nommée pour une tâche simple en rendant le code plus compact ;
elles sont définies exactement là où elles sont utilisées, ce qui peut clarifier l’intention du code pour
des transformations ou critères simples.
Cependant, quelques précautions sont nécessaires. Une fonction lambda complexe (par exemple,
avec des conditions imbriquées comme lambda x: x**2 if x > 0 else −x) peut rendre le code
difficile à lire. Dans ce cas, une fonction nommée avec def est préférable.
>>> nombres = [−2, −1, 0, 1, 2]
>>> transformes = map(lambda x: x**2 + 2*x + 1 if x > 0 else −x**2, nombres)
>>> print(list(transformes))
[−4, −1, 0, 4, 9]

Cette fonction lambda est difficile à comprendre. Une fonction nommée serait plus claire :
>>> def transformation(x):
... if x > 0:
... return x**2 + 2*x + 1
... return −x**2
...
>>> transformes = map(transformation, nombres)
>>> print(list(transformes))
[−4, −1, 0, 4, 9]

Évitez donc d’abuser des fonctions lambda pour des tâches complexes. Si une fonction lambda
dépasse une ligne ou devient difficile à comprendre, convertissez-la en une fonction classique.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 6. Modules et fichiers

Vous avez appris à écrire des programmes Python en utilisant les fonctionnalités de base du langage,
comme les variables, les boucles, les fonctions et les structures de données. Cependant, Python
offre une richesse de fonctionnalités supplémentaires grâce à ses modules qui permettent d’étendre
les capacités du langage en regroupant des fonctions, des classes et des constantes liées à des
tâches spécifiques. Ce chapitre vous introduit à l’utilisation des modules, à leur importation et à
l’exploration de certains modules standards de Python qui sont des outils essentiels pour résoudre
des problèmes variés.

6.1 Modules

Un module est un fichier Python contenant des définitions de fonctions, de classes, de variables
ou d’autres objets, qui peuvent être importés dans un programme pour réutiliser leur contenu. Les
modules permettent d’organiser le code de manière modulaire et de partager des fonctionnalités
entre différents programmes.
Pensez à un module comme à une boîte à outils : chaque module contient un ensemble d’outils
(fonctions, par exemple) adaptés à une tâche particulière, comme générer des nombres aléatoires ou
effectuer des calculs mathématiques. En important un module, vous accédez à ces outils sans avoir
à les recréer.

6.1.1 Syntaxe : import, from, as

Pour utiliser un module, vous devez l’importer dans votre programme, généralement en début de
fichier, à l’aide de l’instruction import. Python propose plusieurs façons d’importer des modules,
chacune adaptée à des besoins spécifiques. Les formes de base de l’importation sont : import,
from ... import ... et as.

[Link] L’instruction import

L’instruction import charge un module dans votre programme et rend ses fonctionnalités dispo-
nibles. La syntaxe de base est :
1 import nom_module
 100 Chapitre 6. Modules et fichiers

Pour importer le module math, qui contient des fonctions mathématiques, vous pouvez écrire :
>>> import math
>>> print([Link](16)) # Calcule la racine carrée de 16
4.0

Ici, [Link]() est une fonction du module math. Le point . permet d’accéder aux fonctions ou
variables définies dans le module.
Note. Les modules standards, comme math, font partie de la bibliothèque standard de Python et
sont disponibles dès l’installation de Python. Vous n’avez pas besoin de les installer séparément,
contrairement aux modules externes.

[Link] Importation sélective avec from ... import ...

Parfois, vous n’avez besoin que d’une partie spécifique d’un module, comme une fonction ou une
constante particulière. L’instruction from ... import ... permet d’importer uniquement ce dont
vous avez besoin, ce qui rend le code plus lisible et évite de charger l’ensemble du module.
Pour importer uniquement la fonction sqrt du module math :
>>> from math import sqrt
>>> print(sqrt(16)) # Pas besoin d'écrire [Link]
4.0

Vous pouvez importer plusieurs éléments en les séparant par des virgules :
>>> from math import sqrt, pi
>>> print(sqrt(25))
5.0
>>> print(pi)
3.141592653589793

On peut également importer toutes les fonctions d’un module :

>>> from math import *
>>> print(cos(−pi))
−1.0

L’instruction from math import * importe toutes les fonctions du module math. On peut alors
utiliser toutes ses fonctions directement.
Note. Évitez d’importer trop d’éléments avec from module import *, car cela peut rendre le
code difficile à lire et provoquer des conflits si plusieurs modules définissent des noms identiques
(par exemple, deux fonctions portant le même nom). Préférez des importations explicites.

[Link] Renommer avec as

L’instruction as permet de donner un alias (un nom alternatif) à un module ou à un élément importé.
Cela est utile pour raccourcir les noms longs ou éviter des conflits.
Pour importer le module math avec l’alias m :
>>> import math as m
>>> print([Link](9))
3.0

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 6.1 Modules 101

Ici, m est un alias pour math, ce qui rend le code plus concis.
Vous pouvez également utiliser as avec from ... import ... :
>>> from math import sqrt as racine
>>> print(racine(16))
4.0

Note. Choisissez des alias courts mais explicites pour maintenir la lisibilité du code. Par exemple,
m est un alias courant pour math, mais r pour sqrt pourrait prêter à confusion.

6.1.2 Modules standards

La bibliothèque standard de Python contient de nombreux modules prêts à l’emploi. Ces modules
couvrent des domaines variés comme les mathématiques, la gestion de fichiers, la génération de
nombres aléatoires ou encore la manipulation de dates. Ces modules sont installés avec Python et
ne nécessitent aucune configuration supplémentaire. Pour une liste complète des modules standards,
consultez la documentation officielle de Python 1 .
Note. Les modules standards sont vastes et il est impossible de couvrir toutes leurs fonctionnalités
dans ce cours. Les exemples présentés ici illustrent des cas d’usage courants. Pour explorer
davantage, référez-vous à la documentation officielle, qui fournit des descriptions détaillées et des
exemples supplémentaires.

[Link] random : nombres aléatoires

Le module random fournit des fonctions pour générer des nombres aléatoires, ce qui est utile
dans des applications comme les simulations, les jeux ou les tests de programmes. Il est basé sur
un générateur de nombres pseudo-aléatoires, ce qui signifie que les nombres produits semblent
aléatoires mais sont déterminés par une graine initiale (seed).
Voici quelques fonctions clés du module random :
• random() : Retourne un nombre flottant aléatoire entre 0 (inclus) et 1 (exclus), tiré dans une
distribution uniforme.
• randint(a, b) : Retourne un entier aléatoire entre a et b (inclus), toujours dans une distri-
bution uniforme.
• choice(sequence) : Sélectionne un élément aléatoire dans une séquence (comme une liste
ou un tuple).
Voici un exemple qui illustre l’utilisation de ces fonctions.
>>> import random
>>> print([Link]())
0.24489185380347622
>>> print([Link](1, 6))
2
>>> fruits = ["pomme", "banane", "orange"]
>>> print([Link](fruits))
orange

Note. Les résultats varient à chaque exécution, car les nombres sont générés aléatoirement. Pour
obtenir des résultats reproductibles (par exemple, pour des tests), vous pouvez définir une graine
avec [Link](valeur).

1. [Link]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 102 Chapitre 6. Modules et fichiers

En informatique, la génération de nombres aléatoires est un problème complexe. On utilise plutôt

des « générateurs de nombres pseudo-aléatoires ». Pour cela, une graine aléatoire doit être définie.
Cette graine est la plupart du temps un nombre entier qu’on passe au générateur : celui-ci va alors
produire une série donnée de nombres pseudo-aléatoires qui dépendent de cette graine. Si on change
la graine, la série de nombres change. En Python, la graine aléatoire se définit avec la fonction
seed() :

>>> [Link](42)
>>> [Link](0, 10)
10
>>> [Link](0, 10)
1
>>> [Link](0, 10)
0

Ici, la graine aléatoire est fixée à 42. Si on ne précise pas la graine, par défaut, Python utilise la date,
ou plutôt la timestamp (plus précisément, il s’agit du nombre de secondes écoulées depuis le 1er
janvier 1970). Ainsi, à chaque fois qu’on relance Python, la graine sera différente, car ce nombre
de secondes sera différent.
Si vous exécutez ces mêmes lignes de code (depuis l’instruction [Link](42)), il se peut que
vous ayez des résultats différents selon la version de Python. Néanmoins, vous devriez systémati-
quement obtenir les mêmes résultats si vous relancez plusieurs fois de suite ces instructions sur une
même machine.

Pour explorer d’autres fonctionnalités, comme la génération de nombres selon des distributions
spécifiques (par exemple, gaussienne, exponentielle, binomiale, etc.), consultez la documentation
officielle du module random 2 pour plus de détails.

[Link] math : fonctions mathématiques

Le module math fournit des fonctions et des constantes pour effectuer des calculs mathématiques
avancés, comme les opérations trigonométriques, logarithmiques et plein d’autres. Nous avons
donc des constantes comme pi (la constante π), e (la base du logarithme naturel), inf (l’infini),
ainsi que des fonctions comme :
• sqrt(x) : Calcule la racine carrée de x.
• sin(x), cos(x), tan(x) : Fonctions trigonométriques (angles en radians).
• ceil(x), floor(x) : Arrondissent x à l’entier supérieur ou inférieur.
• log(x) : Calcule le logarithme népérien de x.

>>> import math

>>> print([Link]([Link] / 4))
0.9999999999999999
>>> print([Link](1))
0.7853981633974483
>>> print([Link]((x for x in range(1, 6))))
120
>>> print([Link](3.2), [Link](3.2))
4 3
>>> print([Link](math.e))
1.0

2. [Link]

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 6.1 Modules 103

Note. Les fonctions trigonométriques du module math attendent des angles en radians, pas en
degrés. Pour convertir des degrés en radians, utilisez [Link](degres). Pour une liste
complète des fonctions du module math, consultez la documentation officielle 3 .

[Link] os : interactions système

Le module os fournit des fonctions pour interagir avec le système d’exploitation, permettant
d’effectuer des tâches comme la manipulation de fichiers, la navigation dans les répertoires ou
l’exécution de commandes système. Il est utile pour écrire des programmes qui doivent s’adapter à
l’environnement dans lequel ils s’exécutent, comme Windows, Linux ou macOS. Ce module est
un pont entre votre code Python et les fonctionnalités du système d’exploitation. Il contient des
outils pour gérer les fichiers et répertoires, accéder aux variables d’environnement et exécuter des
opérations spécifiques au système d’exploitation. Il permet d’écrire des programmes portables,
c’est-à-dire capables de fonctionner sur différents systèmes avec un minimum d’ajustements.
Voici quelques fonctions principales du module os :
• [Link]() : Retourne le chemin absolu du répertoire de travail courant.
• [Link](path) : Liste les fichiers et répertoires dans le chemin spécifié.
• [Link](path) : Crée un nouveau répertoire au chemin spécifié.
• [Link](*paths) : Combine plusieurs composants de chemin pour former un chemin
valide adapté au système d’exploitation.
Voici un programme qui utilise le module os pour afficher le répertoire de travail courant et lister
son contenu.
>>> import os
>>> print([Link]())
/home/user/projets
>>> print([Link]('.'))
['[Link]', 'data', '[Link]']

Dans cet exemple, [Link]() retourne le chemin absolu du répertoire courant et [Link]
('.') liste les fichiers et dossiers dans ce répertoire. Le point '.' désigne le répertoire courant.

Note. Les chemins de fichiers varient selon les systèmes d’exploitation (par exemple, C:\data sous
Windows, /data sous Linux). Utilisez [Link]() pour construire des chemins portables, car
il adapte automatiquement les séparateurs (\ ou /) au système.
Pour des tâches plus complexes, comme la suppression de répertoires ou la gestion des permis-
sions, consultez la documentation officielle du module os 4 . Le chapitre 8 explorera davantage la
manipulation de fichiers avec os.

[Link] time et datetime : gestion du temps et des dates

Les modules time et datetime permettent de travailler avec le temps et les dates, que ce soit pour
mesurer la durée d’un programme, afficher la date actuelle ou manipuler des intervalles temporels.
Bien que ces modules partagent certaines fonctionnalités, ils ont des objectifs distincts : time est
orienté vers la manipulation de timestamps et la mesure du temps, tandis que datetime est conçu
pour gérer des dates et heures de manière plus simple.

Le module time fournit des fonctions pour accéder au temps système, mesurer des durées et
formater des timestamps. Le module datetime offre des classes pour représenter et manipuler des

3. [Link]
4. [Link]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

104 Chapitre 6. Modules et fichiers

dates, des heures et des intervalles temporels de manière structurée.

Fonctions principales du module time

Le module time est souvent utilisé pour mesurer des durées ou introduire des pauses dans un
programme. Voici quelques fonctions clés :
• [Link]() : Retourne le timestamp actuel (nombre de secondes depuis le 1er janvier 1970,
appelé époque Unix).
• [Link](secondes) : Suspend l’exécution du programme pendant le nombre de se-
condes spécifié.
• [Link]() : Convertit un timestamp en une chaîne de caractères lisible.
Voici un programme qui mesure le temps d’exécution d’une boucle et introduit une pause.
1 import time
2
3 # Mesurer le temps de départ
4 debut = [Link]()
5
6 # Simuler une tâche
7 for _ in range(1000000):
8 pass
9
10 # Mesurer le temps écoulé
11 fin = [Link]()
12 print(f"Temps écoulé : {fin − debut} secondes")
13
14 # Pause de 2 secondes
15 [Link](2)
16 print("Fin de la pause")

Exécution :
Temps écoulé : 0.031142711639404297 secondes
Fin de la pause

Ici, [Link]() est utilisé pour mesurer la durée de la boucle et [Link](2) introduit une
pause de 2 secondes.
Fonctions principales du module datetime

Le module datetime fournit des classes comme datetime, date et timedelta pour manipuler des
dates et heures. Voici quelques fonctionnalités courantes :
• [Link]() : Retourne l’objet datetime représentant la date et l’heure
actuelles.
• [Link]() : Retourne l’objet date de la date actuelle.
• [Link] : Représente une durée (par exemple, 3 jours) pour effectuer des
calculs sur les dates.
Voici un programme qui affiche la date actuelle et calcule une date future.
>>> from datetime import datetime, date, timedelta
>>> print([Link]())
2025−05−05 [Link].384303
>>> print([Link]())
2025−05−05

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 6.1 Modules 105

>>> aujourd_hui = [Link]()

>>> dans_une_semaine = aujourd_hui + timedelta(days=7)
>>> print(dans_une_semaine)
2025−05−12

Dans cet exemple, timedelta(days=7) crée une durée de 7 jours, qui est ajoutée à la date actuelle
pour obtenir une date future.
Note. Les objets datetime et date ne sont pas des chaînes de caractères. Pour les afficher dans un
format spécifique (par exemple, "05/05/2025"), utilisez la méthode strftime(). Par exemple :
>>> print([Link]().strftime("%d/%m/%Y %H:%M"))
05/05/2025 03:03

Pour des manipulations avancées, comme les fuseaux horaires ou les formats de date complexes,
n’hésitez pas à consulter la documentation officielle des modules time 5 et datetime 6 .

[Link] copy : copie d’objets

Le module copy fournit des outils pour créer des copies d’objets Python, comme les listes, les
dictionnaires ou les objets personnalisés. Comme vous l’avez vu dans la section 4.1.3 sur les listes
imbriquées et la copie, une simple affectation (par exemple, liste2 = liste1) ne crée pas une
nouvelle liste, mais une référence à la même liste. Le module copy permet de résoudre ce problème
en créant des copies indépendantes, soit superficielles, soit profondes.
Les deux fonctions du module copy sont :
• [Link](obj) : Crée une copie superficielle (shallow copy) de l’objet obj.
• [Link](obj) : Crée une copie profonde (deep copy) de l’objet obj, y compris tous
les objets imbriqués.
Considérons une liste imbriquée pour illustrer la différence entre une copie superficielle et une
copie profonde.
1 import copy
2
3 # Liste imbriquée
4 liste_originale = [1, [2, 3], 4]
5
6 # Copie superficielle
7 liste_copie_superficielle = [Link](liste_originale)
8 # Copie profonde
9 liste_copie_profonde = [Link](liste_originale)
10
11 # Modifier la sous−liste dans la liste originale
12 liste_originale[1][0] = 99
13
14 print(liste_originale)
15 print(liste_copie_superficielle)
16 print(liste_copie_profonde)

Exécution :
[1, [99, 3], 4]
[1, [99, 3], 4]

5. [Link]
6. [Link]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 106 Chapitre 6. Modules et fichiers

[1, [2, 3], 4]

Dans cet exemple, la copie superficielle liste_copie_superficielle partage la sous-liste [2,

3] avec l’originale, donc la modification de liste_originale[1][0] affecte également la copie
superficielle. En revanche, la copie profonde liste_copie_profonde est totalement indépendante,
car elle a dupliqué la sous-liste.
Note. Utilisez [Link]() pour les structures de données complexes (comme des listes
imbriquées ou des dictionnaires contenant d’autres dictionnaires) afin d’éviter des modifications
inattendues. Cependant, deepcopy() est plus coûteux en termes de performances, car il duplique
récursivement tous les objets.

6.1.3 Obtenir de l’aide sur les modules

Lorsque vous travaillez avec des modules Python, qu’ils soient standards ou externes, il est fréquent
de ne pas connaître toutes leurs fonctionnalités ou la manière de les utiliser. Heureusement, Python
fournit des outils intégrés pour explorer les modules et obtenir des informations sur leur contenu à
travers deux fonctions essentielles : help() pour afficher la documentation des modules et dir()
pour lister leurs attributs. Ces outils sont utiles pour apprendre à utiliser un module sans avoir à
consulter immédiatement la documentation en ligne.
La fonction help() affiche la documentation intégrée (docstring) d’un module, d’une fonction ou
d’un objet Python en décrivant son utilisation et ses fonctionnalités. La fonction dir() retourne
une liste des attributs et méthodes disponibles pour un module ou un objet, permettant d’explorer
son contenu.

[Link] Utilisation de help()

La fonction help() est accessible directement dans l’interpréteur Python ou dans un programme.
En passant un module comme argument, elle affiche sa documentation qui inclut souvent une
description générale, une liste des fonctions et des exemples d’utilisation.
Pour obtenir de l’aide sur le module math, par exemple, vous pouvez exécuter la commande suivante
dans l’interpréteur Python :
>>> import math
>>> help(math)

Vous obtiendrez une page comme celle-ci :

Help on built−in module math:

NAME
math

DESCRIPTION
This module provides access to the mathematical functions
defined by the C standard.

FUNCTIONS
acos(x, /)
Return the arc cosine (measured in radians) of x.

The result is between 0 and pi.

acosh(x, /)

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 6.1 Modules 107

Return the inverse hyperbolic cosine of x.

asin(x, /)
Return the arc sine (measured in radians) of x.

Cet extrait montre une partie de la documentation du module math qui contient une description et
une liste de fonctions.
Vous pouvez également utiliser help() pour obtenir des informations sur une fonction spécifique
d’un module :
>>> help(math.log10)

Qui renvoie :
Help on built−in function log10 in module math:

log10(x, /)
Return the base 10 logarithm of x.

Note. Dans l’interpréteur Python, help() affiche la documentation de manière interactive, permet-
tant de naviguer avec les touches du clavier.

• Pour vous déplacer dans l’aide, utilisez les flèches du haut et du bas pour le parcourir ligne
par ligne ou les touches Page-up et Page-down pour faire défiler l’aide page par page.
• Pour quitter l’aide, appuyez sur la touche Q.
• Pour chercher du texte, tapez le caractère / puis le texte que vous cherchez, puis la touche
Entrée. Par exemple, pour chercher l’aide sur la fonction factorial(), tapez /factorial
puis Entrée.

[Link] Utilisation de dir()

La fonction dir() est utile pour explorer rapidement le contenu d’un module sans lire toute sa
documentation. Elle retourne une liste de chaînes représentant les noms des attributs, fonctions et
constantes définis dans le module.
Pour lister les attributs du module random :
>>> import random
>>> print(dir(random))
['BPF', 'LOG4', 'NV_MAGICCONST', 'RECIP_BPF', 'Random', 'SG_MAGICCONST', '
SystemRandom', 'TWOPI', '_ONE', '_Sequence', '__all__', '__builtins__', '
__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__
', '__spec__', '_accumulate', '_acos', '_bisect', '_ceil', '_cos', '_e', '
_exp', '_fabs', '_floor', '_index', '_inst', '_isfinite', '_lgamma', '_log
', '_log2', '_os', '_pi', '_random', '_repeat', '_sha512', '_sin', '_sqrt
', '_test', '_test_generator', '_urandom', '_warn', 'betavariate', '
binomialvariate', 'choice', 'choices', 'expovariate', 'gammavariate', '
gauss', 'getrandbits', 'getstate', 'lognormvariate', 'normalvariate', '
paretovariate', 'randbytes', 'randint', 'random', 'randrange', 'sample', '
seed', 'setstate', 'shuffle', 'triangular', 'uniform', 'vonmisesvariate',
'weibullvariate']

Cette liste affiche des fonctions comme random(), gauss(), choice(), etc., ainsi que des attributs
internes (commençant par _) utilisés par le module.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 108 Chapitre 6. Modules et fichiers

6.1.4 Modules externes : installation avec pip

Dans ce chapitre, vous avez utilisé des modules standards de Python, comme math, random ou os
qui sont inclus dans l’installation de Python. Cependant, la puissance de Python réside également
dans son écosystème de modules externes créés par la communauté et disponibles pour des tâches
spécifiques, comme l’analyse de données, la création de graphiques ou les requêtes web. Cette
sous-section explique comment installer et utiliser ces modules externes à l’aide de l’outil pip, le
gestionnaire de paquets de Python.

Un module externe est une bibliothèque Python développée par des tiers et non incluse dans la
bibliothèque standard. Ces modules sont hébergés sur le Python Package Index (PyPI) 7 et peuvent
être installés avec la commande pip.

[Link] Installation avec pip

Pour installer un module externe, vous utilisez pip, un outil en ligne de commande inclus avec
Python. La syntaxe générale pour installer un module est :
$ pip install nom_du_module

Pour installer le module requests qui permet de faire des requêtes HTTP (par exemple, pour récu-
pérer des pages web), exécutez la commande suivante dans votre terminal ou invite de commandes :
$ pip install requests

Une fois installé, vous pouvez importer et utiliser le module dans votre programme :
>>> import requests
>>> reponse = [Link]('[Link]
>>> print(reponse.status_code)
200

Ici, [Link]() envoie une requête à l’API de GitHub et status_code indique si la requête a
réussi (200 signifie succès).
Note. Assurez-vous que pip correspond à la version de Python que vous utilisez. Par exemple,
si vous utilisez Python 3 sur Linux ou macOS, exécutez pip3 install nom_du_module. Vous
pouvez vérifier la version avec pip −−version. Généralement, c’est pip qui est utilisé.

[Link] Mise à jour et désinstallation

Pour mettre à jour un module à la dernière version, utilisez :

$ pip3 install −−upgrade nom_du_module

Pour désinstaller un module, utilisez :

$ pip3 uninstall nom_du_module

Pour mettre à jour requests et vérifier la liste des modules installés :

$ pip3 install −−upgrade requests

7. [Link]

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 6.2 Programmation modulaire 109

$ pip3 list
Package Version
−−−−−−−−−−−−−−−−−−−−−−−−−−−−−− −−−−−−−−−−−−
anonip 1.1.0
base58 1.0.3
cryptography 43.0.0
[...]

[Link] Exemples de modules externes populaires

Voici quelques modules externes couramment utilisés dont certains seront davantage explorés dans
les chapitres suivants :
• numpy : Pour les calculs numériques et la manipulation de tableaux.
• matplotlib : Pour créer des graphiques et des visualisations.
• pandas : Pour l’analyse et la manipulation de données tabulaires.
• requests : Pour interagir avec des services web via des requêtes HTTP.
• scikit−learn : Pour l’apprentissage automatique (machine learning).
• tensorflow : Pour construire et entraîner des modèles de deep learning à grande échelle.
• torch : Pour le développement flexible et rapide de modèles de deep learning.
• seaborn : Pour créer des visualisations statistiques élégantes (basé sur matplotlib).
• sympy : Pour effectuer du calcul symbolique (mathématiques formelles).
• opencv−python : Pour le traitement d’images et la vision par ordinateur.

Note. Les modules externes peuvent avoir des dépendances (autres modules nécessaires à leur fonc-
tionnement). pip les installe automatiquement, mais vérifiez les messages d’erreur si l’installation
échoue.

6.2 Programmation modulaire

Les programmes que vous écriviez étaient généralement contenus dans un seul fichier Python
où vous définissiez des variables, des fonctions et des blocs de code pour résoudre un problème
spécifique. Cependant, à mesure que vos projets deviennent plus complexes, organiser le code dans
un seul fichier peut devenir difficile à maintenir et à réutiliser. La programmation modulaire résout
ce problème en permettant de diviser le code en unités distinctes appelées modules.

6.2.1 Création de modules

Un module est un fichier Python (extension .py) contenant des définitions de fonctions, de
constantes, de variables ou de classes, qui peuvent être importées dans d’autres programmes à l’aide
de l’instruction import. Un module agit comme une boîte à outils, regroupant des fonctionnalités
liées pour une réutilisation facile.
Pour créer un module, il suffit de créer un fichier avec l’extension .py (comme n’importe quel
script Python) et d’y définir les éléments souhaités. Une fois créé, le module peut être importé dans
un autre programme avec import nom_du_module où nom_du_module est le nom du fichier sans
l’extension .py.
Supposons que vous souhaitiez créer un module pour effectuer des calculs mathématiques simples.
Créez un fichier nommé [Link] avec le contenu suivant :
1 # Constantes
2 PI = 3.14159
3 GRAVITE = 9.81 # Accélération gravitationnelle en m/s^2

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 110 Chapitre 6. Modules et fichiers

4
5 # Fonctions
6 def carre(nombre):
7 """Retourne le carré d'un nombre."""
8 return nombre ** 2
9
10 def aire_cercle(rayon):
11 """Calcule l'aire d'un cercle à partir de son rayon."""
12 return PI * rayon ** 2
13
14 def energie_potentielle(masse, hauteur):
15 """Calcule l'énergie potentielle (E = mgh)."""
16 return masse * GRAVITE * hauteur

Vous pouvez ensuite utiliser ce module dans un autre programme, par exemple, [Link] :
1 import calculs
2
3 print(f"Carré de 5 : {[Link](5)}")
4 print(f"Aire d'un cercle de rayon 3 : {calculs.aire_cercle(3):.4f}")
5 print(f"Énergie potentielle (m=2kg, h=10m) : {calculs.energie_potentielle(2,
10):.4f}")
6 print(f"Constante de gravité : {[Link]}")

Lorsqu’on exécute le script [Link] :

$ python3 [Link]
Carré de 5 : 25
Aire d'un cercle de rayon 3 : 28.2743
Énergie potentielle (m=2kg, h=10m) : 196.2000
Constante de gravité : 9.81

Dans cet exemple, le module calculs définit deux constantes PI et GRAVITE, ainsi que trois
fonctions carre(), aire_cercle() et energie_potentielle(), qui sont accessibles via calculs
.nom après importation.

Notes.
1. Les constantes, bien que Python ne les rende pas réellement immuables, sont des variables
dont la valeur ne devrait pas changer. Par convention, elles sont nommées en majuscules (par
exemple, PI) et utilisées pour stocker des valeurs fixes. Il faut noter que les constantes en Py-
thon peuvent être modifiées, car il n’existe pas de mécanisme natif pour les rendre immuables.
Par convention, respectez leur usage en ne les modifiant pas dans vos programmes.
2. Les modules doivent être dans le même répertoire que le programme qui les importe ou dans
un chemin accessible par Python. Vous pouvez également utiliser from calculs import
carre pour importer uniquement une fonction spécifique.
3. La première fois qu’un module est importé, Python crée un répertoire nommé __pycache__
contenant un fichier avec une extension .pyc qui contient le bytecode 8 , c’est-à-dire le code
pré-compilé du module.

[Link] Inclusion de code exécutable

Un module Python, comme vu dans les paragraphes précédents, est généralement constitué de
définitions telles que des fonctions ou des constantes. Lorsqu’un tel module est importé dans

8. [Link]

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

6.2 Programmation modulaire 111

un autre programme, ces définitions sont chargées en mémoire, mais aucun code n’est exécuté
automatiquement, ce qui garantit que le module agit comme une bibliothèque d’outils prêts à
l’emploi. Cependant, si vous incluez du code exécutable, comme des appels à print() ou des
calculs, directement dans le module, ce code s’exécutera dès que le module est importé, ce qui peut
entraîner des comportements inattendus comme des affichages indésirables ou une consommation
inutile de mémoire
Lorsqu’un module ne contient que des définitions, son importation charge ces définitions en
mémoire sans provoquer d’effet immédiat. Cela garantit que le module peut être utilisé comme
une bibliothèque, où les fonctions ou constantes sont disponibles mais n’agissent que lorsqu’elles
sont explicitement appelées. Si on l’exécutait comme un script classique, cela n’afficherait rien, par
exemple :
$ python3 [Link]
$

Mais si vous ajoutez du code exécutable directement dans un module, ce code s’exécute automati-
quement chaque fois que le module est importé, ce qui peut produire des effets indésirables, comme
des affichages non souhaités, des calculs inutiles ou des modifications de données.
Modifions [Link] pour inclure du code exécutable :
1 PI = 3.14159
2
3 def aire_cercle(rayon):
4 """Calcule l'aire d'un cercle à partir de son rayon."""
5 return PI * rayon ** 2
6
7 # Code exécutable
8 print("Module calculs chargé.")
9 resultat = aire_cercle(5)
10 print(f"Aire d'un cercle de rayon 5 : {resultat:.4f}")

Importez ce module dans [Link] :

1 import calculs
2
3 print(f"Programme principal : Aire pour rayon 2 : {calculs.aire_cercle(2):.4
f}")

Puis exécutez-le :
$ python3 [Link]
Module calculs chargé.
Aire d'un cercle de rayon 5 : 78.5397
Programme principal : Aire pour rayon 2 : 12.5664

Lors de l’importation, les print() et le calcul de aire_cercle(5) s’exécutent immédiatement,

même si le programme principal ne les demande pas. Cela peut être source de confusion ou de
gaspillage de ressources.
Pour éviter que le code exécutable d’un module ne s’exécute lors de son importation, Python
fournit la variable spéciale __name__. Cette variable prend la valeur "__main__" si le fichier est
exécuté directement (par exemple, avec python3 [Link]) et le nom du module (par exemple,
"calculs") s’il est importé. En utilisant if __name__ == "__main__":, vous pouvez limiter

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 112 Chapitre 6. Modules et fichiers

l’exécution du code aux cas où le module est exécuté directement, souvent pour des tests ou des
démonstrations.
Modifions [Link] pour utiliser if __name__ == "__main__": :
1 PI = 3.14159
2
3 def aire_cercle(rayon):
4 """Calcule l'aire d'un cercle à partir de son rayon."""
5 return PI * rayon ** 2
6
7 if __name__ == "__main__":
8 print("Module calculs exécuté directement.")
9 resultat = aire_cercle(5)
10 print("Aire d'un cercle de rayon 5 :", resultat)

Testez le module directement :

$ python3 [Link]
Module calculs exécuté directement.
Aire d'un cercle de rayon 5 : 78.5397

Importez-le dans [Link] :

1 import calculs
2
3 print(f"Programme principal : Aire pour rayon 2 : {calculs.aire_cercle(2):.4
f}")

Puis exécutez-le :
$ python3 [Link]
Programme principal : Aire pour rayon 2 : 12.5663

Dans ce cas, le code dans if __name__ == "__main__": ne s’exécute pas lors de l’importation,
car __name__ vaut "calculs". Cela permet d’inclure des tests ou des exemples dans le module
sans affecter les programmes qui l’importent. On peut vérifier le comportement des fonctions du
module sans écrire un programme séparé.

6.2.2 Docstrings et documentation

La documentation est un élément clé de l’organisation du code, car elle permet aux autres program-
meurs (ou à vous-même dans le futur) de comprendre rapidement le fonctionnement d’un module,
d’une fonction ou d’une classe. En Python, la documentation est généralement fournie sous forme
de docstrings, des chaînes spéciales placées au début des modules, fonctions ou classes pour décrire
leur rôle et leur utilisation.

Une docstring est une chaîne de caractères, délimitée par des triples guillemets (""" ou '''),
placée immédiatement après la définition d’un module, d’une fonction ou d’une classe, pour
décrire son objectif, ses paramètres et son comportement. La documentation contient également
des commentaires et des guides externes pour expliquer le code.
Une docstring doit être claire, concise et suivre les conventions de Python, notamment la norme

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

6.2 Programmation modulaire 113

PEP 257 9 . Elle inclut généralement :

• Une description brève de ce que fait l’élément (module, fonction, classe).
• Une explication des paramètres, de leurs types et de leur rôle.
• Une description de la valeur retournée, le cas échéant.
• Des informations sur les exceptions levées, si pertinentes.
Voici un module traitement_texte.py avec des docstrings complètes :
1 """Module pour le traitement avancé des chaînes de caractères.
2
3 Ce module fournit des fonctions pour nettoyer et analyser du texte, utiles
pour
4 le prétraitement de données textuelles ou la validation d'entrées
utilisateur.
5 """
6
7 def nettoyer_texte(texte):
8 """Convertit une chaîne en minuscules et supprime les espaces inutiles.
9
10 Args:
11 texte (str): La chaîne à nettoyer.
12
13 Returns:
14 str: La chaîne nettoyée, en minuscules et sans espaces au début ou à
la fin.
15
16 Example:
17 >>> nettoyer_texte(' Bonjour ! ')
18 'bonjour !'
19 """
20 return [Link]().strip()
21
22 def compter_mots(texte):
23 """Compte le nombre de mots dans une chaîne.
24
25 Un mot est défini comme une séquence de caractères séparée par des
espaces.
26
27 Args:
28 texte (str): La chaîne à analyser.
29
30 Returns:
31 int: Le nombre de mots dans la chaîne.
32 """
33 return len([Link]())

Vous pouvez accéder aux docstrings avec la fonction help() ou l’attribut __doc__ :
>>> import traitement_texte
>>> help(traitement_texte)

Help on module traitement_texte:

NAME
traitement_texte − Module pour le traitement avancé des chaînes de caractè
res.

DESCRIPTION
Ce module fournit des fonctions pour nettoyer et analyser du texte, utiles

9. [Link]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 114 Chapitre 6. Modules et fichiers

pour
le prétraitement de données textuelles ou la validation d'entrées
utilisateur.

FUNCTIONS
compter_mots(texte)
Compte le nombre de mots dans une chaîne.

Un mot est défini comme une séquence de caractères séparée par des
espaces.

Args:
texte (str): La chaîne à analyser.

Returns:
int: Le nombre de mots dans la chaîne.

nettoyer_texte(texte)
Convertit une chaîne en minuscules et supprime les espaces inutiles.

Args:
texte (str): La chaîne à nettoyer.

Returns:
str: La chaîne nettoyée, en minuscules et sans espaces au début ou
à la fin.

Example:
>>> nettoyer_texte(" Bonjour ! ")
'bonjour !'

FILE
/home/user/projets/traitement_texte.py

Vous remarquez que Python a généré automatiquement cette page d’aide, tout comme il est capable
de le faire pour les modules internes à Python (random, math, etc.) et ce, grâce aux docstrings.
Note. Les docstrings sont très utiles dans les environnements de développement comme VSCode, où
elles apparaissent sous forme d’infobulles lorsque vous survolez une fonction. Une documentation
absente ou obsolète peut rendre un module inutilisable, surtout dans un contexte collaboratif.
Prenez le temps de documenter votre code dès sa création, car il est plus difficile d’ajouter une
documentation complète après coup.
Voici quelques recommandations pour une documentation efficace :
• Écrivez des docstrings pour chaque module, fonction et classe, même si leur rôle semble
évident.
• Utilisez un langage clair et évitez le jargon technique inutile.
• Incluez des exemples dans les docstrings pour illustrer l’utilisation des fonctions.
• Mettez à jour la documentation chaque fois que vous modifiez le code pour éviter les
incohérences.

6.3 Fichiers
Les programmes que vous avez écrits jusqu’à présent manipulaient des données temporaires,
stockées en mémoire dans des variables, des listes ou des dictionnaires. Cependant, dans de
nombreuses applications, il est nécessaire de sauvegarder des données de manière permanente ou
de lire des informations stockées sur le disque, par exemple dans des fichiers texte. La manipulation

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 6.3 Fichiers 115

de fichiers est ainsi une tâche courante en programmation, que ce soit pour enregistrer des résultats,
lire des données expérimentales ou configurer une application. Python facilite cette tâche grâce à la
fonction open() qui permet d’accéder à un fichier pour le lire, l’écrire ou les deux.

6.3.1 open(), contexte with

Pour manipuler un fichier, vous devez d’abord l’ouvrir avec la fonction open() qui retourne un
objet fichier. Cet objet fournit des méthodes pour lire, écrire ou naviguer dans le contenu du fichier.
Une fois l’opération terminée, le fichier doit être fermé pour libérer les ressources système. Le
gestionnaire de contexte with simplifie cette tâche en fermant automatiquement le fichier, même en
cas d’erreur.

[Link] Utilisation de open()

La syntaxe de base de open() est :

1 open(path, mode)

• path : Le chemin vers le fichier qui peut être relatif (par exemple, [Link]) ou absolu
(par exemple, /home/user/[Link]). Utilisez [Link]() pour construire des
chemins portables.
• mode : Une chaîne spécifiant le mode d’ouverture, comme 'r' pour la lecture ou 'w' pour
l’écriture.
Les méthodes principales d’un objet fichier sont :
• read() : Lit tout le contenu du fichier sous forme de chaîne (ou de bytes en mode binaire).
• readline() : Lit une ligne du fichier à la fois.
• readlines() : Lit toutes les lignes du fichier et les retourne sous forme de liste de chaînes.
• write(text) : Écrit du texte (ou des bytes) dans le fichier.
• close() : Ferme le fichier, libérant les ressources.

Supposons que vous ayez un fichier texte nommé [Link] avec le contenu suivant :
pomme
banane
orange
ananas
mangue

Voici un programme qui lit et affiche tout le contenu de ce fichier à l’aide de read() :
>>> fichier = open('[Link]', 'r')
>>> contenu = [Link]()
>>> print(contenu)
pomme
banane
orange
ananas
mangue

>>> [Link]()

Dans cet exemple, read() récupère tout le contenu du fichier comme une seule chaîne avec les
sauts de ligne (\n). La méthode close() est appelée manuellement pour fermer le fichier.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 116 Chapitre 6. Modules et fichiers

Note. Oublier d’appeler close() peut entraîner des problèmes, comme des données non enregis-
trées ou des ressources système bloquées. Le gestionnaire de contexte with est recommandé pour
éviter ces erreurs.

[Link] Gestionnaire de contexte with

Le gestionnaire de contexte with garantit que le fichier est fermé automatiquement à la fin du bloc,
même si une erreur survient. Sa syntaxe est :
1 with open(path, mode) as variable:
2 # Instructions

Voici le même programme de lecture de [Link], mais en utilisant with :

>>> with open('[Link]', 'r') as fichier:
... contenu = [Link]()
... print(contenu)
...
pomme
banane
orange
ananas
mangue

Une fois sorti du bloc d’instructions, Python fermera automatiquement le fichier. Vous n’avez donc
plus besoin d’utiliser la méthode .close().

6.3.2 Méthodes de lecture : read, readline, readlines

Python propose plusieurs méthodes pour lire un fichier, chacune adaptée à des besoins spéci-
fiques. Comprendre leurs différences est essentiel pour manipuler efficacement les fichiers, surtout
lorsqu’ils contiennent beaucoup de données.
read() La méthode read() lit tout le contenu du fichier et le retourne comme une seule chaîne
(ou une séquence de bytes en mode binaire). Elle est adaptée aux petits fichiers ou lorsque vous
avez besoin de tout le contenu d’un coup. Elle retourne une chaîne contenant toutes les lignes, avec
les sauts de ligne (\n) préservés.. Nous l’avons déjà vue en exemple dans la section précédente.
Note. Pour les fichiers volumineux, read() peut consommer beaucoup de mémoire, car tout le
contenu est chargé en mémoire. Pour les gros fichiers, préférez les méthodes ligne par ligne.
readline() La méthode readline() lit une seule ligne du fichier et retourne une chaîne (avec
le \n à la fin, sauf si la ligne ne se termine pas par un saut de ligne). Elle est utile pour parcourir un
fichier progressivement, ligne par ligne.
>>> with open('[Link]', 'r') as fichier:
... ligne1 = [Link]()
... ligne2 = [Link]()
... print("Première ligne :", [Link]())
... print("Deuxième ligne :", [Link]())
...
Première ligne : pomme
Deuxième ligne : banane

La méthode strip() supprime les sauts de ligne pour un affichage plus propre. Si vous appelez
readline() après la dernière ligne, elle retourne une chaîne vide ('').

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 6.3 Fichiers 117

readlines() La méthode readlines() lit toutes les lignes du fichier et les retourne sous forme
de liste, chaque élément étant une chaîne représentant une ligne (avec \n). Elle est pratique lorsque
vous souhaitez stocker toutes les lignes pour un traitement ultérieur.
>>> with open('[Link]', 'r') as fichier:
... lignes = [Link]()
... print(lignes)
...
['pomme\n', 'banane\n', 'orange\n', 'ananas\n', 'mangue\n']

Pour supprimer les sauts de ligne, vous pouvez utiliser une compréhension de liste :
>>> with open('[Link]', 'r') as fichier:
... lignes = [[Link]() for ligne in [Link]()]
... print(lignes)
...
['pomme', 'banane', 'orange', 'ananas', 'mangue']

Note. La méthode readlines() charge toutes les lignes en mémoire, ce qui peut être problématique
pour les fichiers très volumineux. Une boucle for sur l’objet fichier est souvent plus efficace, comme
expliqué ci-dessous.

[Link] Lecture ligne par ligne avec une boucle

Une méthode efficace pour lire un fichier volumineux est d’itérer directement sur l’objet fichier
avec une boucle for. Cela lit une ligne à la fois et réduit la consommation de mémoire.
>>> with open('[Link]', 'r') as fichier:
... for ligne in fichier:
... print([Link]())
...
pomme
banane
orange
ananas
mangue

Chaque itération de la boucle récupère une ligne, incluant le saut de ligne, que strip() supprime
pour l’affichage.
Note. Les lignes lues via readline(), readlines() ou une boucle for incluent le caractère de
saut de ligne (\n), sauf pour la dernière ligne si elle ne se termine pas par \n. Utilisez strip() ou
rstrip() pour les supprimer si nécessaire.

6.3.3 Modes : r, w, a, rb, wb

Lorsque vous ouvrez un fichier avec open(), le paramètre mode détermine si vous lisez, écrivez ou
ajoutez des données, ainsi que le type de données manipulées (texte ou binaire). Choisir le mode
approprié est essentiel pour éviter des erreurs ou des comportements inattendus.
Les modes suivants s’appliquent aux fichiers texte, où les données sont interprétées comme des
chaînes de caractères :

• 'r' : Mode lecture (par défaut). Ouvre le fichier pour la lecture uniquement. Si le fichier
n’existe pas, une erreur FileNotFoundError est levée.
• 'w' : Mode écriture. Ouvre le fichier pour l’écriture, créant un nouveau fichier ou remplaçant

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

118 Chapitre 6. Modules et fichiers

un fichier existant.
• 'a' : Mode ajout. Ouvre le fichier pour ajouter du contenu à la fin, créant un nouveau fichier
si nécessaire.
Voici un programme qui illustre les modes w et a :
1 # Écriture : remplace ou crée le fichier
2 with open('[Link]', 'w') as fichier:
3 [Link]("Entrée 1\n")
4
5 # Ajout : ajoute à la fin du fichier
6 with open('[Link]', 'a') as fichier:
7 [Link]("Entrée 2\n")

Après exécution, le fichier [Link] contient :

1 Entrée 1
2 Entrée 2

Si vous exécutez à nouveau le mode w, le fichier est remplacé, tandis que le mode a ajoute à la fin
sans affecter le contenu existant.
Notes.
1. Le mode w écrase tout contenu existant sans avertissement. Utilisez a pour préserver le
contenu et ajouter de nouvelles données.
2. Vous pouvez combiner les modes pour des besoins spécifiques, comme 'r+' (lecture et
écriture) ou 'x' pour la création exclusive. Cependant, ces modes sont moins courants
pour les débutants. Mais si vous voulez approfondir votre compréhension des modes et des
opérations sur les fichiers, consultez la documentation officielle de Python 10 .

10. [Link]

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7. Bibliothèques scientifiques

7.1 Introduction aux bibliothèques scientifiques

7.1.1 Rôle des bibliothèques dans les sciences et l’ingénierie
Dans les disciplines scientifiques et techniques, les calculs numériques, la visualisation de données
et l’analyse de résultats expérimentaux occupent une place centrale. Ces tâches, souvent complexes,
nécessitent des outils puissants capables de manipuler de grandes quantités de données avec rapidité
et précision. Les bibliothèques scientifiques en Python répondent précisément à ce besoin en
offrant des fonctions prêtes à l’emploi, optimisées pour les opérations mathématiques, statistiques
et graphiques. En utilisant ces bibliothèques, vous pouvez, par exemple, résoudre des systèmes
d’équations linéaires, analyser des séries de mesures ou représenter graphiquement des résultats
expérimentaux, sans avoir à réécrire des algorithmes complexes.

7.1.2 Aperçu des bibliothèques : NumPy, Matplotlib et Pandas

Trois bibliothèques principales seront abordées dans ce chapitre, chacune jouant un rôle complé-
mentaire dans le calcul scientifique.
La bibliothèque NumPy est le socle du calcul numérique en Python. Elle permet de manipuler des
tableaux multidimensionnels (comme des vecteurs ou des matrices) et d’effectuer des opérations
mathématiques complexes, comme des produits matriciels ou des calculs statistiques, de manière
rapide et intuitive. Vous utiliserez NumPy pour créer, manipuler et analyser des données numériques
avec une efficacité inégalée par les structures de base de Python, comme les listes.
La bibliothèque Matplotlib est dédiée à la visualisation des données. Elle vous permettra de
créer des graphiques variés, tels que des courbes, des histogrammes ou des diagrammes en trois
dimensions, pour représenter vos résultats de manière claire et professionnelle. Que ce soit pour
illustrer une fonction mathématique ou afficher des données expérimentales, Matplotlib est un
outil essentiel pour communiquer vos analyses.
La bibliothèque Pandas excelle dans la gestion et l’analyse de données tabulaires, similaires à des
feuilles de calcul. Elle est particulièrement utile pour organiser, filtrer et analyser des ensembles
de données structurées, comme des mesures issues d’expériences ou des bases de données. Avec
Pandas, vous pourrez facilement extraire des informations pertinentes de grands volumes de
données.
 120 Chapitre 7. Bibliothèques scientifiques

Chacune de ces bibliothèques a été conçue pour interagir harmonieusement avec les autres, vous
permettant de construire des projets scientifiques complets, de la manipulation des données à leur
visualisation. Dans les sections suivantes, vous commencerez par explorer NumPy qui constitue la
fondation de ces outils.

7.1.3 Installation des bibliothèques : outils et vérification

Avant de pouvoir utiliser ces bibliothèques, il est nécessaire de les installer sur votre système, car
elles ne font pas partie de la distribution standard de Python. L’outil le plus courant pour gérer
l’installation est pip, le gestionnaire de paquets de Python. Une autre option populaire est conda,
qui est particulièrement adapté aux environnements scientifiques grâce à sa gestion simplifiée des
dépendances.
Pour installer NumPy, Matplotlib et Pandas avec pip, ouvrez un terminal (ou une invite de
commandes sous Windows) et exécutez la commande suivante :
1 pip install numpy matplotlib pandas

Cette commande télécharge et installe les versions les plus récentes de ces bibliothèques, compa-
tibles avec Python 3.10 ou supérieur 1 . Si vous utilisez conda, la commande équivalente est :
1 conda install numpy matplotlib pandas

# Résultat attendu dans le terminal

Collecting numpy
Downloading numpy−2.2.4−cp310−cp310−win_amd64.whl (15.8 MB)
...
Successfully installed numpy−2.2.4 matplotlib−3.10.1 pandas−2.2.3

Une fois l’installation terminée, vous devez vérifier que les bibliothèques sont correctement instal-
lées. Pour cela, ouvrez un interpréteur Python (par exemple, en tapant python dans le terminal) et
essayez d’importer chaque bibliothèque :
>>> import numpy
>>> import matplotlib
>>> import pandas

Si aucune erreur n’apparaît, les bibliothèques sont prêtes à l’emploi. En pratique, vous utiliserez
souvent des alias pour simplifier vos scripts, comme np pour NumPy. Par exemple :
>>> import numpy as np
>>> print(np.__version__)
2.2.4

Cette commande affiche la version de NumPy installée, ce qui est utile pour vérifier la compatibilité
avec vos scripts. Si une erreur survient lors de l’importation (par exemple, ModuleNotFoundError),
assurez-vous que l’installation a réussi et que vous utilisez le bon environnement Python (certains
systèmes peuvent avoir plusieurs versions de Python installées).
Note. Il est important d’utiliser une version récente de Python (3.10 ou supérieure) pour garantir
la compatibilité avec les dernières versions des bibliothèques. Si vous rencontrez des problèmes

1. Documentation officielle de Python : [Link]

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.2 NumPy : fondations des calculs numériques 121

d’installation, vérifiez que pip ou conda est associé à la bonne version de Python en exécutant
pip −−version ou conda −−version dans le terminal.

Vous êtes maintenant prêts à explorer les fonctionnalités de ces bibliothèques, en commençant par
NumPy dans la section suivante. Les outils installés vous permettront de manipuler des données, de
réaliser des calculs scientifiques et de visualiser vos résultats avec aisance.

7.2 NumPy : fondations des calculs numériques

7.2.1 Concepts de base : tableaux et matrices dans NumPy
[Link] Les tableaux NumPy (ndarray) face aux listes Python

Dans le calcul scientifique, la manipulation efficace de grandes quantités de données numériques

est essentielle. La bibliothèque NumPy (Numerical Python) 2 introduit une structure de données
fondamentale : le tableau multidimensionnel ou ndarray. Un ndarray est une grille d’éléments,
tous du même type (généralement des nombres), organisée en une ou plusieurs dimensions. Par
exemple, un tableau à une dimension peut représenter un vecteur, un tableau à deux dimensions
une matrice et un tableau à trois dimensions un tenseur. Ces structures sont essentielles pour des
applications scientifiques, comme le traitement de données expérimentales ou la modélisation
mathématique.
À première vue, un ndarray peut ressembler à une liste Python, mais leurs différences sont
significatives. Une liste Python est une structure flexible, capable de stocker des éléments de
types variés (nombres, chaînes, etc.), mais elle est lente pour les calculs numériques intensifs, car
chaque opération nécessite des boucles explicites. En revanche, un ndarray est optimisé pour la
performance : il stocke les données dans un bloc de mémoire contigu permettant des opérations
vectorisées rapides. De plus, les ndarray imposent un type de données unique (par exemple, entiers
ou flottants), ce qui réduit l’utilisation de la mémoire et accélère les calculs.
Considérez un exemple simple : pour additionner deux listes de nombres en Python, vous devez
écrire une boucle ou utiliser une compréhension de liste. Avec NumPy, cette opération est directe et
rapide. Voici une comparaison :
1 import numpy as np
2
3 # Avec une liste Python
4 liste1 = [1, 2, 3]
5 liste2 = [4, 5, 6]
6 somme = [liste1[i] + liste2[i] for i in range(len(liste1))]
7 print(somme)
8
9 # Avec NumPy
10 tableau1 = [Link]([1, 2, 3])
11 tableau2 = [Link]([4, 5, 6])
12 somme = tableau1 + tableau2
13 print(somme)

[5, 7, 9]
[5 7 9]

Dans l’exemple avec NumPy, l’opération + est appliquée simultanément à tous les éléments, sans
boucle explicite, ce qui est non seulement plus concis, mais aussi beaucoup plus rapide pour de

2. [Link]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 122 Chapitre 7. Bibliothèques scientifiques

grands ensembles de données. Cette capacité à effectuer des opérations vectorisées fait de NumPy
un outil indispensable pour le calcul scientifique.

[Link] Création de tableaux et matrices : array, zeros, ones, arange, linspace, eye, diag,
full, tile

La création de tableaux est la première étape pour exploiter la puissance de NumPy. La bibliothèque
propose plusieurs fonctions pour générer des ndarray avec des structures et des contenus variés,
adaptées à différentes applications scientifiques. Nous commencerons par la fonction array qui
convertit une liste Python (ou une liste imbriquée) en un ndarray.
Pour créer un tableau à une dimension, représentant par exemple une série de mesures, vous pouvez
utiliser :
>>> import numpy as np
>>> valeurs = [1.5, 2.7, 3.2]
>>> tableau = [Link](valeurs)
>>> print(tableau)
[1.5 2.7 3.2]

Pour une matrice (tableau à deux dimensions), utilisez une liste imbriquée. Par exemple, pour
représenter une matrice 2x3 :
>>> matrice = [Link]([[1, 2, 3], [4, 5, 6]])
>>> print(matrice)
[[1 2 3]
[4 5 6]]

Notes.
• Lors de la création d’un tableau avec array, assurez-vous que les listes imbriquées ont des
longueurs cohérentes. Par exemple, [Link]([[1, 2], [3]]) générera une erreur ou un
tableau irrégulier, car les sous-listes n’ont pas la même taille.
• Les tableaux NumPy sont homogènes, c’est-à-dire que tous leurs éléments doivent être du
même type. Si vous créez un tableau à partir d’une liste contenant des entiers et des flottants,
NumPy convertit automatiquement tous les éléments en flottants pour préserver la précision.
Par exemple :
>>> mixte = [Link]([1, 2, 3.5])
>>> print(mixte)
[1. 2. 3.5]

Si des chaînes de caractères sont incluses, tous les éléments sont convertis en chaînes :
>>> mixte_texte = [Link]([1, 2, "tigre"])
>>> print(mixte_texte)
['1' '2' 'tigre']

Pour initialiser des tableaux avec des valeurs prédéfinies, NumPy propose zeros et ones. La fonction
zeros crée un tableau rempli de zéros, utile pour initialiser des matrices avant de les remplir :

>>> [Link]((2))
array([0., 0.])
>>> [Link]((2, 3))

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

7.2 NumPy : fondations des calculs numériques 123

array([[0., 0., 0.],

[0., 0., 0.]])

La fonction ones crée un tableau rempli de uns, souvent utilisé pour des calculs normalisés :
>>> [Link]((3))
array([1., 1., 1.])
>>> [Link]((3, 2))
array([[1., 1.],
[1., 1.],
[1., 1.]])

La fonction full remplit un tableau avec une valeur spécifique, par exemple pour initialiser une
matrice avec une constante :
>>> [Link]((4), 5)
array([5, 5, 5, 5])
>>> [Link]((2, 2), 5)
array([[5, 5],
[5, 5]])

Pour générer des séquences numériques, arange et linspace sont particulièrement utiles. La
fonction arange crée un tableau à une dimension avec des valeurs espacées régulièrement, en
spécifiant un début, une fin (exclue) et un pas, similaire à range. Par exemple, pour créer une
séquence de 0 à 9 avec un pas de 2 :
>>> [Link](0, 10, 2)
array([0, 2, 4, 6, 8])

La fonction linspace génère un tableau avec un nombre donné de points équidistants entre deux
bornes (incluses). Elle est idéale pour créer des axes pour des graphiques. Par exemple, pour générer
5 points entre 0 et 1 :
>>> [Link](0, 1, 5)
array([0. , 0.25, 0.5 , 0.75, 1. ])

Pour des matrices spécifiques en algèbre linéaire, eye et diag sont essentielles. La fonction eye
crée une matrice identité, avec des 1 sur la diagonale principale et des 0 ailleurs :
>>> [Link](3)
array([[1., 0., 0.],
[0., 1., 0.],
[0., 0., 1.]])

La fonction diag crée une matrice diagonale à partir d’une liste de valeurs, ou extrait la diagonale
d’une matrice existante. Par exemple :
>>> [Link]([1, 2, 3])
array([[1, 0, 0],
[0, 2, 0],
[0, 0, 3]])
>>> [Link]([Link]([1, 2, 3]))
array([1, 2, 3])

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 124 Chapitre 7. Bibliothèques scientifiques

La fonction tile répète un tableau ou une séquence selon un motif spécifié, utile pour créer des
structures répétitives. Par exemple, pour répéter le vecteur [1, 2] trois fois :
>>> [Link]([1, 2], 3)
array([1, 2, 1, 2, 1, 2])

Pour une répétition en deux dimensions, spécifiez un tuple pour la forme :

>>> [Link]([1, 2], (2, 3))
array([[1, 2, 1, 2, 1, 2],
[1, 2, 1, 2, 1, 2]])

Ces fonctions vous permettent de créer des tableaux adaptés à une grande variété de besoins, qu’il
s’agisse de modéliser des données expérimentales, de préparer des calculs matriciels ou de générer
des séquences pour des visualisations. Dans la sous-sous-section suivante, vous explorerez les
propriétés de ces tableaux, comme leur forme et leur type de données, pour mieux comprendre et
manipuler leur structure.

[Link] Propriétés des tableaux : shape, ndim, size, dtype

Une fois un tableau ndarray créé, il est essentiel de comprendre ses caractéristiques pour pouvoir
le manipuler efficacement. NumPy fournit plusieurs attributs permettant d’explorer la structure et le
contenu d’un tableau : shape, ndim, size et dtype.
L’attribut shape retourne un tuple indiquant le nombre d’éléments dans chaque dimension du
tableau. Par exemple, pour un tableau à une dimension, shape donne la longueur du tableau. Pour
une matrice, il indique le nombre de lignes et de colonnes. Considérons l’exemple suivant :
>>> tableau_1d = [Link]([1, 2, 3, 4])
>>> tableau_1d.shape
(4,)
>>> [Link]
(2, 3)

Le résultat (4,) signifie que le tableau a une dimension avec 4 éléments. (2, 3) indique 2 lignes
et 3 colonnes.
L’attribut ndim donne le nombre de dimensions du tableau, c’est-à-dire le nombre d’axes ou de
niveaux d’organisation. Il correspond à la longueur du tuple retourné par shape. Par exemple :
>>> tableau_1d.ndim
1
>>> [Link]
2

Pour un tableau à trois dimensions, comme un cube de données, ndim serait 3. Cet attribut est utile
pour vérifier si un tableau a la structure attendue avant d’effectuer des opérations complexes.
L’attribut size retourne le nombre total d’éléments dans le tableau, quelle que soit sa forme. Il
s’agit du produit des valeurs dans shape. Par exemple :
>>> tableau_1d.size
4
>>> [Link]
6

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.2 NumPy : fondations des calculs numériques 125

Cet attribut est pratique pour évaluer la taille globale d’un tableau, par exemple pour vérifier la
cohérence des données.
L’attribut dtype indique le type de données des éléments du tableau, comme les entiers (int64),
les nombres à virgule flottante (float64) ou d’autres types spécifiques. Le type est déterminé
automatiquement lors de la création du tableau, en fonction des valeurs fournies, mais peut être
spécifié explicitement pour des besoins particuliers. Par exemple :
1 tableau_entiers = [Link]([1, 2, 3])
2 tableau_flottants = [Link]([1.5, 2.7, 3.2])
3 print(tableau_entiers.dtype)
4 print(tableau_flottants.dtype)

>>> tableau_entiers = [Link]([1, 2, 3])

>>> tableau_flottants = [Link]([1.5, 2.7, 3.2])
>>> tableau_entiers.dtype
dtype('int64')
>>> tableau_flottants.dtype
dtype('float64')

Vous pouvez forcer un type spécifique avec l’argument dtype lors de la création du tableau. Par
exemple, pour créer un tableau d’entiers 32 bits :
>>> tableau_int32 = [Link]([1, 9, −8], dtype=np.int32)
>>> tableau_int32.dtype
dtype('int32')

Le choix du dtype est important dans les calculs scientifiques, car il affecte la précision et la
mémoire utilisée. Par exemple, float32 consomme moins de mémoire que float64, mais offre
une précision moindre, ce qui peut être important pour des simulations numériques 3 .
Ces informations vous permettent de comprendre pleinement la structure du tableau et de vous
assurer qu’il est adapté à vos besoins, que ce soit pour des calculs mathématiques ou des analyses
de données.

7.2.2 Opérations sur les tableaux

La bibliothèque NumPy excelle dans la manipulation des tableaux grâce à ses capacités à réaliser des
opérations mathématiques de manière rapide et simple. Ces opérations sont notamment des calculs
arithmétiques, des transformations de structure et des analyses avancées, qui exploitent l’efficacité
des tableaux pour traiter de grandes quantités de données.

[Link] Arithmétique élémentaire et broadcasting

Les opérations arithmétiques dans NumPy, telles que l’addition, la soustraction, la multiplication, la
division et l’exponentiation, sont appliquées élément par élément, c’est-à-dire que chaque élément
d’un tableau est traité individuellement avec l’élément correspondant d’un autre tableau ou avec
une constante. Cette approche, appelée vectorisation, élimine le besoin de boucles explicites et rend
le code à la fois plus concis et beaucoup plus rapide qu’avec des listes Python.
Considérons deux tableaux de même forme, représentant par exemple des mesures de température
à deux moments différents. Pour calculer la différence entre ces mesures, vous pouvez utiliser

3. Documentation officielle de NumPy sur les types de données : [Link]

r/[Link]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

126 Chapitre 7. Bibliothèques scientifiques

l’opérateur − :
>>> temp_matin = [Link]([20.5, 21.0, 19.8])
>>> temp_soir = [Link]([22.5, 23.0, 21.5])
>>> temp_soir − temp_matin
array([2. , 2. , 1.7])

Dans cet exemple, chaque élément de temp_soir est soustrait de l’élément correspondant de
temp_matin. Cette opération élément par élément s’applique à tous les opérateurs arithmétiques
standards :
• Addition (+) : a + b additionne les éléments correspondants.
• Soustraction (−) : a − b soustrait les éléments correspondants.
• Multiplication (*) : a * b multiplie les éléments correspondants.
• Division (/) : a / b divise les éléments correspondants.
• Division entière (//) : a // b effectue la division entière des éléments correspondants.
• Exponentiation (**) : a ** b élève chaque élément à la puissance correspondante.
Par exemple, pour multiplier deux matrices élément par élément :
>>> matrice1 = [Link]([[1, 2], [3, 4]])
>>> matrice2 = [Link]([[5, 6], [7, 8]])
>>> matrice1 * matrice2
array([[ 5, 12],
[21, 32]])

Ici, chaque élément est multiplié individuellement. Notez que cette multiplication élément par
élément diffère du produit matriciel classique qui sera abordé dans la sous-section sur l’algèbre
linéaire.
Note. Les tableaux doivent avoir la même forme (shape) pour les opérations élément par élément.
Si les formes diffèrent, NumPy générera une erreur, sauf si le broadcasting s’applique, comme
expliqué ci-dessous. Vérifiez toujours la propriété shape avant d’effectuer des calculs entre plusieurs
tableaux.
Les opérations élément par élément peuvent également impliquer une constante, appelée scalaire.
Dans ce cas, l’opération est appliquée à chaque élément du tableau. Par exemple, pour augmenter
toutes les températures de 2 degrés :
>>> temp_matin = [Link]([20.5, 21.0, 19.8])
>>> temp_matin + 2
array([22.5, 23. , 21.8])

Cette opération est rendue possible par le mécanisme de broadcasting qui permet à NumPy d’adapter
automatiquement un scalaire ou un tableau de forme différente pour qu’il soit compatible avec un
autre tableau. Le broadcasting est une fonctionnalité puissante, mais parfois complexe, qui mérite
une explication détaillée.
Le broadcasting intervient lorsque deux tableaux de formes différentes sont utilisés dans une
opération arithmétique. NumPy tente d’aligner leurs dimensions en « étendant » le tableau de plus
petite dimension, sans dupliquer physiquement les données en mémoire. Les règles du broadcasting
sont les suivantes :
1. Si les tableaux ont un nombre différent de dimensions, le tableau avec moins de dimensions
est complété par des dimensions de taille 1 à gauche.
2. Les dimensions des deux tableaux sont comparées : elles sont compatibles si elles sont égales

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.2 NumPy : fondations des calculs numériques 127

ou si l’une d’elles est 1.

3. Si une dimension est 1, NumPy répète implicitement les éléments de cette dimension pour
correspondre à l’autre tableau.
Considérons un exemple où l’on souhaite multiplier un vecteur par une matrice. Soit une matrice
2x3 et un vecteur de taille 3 :
>>> matrice = [Link]([[1, 2, 3], [4, 5, 6]])
>>> vecteur = [Link]([10, 20, 30])
>>> matrice * vecteur
array([[ 10, 40, 90],
[ 40, 100, 180]])

Ici, le vecteur de forme (3,) est broadcasté pour correspondre à la forme de la matrice (2, 3).
NumPy interprète le vecteur comme une matrice (1, 3) puis répète implicitement cette ligne pour
obtenir une matrice (2, 3), permettant la multiplication élément par élément. Le calcul peut être
visualisé ainsi :
• Pour la première ligne : [1, 2, 3] * [10, 20, 30] = [10, 40, 90].
• Pour la deuxième ligne : [4, 5, 6] * [10, 20, 30] = [40, 100, 180].
Un autre exemple courant est l’addition d’un scalaire à une matrice, où le scalaire est broadcasté à
toutes les positions :
>>> matrice = [Link]([[1, 2], [3, 4]])
>>> matrice + 10
array([[11, 12],
[13, 14]])

Le scalaire 10 est étendu à une matrice (2, 2) contenant des 10, permettant l’addition élément par
élément. Il en est de même pour les autres opérations (*, /, //, **).
Note. Le broadcasting peut produire des erreurs si les formes ne sont pas compatibles. Par exemple,
multiplier une matrice (2, 3) par un vecteur (2,) générera une erreur, car les dimensions ne
s’alignent pas.

[Link] Manipulation de la structure : redimensionnement, concaténation

Redimensionnement des tableaux Le redimensionnement consiste à modifier la forme

(shape) d’un tableau sans altérer ses données. La fonction reshape est l’outil principal pour cette
tâche : elle réorganise les éléments d’un tableau selon une nouvelle forme spécifiée, à condition
que le nombre total d’éléments soit préservé.
Considérons un tableau à une dimension contenant 6 éléments, que l’on souhaite transformer en
une matrice 2x3 :
>>> tableau = [Link]([1, 2, 3, 4, 5, 6])
>>> matrice = [Link]((2, 3))
>>> print(matrice)
[[1 2 3]
[4 5 6]]

Le tableau initial de forme (6,) est redimensionné en une matrice de forme (2, 3), car 2 * 3 =
[Link] éléments sont disposés ligne par ligne dans la nouvelle structure. Vous pouvez également
redimensionner dans l’autre sens, par exemple pour aplatir une matrice en un vecteur :
>>> matrice = [Link]([[1, 2, 3], [4, 5, 6]])

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

128 Chapitre 7. Bibliothèques scientifiques

>>> vecteur = [Link]((6,))

>>> print(vecteur)
[1 2 3 4 5 6]

Si vous ne connaissez pas la taille exacte d’une dimension, vous pouvez utiliser −1 pour lais-
ser NumPy calculer automatiquement la valeur appropriée, tant que les autres dimensions sont
compatibles. Par exemple :
>>> matrice = [Link]([[1, 2, 3], [4, 5, 6]])
>>> tableau = [Link]((3, −1))
>>> print(tableau)
[[1 2]
[3 4]
[5 6]]

Ici, −1 indique que la deuxième dimension doit être calculée pour préserver les 6 éléments, donnant
une forme (3, 2), car 3 * 2 = 6.
Pour aplatir complètement un tableau multidimensionnel en un vecteur à une dimension, NumPy
propose ravel et flatten. La fonction ravel retourne une vue du tableau aplati, tandis que
flatten crée une copie indépendante. Par exemple :

>>> matrice = [Link]([[1, 2], [3, 4]])

>>> aplati_ravel = [Link]()
>>> aplati_flatten = [Link]()
>>> print(aplati_ravel)
[1 2 3 4]
>>> print(aplati_flatten)
[1 2 3 4]

La différence entre ravel et flatten réside dans la gestion de la mémoire : modifier aplati_ravel
affecte la matrice originale, car il s’agit d’une vue (i.e. une copie par référence), tandis que
aplati_flatten est une copie indépendante.

Note. Lors du redimensionnement, assurez-vous que la nouvelle forme est compatible avec le
nombre total d’éléments (size). Par exemple, redimensionner un tableau de 6 éléments en une
matrice (2, 4) générera une erreur, car 2 * 4 = 8 \neq 6.
Concaténation des tableaux La concaténation permet de combiner plusieurs tableaux pour
former un tableau unique, ce qui est utile pour regrouper des données provenant de différentes
sources, comme des mesures expérimentales effectuées à des moments distincts. NumPy propose
plusieurs fonctions pour cela, notamment concatenate, hstack et vstack, chacune adaptée à des
cas spécifiques.
La fonction concatenate ou concatcombine des tableaux le long d’un axe existant, spécifié par le
paramètre axis. Considérons deux matrices 2x2 que nous souhaitons concaténer horizontalement
(le long de l’axe des colonnes, axis=1) :
>>> matrice1 = [Link]([[1, 2], [3, 4]])
>>> matrice2 = [Link]([[5, 6], [7, 8]])
>>> concat_horizontal = [Link]((matrice1, matrice2), axis=1)
>>> print(concat_horizontal)
[[1 2 5 6]
[3 4 7 8]]

Pour une concaténation verticale (le long de l’axe des lignes, axis=0) :

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.2 NumPy : fondations des calculs numériques 129

>>> concat_vertical = [Link]((matrice1, matrice2), axis=0)

>>> print(concat_vertical)
[[1 2]
[3 4]
[5 6]
[7 8]]

Les fonctions hstack (concaténation horizontale) et vstack (concaténation verticale) sont des rac-
courcis pour concatenate avec axis=1 et axis=0, respectivement, mais elles s’adaptent automati-
quement aux dimensions des tableaux. Par exemple, pour concaténer deux vecteurs horizontalement
ou verticalement :
>>> vecteur1 = [Link]([1, 2])
>>> vecteur2 = [Link]([3, 4])
>>> hstack_result = [Link]((vecteur1, vecteur2))
>>> print(hstack_result)
[1 2 3 4]
>>> vstack_result = [Link]((vecteur1, vecteur2))
>>> print(vstack_result)
[[1 2]
[3 4]]

Note. Pour la concaténation, les tableaux doivent avoir des dimensions compatibles le long des
axes non concernés. Pour une concaténation horizontale, le nombre de lignes doit être identique ; et
pour une concaténation verticale, le nombre de colonnes doit être identique.

7.2.3 Indexation et slicing : accès aux éléments des tableaux

[Link] Indexation simple et avancée

L’indexation permet d’accéder à un élément spécifique ou à un ensemble d’éléments dans un

tableau, en utilisant des indices qui correspondent aux positions des éléments. Pour un tableau
ndarray, les indices sont spécifiés entre crochets ([]) et leur fonctionnement dépend du nombre de
dimensions du tableau.
Indexation simple Pour un tableau à une dimension, l’indexation est similaire à celle des listes
Python : un entier indique la position de l’élément, en commençant par 0.
Soit un tableau représentant des mesures de température :
>>> temperatures = [Link]([20.5, 21.0, 19.8, 22.3])
>>> print(temperatures[1])
21.0

Ici, temperatures[1] retourne le deuxième élément, 21.0. Les indices négatifs permettent d’accé-
der aux éléments en partant de la fin : temperatures[−1] retourne 22.3, le dernier élément.
Pour une matrice (tableau à deux dimensions), l’indexation utilise deux indices séparés par une
virgule : le premier pour la ligne, le second pour la colonne. Par exemple, pour une matrice 2x3 :
>>> matrice = [Link]([[1, 2, 3], [4, 5, 6]])
>>> print(matrice[1, 2])
6

Ici, matrice[1, 2] accède à l’élément de la deuxième ligne (indice 1) et de la troisième colonne

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 130 Chapitre 7. Bibliothèques scientifiques

(indice 2). Vous pouvez également utiliser des indices négatifs, comme matrice[−1, −1] pour
obtenir le même élément (6). La syntaxe a[i, j] renvoie donc l’élément à la ligne d’indice i et à
la colonne d’indice j.
Indexation avancée L’indexation avancée, également appelée indexation par tableaux ou indexa-
tion sophistiquée, permet d’accéder à plusieurs éléments simultanément en utilisant des listes ou
des tableaux d’indices. Cette technique est puissante pour extraire des sous-ensembles spécifiques.
Par exemple, pour extraire les première et troisième températures :
>>> temperatures = [Link]([20.5, 21.0, 19.8, 22.3])
>>> indices = [0, 2]
>>> selection = temperatures[indices]
>>> print(selection)
[20.5 19.8]

Pour une matrice, vous pouvez spécifier des listes d’indices pour les lignes et les colonnes. Par
exemple, pour extraire les éléments aux positions (0,1) et (-1,2) :
>>> matrice = [Link]([[1, 2, 3], [4, 5, 6]])
>>> elements = matrice[[0, −1], [1, 2]]
>>> print(elements)
[2 6]

Ici, matrice[[0, 1], [−1, 2]] sélectionne les éléments matrice[0, 1] et matrice[−1, 2].
Cette forme d’indexation est utile pour extraire des données non contiguës, comme des points
spécifiques dans un ensemble de mesures.
Notes.

• Lors de l’indexation avancée, assurez-vous que les listes d’indices ont la même longueur
pour les dimensions correspondantes. Par exemple, matrice[[0, 1], [0]] générera une
erreur, car les listes [0, 1] et [0] n’ont pas la même taille.
• Avec deux tableaux A et B, matrice[A, B] retourne un tableau avec les éléments aux posi-
tions matrice[A[0], B[0]], matrice[A[1], B[1]], etc.

[Link] Slicing et modification partielle

Le slicing (ou découpage) permet d’extraire des sous-tableaux en spécifiant des plages d’indices,
de manière similaire aux listes Python, mais avec une syntaxe plus puissante pour les tableaux
multidimensionnels. La syntaxe générale est [début:fin:pas], où début est l’indice de départ
(inclus), fin l’indice de fin (exclus) et pas l’intervalle entre les éléments. Si ces valeurs sont omises,
NumPy utilise des valeurs par défaut : 0 pour début, la fin du tableau pour fin et 1 pour pas.

Pour un tableau à une dimension, extraire les deux premiers éléments :

>>> temperatures = [Link]([20.5, 21.0, 19.8, 22.3])
>>> print(temperatures[0:2])
[20.5 21. ]

Pour extraire tous les éléments avec un pas de 2 :

>>> print(temperatures[::2])
[20.5 19.8]

Dans une matrice, le slicing s’applique à chaque dimension. Par exemple, pour extraire la première

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

7.2 NumPy : fondations des calculs numériques 131

ligne d’une matrice :

>>> matrice = [Link]([[1, 2, 3], [4, 5, 6]])
>>> premiere_ligne = matrice[0, :]
>>> print(premiere_ligne)
[1 2 3]

Ici, : signifie « tous les éléments » pour la dimension des colonnes. La syntaxe a[i, :] renvoie la
ligne d’indice i et a[: ,j] renvoie la colonne d’indice j.
Pour extraire une sous-matrice des deux premières lignes et des deux premières colonnes :
>>> sous_matrice = matrice[0:2, 0:2]
>>> print(sous_matrice)
[[1 2]
[4 5]]

Le slicing permet également de modifier des parties d’un tableau, car les sous-tableaux extraits
par slicing sont des vues du tableau original et non des copies. Cela signifie que modifier un
sous-tableau affecte le tableau d’origine. Par exemple, pour augmenter de 10 la première colonne
d’une matrice :
>>> matrice[:, 0] = matrice[:, 0] + 10
>>> print(matrice)
[[11 2 3]
[14 5 6]]

Cette modification est directe et efficace, mais elle nécessite de la prudence pour éviter des
changements involontaires.
Note. Comme pour les listes, nous attirons votre attention sur la copie de arrays (tableaux). Par
défaut la copie d’arrays se fait par référence, comme pour tous les conteneurs en Python (listes,
tuples, dictionnaires, etc.). Afin d’éviter le problème, vous pouvez soit utiliser la fonction np.
array(), qui crée une nouvelle copie distincte de l’array initial, soit la fonction [Link](),
comme pour les listes.
>>> a = [Link]((2, 2), int)
>>> print(a)
[[0 0]
[0 0]]
>>> b = [Link](a)
>>> b[1, 1] = 100
>>> print(b)
[[ 0 0]
[ 0 100]]
>>> import copy
>>> c = [Link](a)
>>> c[1, 1] = 200
>>> print(c)
[[ 0 0]
[ 0 200]]
>>> print(a)
[[0 0]
[0 0]]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 132 Chapitre 7. Bibliothèques scientifiques

[Link] Masques logiques pour le filtrage

Les masques logiques permettent de filtrer les éléments d’un tableau en fonction de conditions
booléennes, une technique utile pour analyser des données, comme extraire des valeurs dépassant
un seuil. Un masque logique est un tableau de même forme que le tableau d’origine, contenant des
valeurs True ou False selon qu’une condition est satisfaite.
Soit un tableau de températures et une condition pour identifier les valeurs supérieures à 20 degrés :
>>> temperatures = [Link]([20.5, 19.5, 21.0, 19.8, 22.3])
>>> masque = temperatures > 20
>>> print(masque)
[ True False True False True]

Le masque masque contient True pour les éléments satisfaisant la condition temperatures > 20
et False sinon. Vous pouvez utiliser ce masque pour extraire les éléments correspondants :
>>> temp_chaudes = temperatures[masque]
>>> print(temp_chaudes)
[20.5 21. 22.3]

Les masques logiques peuvent être combinés avec des opérateurs logiques comme & (ET), | (OU) et
~(NON). Par exemple, pour sélectionner les températures entre 20 et 21 degrés :
>>> masque = (temperatures >= 20) & (temperatures <= 21)
>>> print(temperatures[masque])
[20.5 21. ]

Notez que les opérateurs logiques and, or et not ne s’appliquent pas sur les arrays.
Les masques logiques permettent également de modifier les éléments sélectionnés. Par exemple,
pour remplacer les températures supérieures à 20 par 20 :
>>> temperatures[temperatures > 20] = 20
>>> print(temperatures)
[20. 19.5 20. 19.8 20. ]

Cette approche est courante dans le traitement des données pour limiter des valeurs aberrantes ou
normaliser des ensembles de données.
Note. Lors de l’utilisation de masques logiques, assurez-vous que les conditions produisent un
tableau booléen de forme compatible. Par ailleurs, placez les conditions combinées entre parenthèses
pour éviter des erreurs de priorité d’opérateurs, comme (condition1) & (condition2).

7.2.4 Fonctions universelles : opérations mathématiques vectorisées

Dans les calculs scientifiques, il est fréquent d’appliquer des opérations mathématiques complexes,
comme des sinus, des exponentielles ou des arrondis, à de grands ensembles de données. La
bibliothèque NumPy propose des fonctions universelles, également appelées ufuncs (pour universal
functions), qui permettent d’effectuer ces opérations de manière vectorisée, c’est-à-dire simulta-
nément sur tous les éléments d’un tableau ndarray sans avoir besoin de boucles explicites. Cette
approche, qui repose sur le principe des opérations élément par élément, combine simplicité et
efficacité et rend les calculs rapides et le code plus lisible.
Une fonction universelle prend ainsi un tableau en entrée et applique une opération mathématique à

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.2 NumPy : fondations des calculs numériques 133

chaque élément en produisant un nouveau tableau de même forme. Par exemple, la fonction sin
calcule le sinus de chaque élément, ce qui est utile pour analyser des données périodiques, comme
des signaux ou des oscillations. Considérons un tableau représentant des angles en radians :
>>> angles = [Link]([0, [Link]/2, [Link], 3*[Link]/2])
>>> print([Link](angles))
[ 0.0000000e+00 1.0000000e+00 1.2246468e−16 −1.0000000e+00]

Dans cet exemple, [Link] applique la fonction sinus à chaque élément de angles et produit un
tableau où sinus[0] = sin(0) = 0, sinus[1] = sin(π /2) = 1, et ainsi de suite. Le résultat
1.2246468e−16 pour sin(π ) est pratiquement nul, reflétant une approximation numérique due à
la précision des flottants.
NumPy fournit une large gamme de fonctions universelles, couvrant diverses catégories mathéma-
tiques. Vous trouverez la liste complètes dans la documentation officielle de NumPy sur les ufuncs 4 .
Voici les principales catégories avec des exemples représentatifs :
• Fonctions trigonométriques et hyperboliques : sin, cos, tan, arcsin, arccos, arctan,
deg2rad, rad2deg, sinh, cosh, tanh, arcsinh, arccosh, arctanh, etc. Ces fonctions sont
utiles pour analyser des données périodiques ou géométriques. Par exemple, pour convertir
les angles d’un tableau de radians en degrés :
>>> print(np.rad2deg(angles))
[ 0. 90. 180. 270.]

• Fonctions exponentielles et logarithmiques : exp, log, log10, sqrt. Ces fonctions sont
essentielles pour modéliser des phénomènes de croissance ou pour normaliser des données.
Par exemple, pour calculer la racine carrée d’un tableau de distances :
>>> distances = [Link]([4, 9, 16, 25])
>>> print([Link](distances))
[2. 3. 4. 5.]

• Fonctions d’arrondi : round, floor, ceil. Ces fonctions permettent d’ajuster les valeurs
pour simplifier les analyses ou les affichages. Par exemple, pour arrondir des mesures à
l’entier inférieur :
>>> mesures = [Link]([2.7, 3.2, 4.8, 5.1])
>>> print([Link](mesures))
[2. 3. 4. 5.]

Les fonctions universelles sont vectorisées, ce qui signifie qu’elles exploitent l’efficacité des
opérations élément par élément, comme les opérations arithmétiques vues précédemment. Cette
vectorisation élimine le besoin de boucles, rendant le code plus clair et plus performant.
Note. Certaines fonctions universelles, comme log ou sqrt, ne sont définies que pour des valeurs
valides (par exemple, log exige des valeurs positives). Appliquer [Link] à un tableau contenant
des valeurs négatives ou nulles générera une erreur ou des valeurs nan (not a number).

7.2.5 Algèbre linéaire et statistiques

Les calculs scientifiques reposent souvent sur des outils mathématiques avancés pour modéliser
des systèmes complexes ou analyser des ensembles de données. La bibliothèque NumPy offre des

4. [Link]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 134 Chapitre 7. Bibliothèques scientifiques

fonctionnalités puissantes à travers son module d’algèbre linéaire ([Link]) pour manipuler
des matrices et résoudre des problèmes linéaires, ainsi que des fonctions statistiques pour résumer
des données. De plus, le module [Link] permet de générer des données aléatoires, utiles
pour des simulations ou des tests.

[Link] Algèbre linéaire : produits, inverses et systèmes linéaires

L’algèbre linéaire est un pilier des sciences appliquées, permettant de représenter des relations
entre variables à l’aide de matrices et de vecteurs. Le module [Link] propose des fonctions
optimisées pour effectuer des opérations comme le produit matriciel, la transposition, le calcul du
déterminant, l’inversion de matrices, la détermination des valeurs et vecteurs propres et la résolution
de systèmes linéaires.
Le tableau suivant récapitule les principales fonctions d’algèbre linéaire utilisées dans cette section :

TABLE 7.1 – Quelques fonctions d’algèbre linéaire

Fonction Description
[Link](a, b) Calcule le produit matriciel ou scalaire entre a et b.
[Link](a, b) Effectue le produit matriciel entre a et b, recom-
mandé pour les matrices.
[Link](a) Retourne la transposée de la matrice a.
[Link](a) Calcule le déterminant de la matrice carrée a.
[Link](a) Calcule l’inverse de la matrice carrée non singulière
a.
[Link](a) Retourne les valeurs propres et vecteurs propres de
la matrice carrée a.
[Link](a, b) Résout le système linéaire ax = b, où a est une ma-
trice et b un vecteur.

Produit matriciel : Pour deux matrices A de forme (m, n) et B de forme (n, p), leur produit
matriciel est une matrice de forme (m, p). NumPy propose dot et matmul, matmul étant préféré
pour les matrices à deux dimensions.
Considérons deux matrices 2x2 :
>>> A = [Link]([[1, 2], [3, 4]])
>>> B = [Link]([[5, 6], [7, 8]])
>>> produit = [Link](A, B)
>>> print(produit)
[[19 22]
[43 50]]

Chaque élément du résultat est une somme de produits : par exemple, produit[0,0] = 1*5 +
2*7 = 19. Pour un produit matrice-vecteur ou un produit scalaire :
>>> vecteur = [Link]([5, 9])
>>> print(([Link](A, vecteur)))
[23 51]
>>> print([Link](vecteur, vecteur))
106

Note. Le produit matriciel exige que le nombre de colonnes de A corresponde au nombre de lignes
de B.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

7.2 NumPy : fondations des calculs numériques 135

Transposée : La transposée d’une matrice A, notée AT , est obtenue en échangeant ses lignes et ses
colonnes : l’élément Ai j devient ATji . NumPy propose la fonction transpose ou l’attribut T :
>>> A = [Link]([[1, 2, 3], [4, 5, 6]])
>>> print([Link](A))
[[1 4]
[2 5]
[3 6]]
>>> print(A.T)
[[1 4]
[2 5]
[3 6]]

Déterminant : Le déterminant d’une matrice carrée est une valeur scalaire qui indique si la matrice
est inversible (déterminant non nul) ou caractérise des propriétés géométriques, comme le facteur
d’échelle d’une transformation. La fonction [Link] calcule le déterminant :
>>> A = [Link]([[1, 2], [3, 4]])
>>> det_A = [Link](A)
>>> print(det_A)
−2.0000000000000004

 
a b
Pour une matrice 2x2 , le déterminant est a*d − b*c, soit 1*4 − 2*3 = −2. Le résultat est
c d
légèrement inexact en raison de la précision des flottants, mais il est fonctionnellement correct.

Inverses de matrices : L’inverse d’une matrice carrée A est une matrice A_inv telle que A * A_inv
= I, où I est la matrice identité. L’inverse est utilisé pour résoudre des systèmes linéaires ou
inverser des transformations. La fonction [Link] calcule cet inverse :
>>> A = [Link]([[1, 2], [3, 4]])
>>> A_inv = [Link](A)
>>> print(A_inv)
[[−2. 1. ]
[ 1.5 −0.5]]

Vérifiez l’inverse en calculant A * A_inv :

>>> print([Link](A, A_inv))
[[1.0000000e+00 0.0000000e+00]
[8.8817842e−16 1.0000000e+00]]

Vecteurs propres et valeurs propres : Les valeurs propres (λ ) et vecteurs propres (v) d’une
matrice carrée A satisfont A.v = λ .v. La fonction [Link] retourne un tuple contenant les
valeurs propres et les vecteurs propres :
>>> A = [Link]([[1, 2], [2, 1]])
>>> valeurs_propres, vecteurs_propres = [Link](A)
>>> print(valeurs_propres)
[ 3. −1.]
>>> print(vecteurs_propres)
[[ 0.70710678 −0.70710678]
[ 0.70710678 0.70710678]]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 136 Chapitre 7. Bibliothèques scientifiques

Chaque colonne de vecteurs_propres est un vecteur propre associé à la valeur propre correspon-
dante. Par exemple, le premier vecteur propre [0.707, 0.707] correspond à λ = 3.

Systèmes linéaires : Un système d’équations linéaires ax = b peut être résolu avec [Link]
qui est plus efficace que l’inversion explicite. Pour le système :

(
x + 2y = 5
3x + 4y = 11

>>> A = [Link]([[1, 2], [3, 4]])

>>> b = [Link]([5, 11])
>>> x = [Link](A, b)
>>> print(x)
[1. 2.]

Le résultat [1, 2] indique x1 = 1, x2 = 2.

[Link] Statistiques : moyenne, écart-type et autres mesures

Les analyses statistiques permettent de résumer et d’interpréter des ensembles de données, comme
des mesures expérimentales ou des observations. NumPy offre des fonctions intégrées pour calculer
des mesures statistiques courantes, telles que la moyenne, l’écart-type, la médiane et d’autres,
appliquées directement aux tableaux ndarray. Ces fonctions sont vectorisées, ce qui les rend
rapides et faciles à utiliser.
Soit un tableau représentant des mesures de température :
1 temperatures = [Link]([20.5, 21.0, 19.8, 22.3, 20.1])

Moyenne : La fonction mean calcule la moyenne arithmétique des éléments :

>>> print([Link](temperatures))
20.74

Écart-type : La fonction std mesure la dispersion des données par rapport à la moyenne :
>>> print([Link](temperatures))
0.8777243302996675

Médiane : La fonction median retourne la valeur centrale après tri des données, utile pour des
données avec des valeurs aberrantes :
>>> print([Link](temperatures))
20.5

Minimum et maximum : Les fonctions min et max identifient les valeurs extrêmes :
>>> minimum = [Link](temperatures)
>>> maximum = [Link](temperatures)
>>> print(minimum, maximum)
19.8 22.3

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.2 NumPy : fondations des calculs numériques 137

Somme : La fonction sum additionne tous les éléments :

>>> print([Link](temperatures))
103.69999999999999

Ces fonctions peuvent être appliquées à des matrices, soit sur l’ensemble des éléments, soit le long
d’un axe spécifique. Par exemple, pour calculer la moyenne de chaque colonne ou de chaque ligne
d’une matrice :
>>> matrice = [Link]([[1, 2, 3], [4, 5, 6]])
>>> moyennes_colonnes = [Link](matrice, axis=0)
>>> print(moyennes_colonnes)
[2.5 3.5 4.5]
>>> moyennes_lignes = [Link](matrice, axis=1)
>>> print(moyennes_lignes)
[2. 5.]

Note. Lors de l’utilisation de fonctions statistiques sur des matrices, spécifiez l’axe (axis) si vous
voulez des résultats par ligne ou colonne. Sans axis, NumPy applique l’opération à tous les éléments,
ce qui peut ne pas correspondre à votre intention. Dans l’exemple précédent, si l’axe n’était pas
spécifié, on aurait eu :
>>> print([Link](matrice))
3.5

[Link] Génération de nombres aléatoires

Le module [Link] permet de générer des nombres aléatoires, une fonctionnalité essentielle
pour des simulations, des tests statistiques ou la création de données synthétiques. Elles sont utiles
pour modéliser des phénomènes aléatoires, comme le bruit dans des mesures ou la variabilité dans
des expériences.
Les fonctions de [Link] se divisent en deux catégories : les générateurs simples qui
produisent des nombres aléatoires selon des distributions uniformes ou normales et les fonctions de
distributions statistiques qui modélisent des processus spécifiques. Pour garantir la reproductibilité
des résultats, vous pouvez fixer une graine aléatoire avec [Link] :
1 [Link](42)

Le tableau suivant récapitule les principales fonctions de génération aléatoire et les distributions
statistiques disponibles dans [Link] :

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

138 Chapitre 7. Bibliothèques scientifiques

TABLE 7.2 – Fonctions de génération aléatoire et les distributions statistiques

Fonction Description
rand(d0, d1, ..., dN) Génère un tableau, de dimension (d0, d1, ...,
dN), de nombres aléatoires uniformément distribués
entre 0 et 1.
randn(d0, d1, ..., dN) Génère un tableau, de dimension (d0, d1, ...,
dN), de nombres suivant une distribution normale
standard (moyenne 0, écart-type 1).
randint(low, high, size) Génère des entiers aléatoires entre low (inclus) et
high (exclus).
choice(a, size, replace) Sélectionne size éléments aléatoires dans a, avec ou
sans remplacement. Par défaut, replace=True.
uniform(low, high, size) Génère des nombres suivant une distribution uni-
forme entre low et high. Par défaut, low=0.0 et high
=1.0.
normal(loc, scale, size) Génère des nombres suivant une distribution normale
avec moyenne loc et écart-type scale. Par défaut,
loc=0.0 et scale=1.0.
poisson(lam, size) Génère des nombres suivant une distribution de Pois-
son avec paramètre lam (taux moyen d’événements).
Par défaut, lam=1.0.
binomial(n, p, size) Génère des nombres suivant une distribution bino-
miale avec n essais et probabilité p.
exponential(scale, size) Génère des nombres suivant une distribution expo-
nentielle avec échelle scale (inverse du taux). Par
défaut, scale=1.0.

Voici quelques exemples d’utilisation. Pour générer un tableau 2x3 de nombres aléatoires uniformes
entre 0 et 1 :
>>> print([Link](2, 3))
[[0.37454012 0.95071431 0.73199394]
[0.59865848 0.15601864 0.15599452]]

Pour générer 5 entiers aléatoires entre 1 et 10 :

>>> print([Link](1, 11, size=5))
[7 4 8 5 7]

Pour simuler des données suivant une distribution normale avec une moyenne de 10 et un écart-type
de 2 :
>>> print([Link](loc=10, scale=2, size=4))
[10.99342831 9.7234714 11.29537708 13.04605971]

Pour modéliser le nombre d’événements dans un processus de Poisson (comme le nombre d’appels
reçus par un centre d’appels en une heure, avec un taux moyen de 5) :
>>> print([Link](lam=5, size=3))
[5 4 4]

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.3 Matplotlib : visualisation des données scientifiques 139

Note. La génération de nombres aléatoires dépend de la graine aléatoire. Sans [Link],

les résultats varient à chaque exécution, ce qui peut compliquer la reproductibilité. Fixez une graine
pour des résultats cohérents, surtout lors de tests ou de comparaisons.

7.3 Matplotlib : visualisation des données scientifiques

La visualisation des données est une étape clé dans l’analyse scientifique, permettant de transformer
des nombres bruts en graphiques clairs et compréhensibles. La bibliothèque Matplotlib est l’outil
de référence en Python pour créer des visualisations variées, allant de simples courbes à des
graphiques complexes avec plusieurs sous-figures. Conçue pour travailler en harmonie avec NumPy
, elle utilise les tableaux ndarray pour représenter les données à tracer. En tant qu’étudiants
débutants, vous découvrirez dans cette section comment produire des graphiques professionnels
pour illustrer vos résultats, que ce soit pour analyser des mesures expérimentales ou modéliser des
phénomènes mathématiques. Les concepts seront abordés progressivement, en commençant par les
bases nécessaires pour créer et comprendre un graphique.

7.3.1 Concepts de base : premiers pas avec Matplotlib

Pour débuter avec Matplotlib, il est essentiel de comprendre ses outils fondamentaux et de savoir
configurer un environnement de tracé. Cette sous-section vous guide à travers les premières étapes,
depuis l’importation de la bibliothèque jusqu’à la création de votre premier graphique, en mettant
l’accent sur la simplicité et l’intuitivité.

[Link] Introduction à Matplotlib et à Pyplot

Matplotlib est une bibliothèque open-source puissante pour la visualisation de données en Python,
largement utilisée dans les domaines scientifiques et techniques 5 . Elle permet de créer des gra-
phiques variés, tels que des courbes, des diagrammes de dispersion, des histogrammes, et bien plus
encore. Le module pyplot, inclus dans Matplotlib, est l’interface principale pour les utilisateurs
débutants, car il offre une syntaxe simple et intuitive inspirée des commandes de tracé de MATLAB.
Pour utiliser Matplotlib, vous devez d’abord l’importer, généralement avec NumPy pour manipuler
les données. Une convention courante est d’importer pyplot sous l’alias plt :
1 import numpy as np
2 import [Link] as plt

Le module pyplot fournit des fonctions comme plot, scatter ou show qui permettent de tracer
des données et d’afficher les graphiques. Par exemple, la fonction plot crée une courbe en reliant
des points, tandis que show affiche la figure à l’écran. Dans un environnement interactif, comme
Jupyter Notebook, l’affichage peut être automatique, mais dans un script Python, [Link]() est
souvent nécessaire.
Pour préparer un tracé, vous commencez généralement par générer des données avec NumPy. Par
exemple, pour créer un tableau de points représentant une fonction linéaire y = 2x + 1, vous pouvez
utiliser [Link] pour générer des valeurs de x :
1 x = [Link](0, 10, 100) # 100 points de 0 à 10
2 y = 2 * x + 1

Ces données seront ensuite utilisées pour tracer un graphique. Matplotlib est conçu pour être

5. Documentation officielle de Matplotlib : [Link]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 140 Chapitre 7. Bibliothèques scientifiques

flexible : vous pouvez travailler dans un style procédural (en appelant des fonctions de pyplot) ou
orienté objet (en manipulant directement les objets Figure et Axes), ce dernier étant introduit plus
loin.
Note. Assurez-vous que Matplotlib est installé dans votre environnement Python. Si ce n’est
pas le cas, vous pouvez l’installer avec la commande pip install matplotlib dans un terminal
avant d’exécuter votre code.

[Link] Création d’un graphique simple

Créer un graphique simple avec Matplotlib est une tâche très accessible. L’objectif est de tracer
une courbe à partir de données, comme une fonction mathématique ou une série de mesures en
utilisant pyplot.
Supposons qu’on a mesuré des températures à différents moments. On peut utiliser un tracé linéaire
pour observer leur évolution :
1 import numpy as np
2 import [Link] as plt
3
4 temps = [Link]([0, 1, 2, 3, 4])
5 temperatures = [Link]([20.5, 21.0, 20.8, 22.0, 21.5])
6 [Link](temps, temperatures)
7 [Link]()

22.0
21.8
21.6
21.4
21.2
21.0
20.8
20.6

0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0

F IGURE 7.1 – Évolution de la température

Pour un autre exemple, traçons la fonction sinus y = sin(x).

1 import numpy as np
2 import [Link] as plt
3
4 x = [Link](0, 2 * [Link], 100) # 100 points de 0 à 2*pi
5 y = [Link](x)
6 [Link](x, y)

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.3 Matplotlib : visualisation des données scientifiques 141

7 [Link]()

22.0
21.8
21.6
21.4
21.2
21.0
20.8
20.6

0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0

F IGURE 7.2 – Tracé de la fonction sinus

Note. Les données passées à [Link] doivent avoir des formes compatibles. Par exemple, x et y
doivent avoir la même longueur (même nombre d’éléments).

[Link] Structure d’une figure : figure, axes et tracés

Un graphique Matplotlib est plus qu’une simple courbe : il est composé d’objets hiérarchiques qui
définissent son apparence et son organisation. Comprendre cette structure est essentiel pour maîtriser
Matplotlib, surtout lorsque vous souhaiterez créer des visualisations complexes. Imaginez un
graphique comme une peinture : la toile est la figure, le cadre délimite la zone de dessin (les axes),
et les lignes ou points sont les tracés. Cette sous-sous-section détaille ces composants : Figure,
Axes, et Plot.

• Figure : La Figure est l’objet global qui contient l’ensemble du graphique, comme une
toile vierge. Elle est créée explicitement avec [Link]() ou implicitement par [Link].
Vous pouvez spécifier sa taille avec le paramètre figsize (en pouces).
• Axes : Un objet Axes (à ne pas confondre avec les axes x et y) est une zone de la figure où les
données sont tracées, comme un cadre contenant une courbe ou un diagramme. Une figure
peut contenir plusieurs Axes (par exemple, pour des sous-graphiques). Chaque Axes a ses
propres axes x et y, étiquettes et tracés.
• Plot : Le Plot désigne les éléments visuels, comme des lignes, des points ou des barres,
tracés dans un Axes. Il est créé avec des fonctions comme plot ou scatter.
Pour illustrer, considérons un graphique simple créé en style orienté objet, qui rend la structure
explicite :
1 import numpy as np
2 import [Link] as plt
3
4 # Création de la figure

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 142 Chapitre 7. Bibliothèques scientifiques

5 fig = [Link](figsize=(6, 4))

6
7 # Ajout d'un Axes
8 ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # [gauche, bas, largeur, hauteur]
9
10 # Données
11 temps = [Link]([0, 1, 2, 3, 4])
12 temperatures = [Link]([20.5, 21.0, 20.8, 22.0, 21.5])
13
14 # Tracé dans l'Axes
15 [Link](temps, temperatures)
16
17 # Affichage
18 [Link]()

22.0
21.8
21.6
21.4
21.2
21.0
20.8
20.6

0.0 0.5 1.0 1.5 2.0 2.5 3.0 3.5 4.0

F IGURE 7.3 – Tracé avec Figure et Axes

On obtient un graphique similaire à celui de la section précédente, mais en contrôlant explicitement

la Figure et l’Axes. La méthode add_axes positionne l’Axes dans la figure avec des coordonnées
normalisées (0 à 1). Le résultat est un tracé dans une zone rectangulaire occupant 80% de la figure,
avec des marges de 10%.
En pratique, pyplot gère souvent la Figure et l’Axes automatiquement. Par exemple, [Link](x,
y) crée une Figure et un Axes implicites puis ajoute le tracé. Cependant, comprendre la structure
explicite est utile pour des personnalisations avancées, comme l’ajout de plusieurs sous-graphiques.
Note. Ne confondez pas Axes (la zone de tracé) avec les axes x et y (les lignes graduées). Une
Figure peut contenir plusieurs Axes, chacun avec ses propres axes x et y.

7.3.2 Personnalisation des graphiques

Un graphique efficace ne se contente pas de représenter des données : il doit être clair, attrayant
et facile à interpréter. Matplotlib offre une grande flexibilité pour personnaliser l’apparence des
graphiques, en ajustant les styles visuels, en ajoutant des annotations et en contrôlant les échelles
des axes. Ces techniques vous permettront de produire des visualisations adaptées à vos besoins,
pour présenter des résultats expérimentaux.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.3 Matplotlib : visualisation des données scientifiques 143

[Link] Modification des styles : couleurs, marqueurs, lignes

Lors de la création d’un graphique avec [Link], Matplotlib applique des styles par défaut,
comme une ligne bleue continue. Cependant, vous pouvez personnaliser ces styles pour améliorer
la lisibilité ou distinguer plusieurs tracés. Les principaux paramètres de style sont les couleurs, les
types de lignes et les marqueurs, qui sont spécifiés dans la fonction plot via des arguments comme
color, linestyle et marker.

Couleurs : Les couleurs peuvent être définies par des noms (par exemple, blue, red, green), des
codes hexadécimaux (par exemple, #FF0000 pour le rouge) ou des abréviations (par exemple, b
pour bleu, r pour rouge). Par exemple, pour tracer une droite rouge :
1 import numpy as np
2 import [Link] as plt
3
4 x = [Link](0, 10, 10)
5 y = 2 * x + 1
6 [Link](x, y, color='red')
7 [Link]()

Ce code génère une droite rouge reliant les points (xi , yi ). Vous pouvez également utiliser c comme
alias pour color, par exemple, c='r'.

20.0
17.5
15.0
12.5
10.0
7.5
5.0
2.5
0.0
0 2 4 6 8 10

F IGURE 7.4 – Droite linéaire y = 2x + 1 tracée en rouge.

Types de lignes : Le paramètre linestyle contrôle l’apparence de la ligne : continue (−), pointillée
(−−), tirets-points (−.) ou points (:). Par exemple, pour une ligne pointillée :
1 import numpy as np
2 import [Link] as plt
3
4 x = [Link](0, 10, 10)
5 y = 2 * x + 1
6 [Link](x, y, linestyle='−−', color='blue')
7 [Link]()

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

144 Chapitre 7. Bibliothèques scientifiques

Ce graphique affiche la même droite, mais avec une ligne bleue pointillée, rendant le tracé visuelle-
ment distinct.

20.0
17.5
15.0
12.5
10.0
7.5
5.0
2.5
0.0
0 2 4 6 8 10

F IGURE 7.5 – Droite linéaire y = 2x + 1 tracée avec une ligne bleue pointillée.

Marqueurs : Les marqueurs permettent d’afficher les points de données individuels, utiles pour les
diagrammes de dispersion ou pour mettre en évidence des points spécifiques sur une courbe. Les
options sont des cercles (o), des carrés (s), des triangles (^) ou des étoiles (*). Par exemple, pour
ajouter des marqueurs circulaires :
1 import numpy as np
2 import [Link] as plt
3
4 x = [Link](0, 10, 20)
5 y = 2 * x + 1
6 [Link](x, y, marker='o', linestyle='−', color='green')
7 [Link]()

Ce code trace une droite verte continue, avec un cercle vert à chaque point de donnée.
Pour un graphique de dispersion sans lignes, omettez linestyle ou utilisez linestyle='' :
1 x = [Link]([1, 2, 3, 4])
2 y = [Link]([2, 4, 1, 5])
3 [Link](x, y, marker='s', linestyle='', color='purple')
4 [Link]()

Ce graphique affiche quatre carrés violets aux coordonnées (1, 2), (2, 4), (3, 1), et (4, 5), sans lignes
de connexion.
Vous pouvez combiner ces options dans une chaîne de formatage concise. Par exemple, 'r−−o'
signifie une ligne rouge pointillée avec des marqueurs circulaires :
1 x = [Link](0, 10, 20) # Moins de points pour voir les marqueurs
2 y = [Link](x)

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

7.3 Matplotlib : visualisation des données scientifiques 145

20.0
17.5
15.0
12.5
10.0
7.5
5.0
2.5
0.0
0 2 4 6 8 10

F IGURE 7.6 – Droite linéaire y = 2x + 1 tracée en vert avec des marqueurs circulaires.

5.0
4.5
4.0
3.5
3.0
2.5
2.0
1.5
1.0
1.0 1.5 2.0 2.5 3.0 3.5 4.0

F IGURE 7.7 – Diagramme de dispersion avec des marqueurs carrés violets.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 146 Chapitre 7. Bibliothèques scientifiques

3 [Link](x, y, 'r−−o')
4 [Link]()

Ce code produit une courbe sinusoidale rouge pointillée, avec des cercles rouges aux 20 points de
donnée, oscillant entre −1 et 1.

1.00
0.75
0.50
0.25
0.00
0.25
0.50
0.75
1.00
0 2 4 6 8 10

F IGURE 7.8 – Courbe sinusoidale tracée en rouge pointillé avec des marqueurs circulaires.

Note. Lorsque vous utilisez des marqueurs, choisissez un nombre raisonnable de points avec
[Link] (par exemple, 20 au lieu de 100) pour éviter que les marqueurs ne se chevauchent,
rendant le graphique illisible.
Ces options de style vous permettent de différencier les tracés, par exemple, pour comparer plusieurs
courbes dans un même graphique.

[Link] Ajout de labels, titres et légendes

Un graphique doit inclure des annotations pour expliquer son contenu et faciliter son interprétation.
Matplotlib permet d’ajouter des étiquettes aux axes (xlabel, ylabel), un titre (title), et une lé-
gende (legend) pour identifier les tracés. Ces éléments sont cruciaux pour rendre vos visualisations
communicatives, que ce soit dans un rapport ou une présentation.
Pour qu’un graphique soit informatif, il doit inclure des annotations pour expliquer son contenu et
faciliter son interprétation. Matplotlib permet d’ajouter des étiquettes aux axes (xlabel, ylabel),
un titre (title) et une légende (legend) pour identifier les tracés.
Considérez un graphique comparant deux fonctions : y = sin(x) et y = cos(x). Vous pouvez ajouter
des labels, un titre et une légende pour clarifier le contenu :
1 import numpy as np
2 import [Link] as plt
3
4 x = [Link](0, 2 * [Link], 100)
5 y1 = [Link](x)
6 y2 = [Link](x)

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

7.3 Matplotlib : visualisation des données scientifiques 147

7
8 [Link](x, y1, 'b−', label='sin(x)')
9 [Link](x, y2, 'r−−', label='cos(x)')
10 [Link]('x (radians)')
11 [Link]('Valeur')
12 [Link]('Comparaison de sin(x) et cos(x)')
13 [Link]()
14 [Link]()

Ce code produit un graphique avec deux courbes : une courbe bleue continue pour sin(x) et une
courbe rouge pointillée pour cos(x). Les annotations sont :
• xlabel('x (radians)') : étiquette l’axe des x comme représentant des angles en radians.
• ylabel('Valeur') : indique que l’axe des y représente les valeurs des fonctions.
• title('Comparaison de sin(x) et cos(x)') : donne un titre descriptif au graphique.
• legend() : affiche une légende identifiant chaque courbe, utilisant les labels spécifiés dans
[Link] ('sin(x)' et 'cos(x)').
• grid() : affiche une grille.
Le résultat est un graphique clair montrant les courbes oscillant entre −1 et 1. Vous pouvez contrôler
la position de la légende avec l’argument loc, par exemple, loc='lower right' pour la placer en
bas à droite.

Comparaison de sin(x) et cos(x)

1.00
0.75
0.50
0.25
Valeur

0.00
0.25
0.50
0.75
sin(x)
1.00 cos(x)
0 1 2 3 4 5 6
x (radians)

F IGURE 7.9 – Comparaison des fonctions sin(x) et cos(x) avec étiquettes et légende.

Pour un autre exemple, supposons qu’on visualise des données de température à deux moments de
la journée :
1 jours = [Link]([1, 2, 3, 4, 5])
2 matin = [Link]([15.5, 16.0, 14.8, 15.2, 16.5])
3 soir = [Link]([20.5, 21.0, 19.8, 20.2, 21.5])
4
5 [Link](jours, matin, 'bo−', label='Matin')
6 [Link](jours, soir, 'rs−−', label='Soir')
7 [Link]('Jour')

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 148 Chapitre 7. Bibliothèques scientifiques

8 [Link]('Température (°C)')
9 [Link]('Températures quotidiennes')
10 [Link]()
11 [Link]()

Ce graphique montre deux courbes : une ligne bleue continue avec des cercles pour les températures
du matin et une ligne rouge pointillée avec des carrés pour celles du soir. Les étiquettes et la légende
rendent le graphique immédiatement compréhensible, avec l’axe des x indiquant les jours et l’axe
des y les températures en degrés Celsius.

Températures quotidiennes

21

20
Température (°C)

19

18

17

16
Matin
15 Soir
1.0 1.5 2.0 2.5 3.0 3.5 4.0 4.5 5.0
Jour

F IGURE 7.10 – Températures quotidiennes : matin et soir.

Note. Assurez-vous que chaque tracé dans un graphique avec légende a un label défini dans
[Link]. Sans label, [Link]() peut générer une erreur ou omettre des tracés.

Ces annotations transforment un graphique brut en une visualisation communicative, adaptée à une
analyse ou une présentation.

[Link] Ajustement des échelles et des limites

Les échelles et limites des axes influencent la manière dont les données sont représentées. Matplotlib
permet de modifier l’échelle des axes (linéaire ou logarithmique) avec set_xscale et set_yscale
et de définir des limites avec set_xlim et set_ylim. Ces ajustements sont essentiels pour mettre
en évidence des tendances ou zoomer sur une région spécifique.
Échelles des axes : Par défaut, Matplotlib utilise une échelle linéaire, où les intervalles sont
proportionnels aux valeurs. Cependant, pour des données couvrant plusieurs ordres de grandeur
(par exemple, des populations ou des fréquences), une échelle logarithmique est plus appropriée.
Considérez une fonction exponentielle y = ex :
1 import numpy as np
2 import [Link] as plt
3
4 x = [Link](0, 5, 100)

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

7.3 Matplotlib : visualisation des données scientifiques 149

5 y = [Link](x)
6
7 fig, ax = [Link]()
8 [Link](x, y)
9 ax.set_yscale('log')
10 ax.set_xlabel('x')
11 ax.set_ylabel('exp(x)')
12 ax.set_title('Exponentielle avec échelle logarithmique')
13 [Link]()

Ce graphique utilise une échelle logarithmique sur l’axe des y, transformant la courbe exponentielle
en une droite, car log(ex ) = x.

Exponentielle avec échelle logarithmique

102
exp(x)

101

100
0 1 2 3 4 5
x

F IGURE 7.11 – Fonction exponentielle y = ex avec une échelle logarithmique sur l’axe des y.

Vous pouvez également appliquer une échelle logarithmique à l’axe des x avec ax.set_xscale('
log'), utile pour des données comme des fréquences ou des échelles temporelles.

Limites des axes : Les limites des axes contrôlent la plage de valeurs affichée. Par exemple, pour
une courbe sinus :
1 x = [Link](0, 2 * [Link], 100)
2 y = [Link](x)
3
4 fig, ax = [Link]()
5 [Link](x, y)
6 ax.set_xlim(0, [Link])
7 ax.set_ylim(−0.5, 1)
8 ax.set_xlabel('x (radians)')
9 ax.set_ylabel('sin(x)')
10 ax.set_title('Sinus avec limites ajustées')
11 [Link]()

Ce graphique affiche seulement la moitié de la période du sinus (de 0 à π), avec l’axe des y limité à
[−0.5, 1], mettant en évidence la montée de la courbe. Le résultat est une courbe bleue continue,

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 150 Chapitre 7. Bibliothèques scientifiques

partant de (0, 0) et atteignant un pic à (π/2, 1).

Sinus avec limites ajustées

1.0

0.8

0.6

0.4
sin(x)

0.2

0.0

0.2

0.4
0.0 0.5 1.0 1.5 2.0 2.5 3.0
x (radians)

F IGURE 7.12 – Courbe sinusoidale sin(x) avec limites ajustées.

Note. Lors de l’ajustement des limites avec set_xlim ou set_ylim, assurez-vous que les valeurs
sont cohérentes avec les données. Par exemple, définir set_ylim(0, 0) ou des limites en dehors
des données peut produire un graphique vide ou trompeur.

[Link] Résumé des options de personnalisation

Pour faciliter la personnalisation de vos graphiques, les tableaux suivants récapitulent les principales
options de style et de configuration disponibles dans Matplotlib. Ces tableaux constituent une
référence rapide pour choisir les marqueurs, types de lignes, couleurs et positions de légendes, vous
permettant de créer des visualisations adaptées à vos besoins. Consultez ces tableaux lorsque vous
concevez vos graphiques pour sélectionner les options les plus appropriées.

TABLE 7.3 – Options de marqueurs pour les tracés

Marqueur Description
o Cercle
s Carré
^ Triangle pointant vers le haut
v Triangle pointant vers le bas
* Étoile
+ Croix
x X
d Losange

Ces tableaux regroupent les options les plus courantes pour personnaliser vos graphiques. Pour des
options supplémentaires, comme des tailles de marqueurs ou des épaisseurs de lignes, référez-vous
à la documentation officielle de Matplotlib 6 .
6. [Link]

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

7.3 Matplotlib : visualisation des données scientifiques 151

TABLE 7.4 – Types de lignes

Option Description
− Ligne continue
−− Ligne pointillée
−. Ligne avec tirets et points
: Ligne en points

TABLE 7.5 – options de couleurs

Option Description
blue, b Couleur bleu
red, r Couleur rouge
green, g Couleur verte
purple, p Couleur violette
cyan, c Couleur cyan
magenta, m Couleur magenta
yellow, y Couleur jaune
black, k Couleur noire
white, w Couleur blanche
#FF0000 Rouge (code hexadécimal)
#00FF00 Vert (code hexadécimal)
#0000FF Bleu (code hexadécimal)

TABLE 7.6 – Options de positionnement des légendes

Valeur de loc Position de la légende

best Position optimale (par défaut)
upper left Coin supérieur gauche
upper right Coin supérieur droit
upper center En haut et au centre
lower left Coin inférieur gauche
lower right Coin inférieur droit
lower center En bas et au centre
center Centre du graphique
center left Centre du graphique et à gauche
center right Centre du graphique et à droite

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 152 Chapitre 7. Bibliothèques scientifiques

7.3.3 Types de graphiques courants

La visualisation des données repose sur le choix du type de graphique adapté à l’objectif de l’analyse.
Matplotlib propose une variété de graphiques pour représenter des relations, des distributions ou
des comparaisons, chacun ayant une fonction spécifique dans la bibliothèque. Avant d’explorer
certains graphiques en détail, un tableau récapitule les types de graphiques les plus courants, leurs
fonctions associées et leurs usages.

TABLE 7.7 – Types de graphiques courants dans Matplotlib

Type de graphique Fonction Description

Tracé linéaire plot Relie les points par des lignes pour représenter des
données continues, comme des séries temporelles ou
des fonctions mathématiques.
Diagramme de dispersion scatter Affiche des points individuels (nuages de points) pour
visualiser les relations entre deux variables, pour des
données expérimentales.
Diagramme en barres bar Représente des catégories avec des barres de hauteur
proportionnelle aux valeurs, utile pour comparer des
quantités.
Diagramme circulaire pie Montre la répartition des données sous forme de sec-
teurs, adapté aux proportions ou pourcentages.
Histogramme hist Visualise la distribution des données en regroupant
les valeurs en intervalles, parfait pour analyser des
fréquences.
Boîte à moustaches boxplot Résume la distribution des données avec les quartiles,
la médiane et les valeurs aberrantes, utile pour les
comparaisons statistiques.

Ce tableau vous servira de guide pour choisir le graphique adapté à vos données. Les sections
suivantes détaillent les tracés linéaires, les diagrammes de dispersion et les histogrammes, avec des
exemples concrets pour vous familiariser avec leur création.

[Link] Tracés linéaires

Les tracés linéaires, créés avec la fonction plot, permettent de représenter des données continues,
comme des séries temporelles, des fonctions mathématiques ou des mesures évoluant progressive-
ment. En reliant les points par des lignes, ces graphiques permettent de visualiser des tendances
ou des variations. Vous avez déjà utilisé [Link] dans les sections précédentes pour tracer des
fonctions comme sin(x).
Considérons une série temporelle représentant la consommation d’énergie quotidienne d’un bâti-
ment sur une semaine :
1 import numpy as np
2 import [Link] as plt
3
4 jours = [Link]([1, 2, 3, 4, 5, 6, 7])
5 consommation = [Link]([120, 115, 130, 125, 140, 135, 128])
6
7 [Link](jours, consommation, 'b−o', label='Consommation (kWh)')
8 [Link]('Jour')
9 [Link]('Consommation (kWh)')
10 [Link]('Consommation d'énergie quotidienne')
11 [Link]()

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.3 Matplotlib : visualisation des données scientifiques 153

12 [Link]()
13 [Link]()

Ce code génère un graphique avec une ligne bleue continue reliant sept points marqués par des
cercles, représentant la consommation d’énergie de 120 à 140 kWh sur une semaine. Les étiquettes
et la légende rendent le graphique clair, avec l’axe des x indiquant les jours et l’axe des y la
consommation en kilowattheures.

Consommation d énergie quotidienne

140 Consommation (kWh)

135
Consommation (kWh)

130

125

120

115
1 2 3 4 5 6 7
Jour

F IGURE 7.13 – Consommation d’énergie quotidienne sur une semaine.

Note. Pour les tracés linéaires, assurez-vous que les données sont ordonnées selon l’axe des x si
vous représentez une séquence temporelle ou une relation continue. Des données désordonnées
peuvent produire des lignes en zigzag déroutantes.
Les tracés linéaires sont polyvalents et constituent un outil de base pour explorer des tendances
dans vos données, que ce soit pour des mesures réelles ou des modèles théoriques.

[Link] Diagrammes de dispersion

Les diagrammes de dispersion, créés avec la fonction scatter, affichent des points individuels
(nuages de points) pour visualiser les relations entre deux variables, sans les relier par des lignes.
Ils sont utiles pour analyser des corrélations, identifier des regroupements ou repérer des valeurs
aberrantes dans des données expérimentales. Contrairement à plot avec linestyle='', scatter
offre plus de contrôle sur la taille, la couleur et la forme des points.
Supposons que l’on étudie la relation entre la température et la consommation d’énergie dans un
bâtiment :
1 import numpy as np
2 import [Link] as plt
3
4 temperatures = [Link]([15, 16, 14, 17, 18, 16, 15])
5 consommation = [Link]([130, 125, 135, 120, 115, 128, 132])
6

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

154 Chapitre 7. Bibliothèques scientifiques

7 [Link](temperatures, consommation, color='purple', marker='o', s=100,

label='Données')
8 [Link]('Température (°C)')
9 [Link]('Consommation (kWh)')
10 [Link]('Température vs Consommation d'énergie')
11 [Link]()
12 [Link]()

Ce code produit un diagramme de dispersion avec des cercles violets de taille 100 (spécifiée par
s=100) aux coordonnées (tempratures[i], consommation[i]). Le graphique suggère une possible
corrélation négative : la consommation diminue légèrement lorsque la température augmente.

Température vs Consommation d énergie

135.0 Données
132.5
130.0
Consommation (kWh)

127.5
125.0
122.5
120.0
117.5
115.0
14.0 14.5 15.0 15.5 16.0 16.5 17.0 17.5 18.0
Température (°C)

F IGURE 7.14 – Relation entre température et consommation d’énergie.

Pour un exemple plus complexe, visualisons des données bidimensionnelles avec des couleurs
variables pour indiquer une troisième variable, comme la pression atmosphérique :
1 [Link](42)
2 temperatures = [Link](10, 20, 10)
3 consommation = [Link](100, 150, 10)
4 pression = [Link](900, 1100, 10)
5
6 scatter = [Link](temperatures, consommation, c=pression, s=150, cmap='
viridis', label='Données')
7 [Link](label='Pression (hPa)')
8 [Link]('Température (°C)')
9 [Link]('Consommation (kWh)')
10 [Link]('Température vs Consommation avec pression')
11 [Link]()
12 [Link]()

Ce graphique affiche 10 points, dont la couleur varie selon la pression (de 900 à 1100 hPa), utilisant
la colormap viridis. Une barre de couleur indique l’échelle de pression, rendant le graphique
informatif sur trois variables.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.3 Matplotlib : visualisation des données scientifiques 155

Température vs Consommation avec pression

150
Données
1040
140
1020
Consommation (kWh)

130 1000

Pression (hPa)
980
120
960

110 940

920
100
12 14 16 18
Température (°C)

F IGURE 7.15 – Diagramme de dispersion indiquant la pression atmosphérique.

Note. Lors de l’utilisation de scatter, vérifiez que les tableaux x et y ont la même longueur et
que les paramètres comme s (taille) ou c (couleur) sont cohérents avec les données pour éviter des
erreurs.

[Link] Histogrammes

Les histogrammes, créés avec la fonction hist, visualisent la distribution des données en regroupant
les valeurs dans des intervalles (ou « bacs ») et en affichant leur fréquence sous forme de barres.
Ils sont essentiels pour analyser la répartition des données, comme la fréquence des mesures ou la
forme d’une distribution. Les histogrammes sont adaptés aux données continues ou aux résultats
d’expériences.
Soit un ensemble de mesures de température collectées sur un mois :
1 import numpy as np
2 import [Link] as plt
3
4 temperatures = [Link](20, 2, 1000) # Moyenne 20°C, écart−type 2°C
5
6 [Link](temperatures, bins=20, color='skyblue', edgecolor='black', label='
Températures')
7 [Link]('Température (°C)')
8 [Link]('Fréquence')
9 [Link]('Distribution des températures')
10 [Link]()
11 [Link]()

Ce code génère un histogramme avec 20 bacs, représentant la distribution de 1000 températures

simulées suivant une loi normale. Les barres bleues claires avec des contours noirs montrent que
la plupart des températures se concentrent autour de 20°C, formant une courbe en cloche typique
d’une distribution normale.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 156 Chapitre 7. Bibliothèques scientifiques

Distribution des températures

175 Températures

150

125
Fréquence

100

75

50

25

0
10.0 12.5 15.0 17.5 20.0 22.5 25.0
Température (°C)

F IGURE 7.16 – Histogramme de la distribution des températures suivant une loi normale.

Note. Le choix du nombre de bacs (bins) est crucial pour les histogrammes. Trop peu de bacs
peuvent masquer des détails, tandis que trop de bacs peuvent rendre le graphique bruité. Expéri-
√
mentez avec différentes valeurs ou utilisez une règle comme n (où n est le nombre de données)
pour un compromis.

7.3.4 Gestion de multiples graphiques

Lorsque vous analysez des données, il est souvent nécessaire de comparer plusieurs visualisations
pour identifier des tendances, des différences ou des relations. Matplotlib permet de regrouper
plusieurs graphiques dans une même figure à l’aide de sous-graphiques en offrant une présentation
claire et organisée. Cela est utile pour comparer des séries de données ou des aspects différents
d’un même problème, comme des distributions ou des évolutions temporelles.

[Link] Sous-graphiques : création et organisation

Les sous-graphiques (ou subplots) sont des graphiques individuels disposés dans une grille au sein
d’une même figure. La fonction [Link] est l’outil principal pour créer ces sous-graphiques,
permettant de définir le nombre de lignes et de colonnes de la grille. Chaque sous-graphique est un
objet Axes, que vous pouvez personnaliser indépendamment, comme expliqué dans la sous-section
sur la structure des figures.
Pour illustrer, créez une figure avec deux sous-graphiques côte à côte pour comparer les fonctions
sin(x) et cos(x) :
1 import numpy as np
2 import [Link] as plt
3
4 x = [Link](0, 2 * [Link], 100)
5 y1 = [Link](x)
6 y2 = [Link](x)
7

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.3 Matplotlib : visualisation des données scientifiques 157

8 fig, (ax1, ax2) = [Link](1, 2, figsize=(10, 4)) # 1 ligne, 2 colonnes

9
10 [Link](x, y1, 'b−', label='sin(x)')
11 ax1.set_xlabel('x (radians)')
12 ax1.set_ylabel('Valeur')
13 ax1.set_title('Sinus')
14 [Link]()
15
16 [Link](x, y2, 'r−−', label='cos(x)')
17 ax2.set_xlabel('x (radians)')
18 ax2.set_ylabel('Valeur')
19 ax2.set_title('Cosinus')
20 [Link]()
21
22 [Link]()

Ce code génère une figure de taille 10 pouces par 4 pouces contenant deux sous-graphiques
horizontaux. Le premier (ax1) montre une courbe bleue continue pour sin(x) et le second (ax2)
une courbe rouge pointillée pour cos(x). Chaque sous-graphique a ses propres étiquettes, titre et
légende.

Sinus Cosinus
1.00 sin(x) 1.00

0.75 0.75

0.50 0.50

0.25 0.25
Valeur

Valeur

0.00 0.00

0.25 0.25

0.50 0.50

0.75 0.75

1.00 1.00 cos(x)

0 1 2 3 4 5 6 0 1 2 3 4 5 6
x (radians) x (radians)

F IGURE 7.17 – Deux sous-graphiques comparant sin(x) et cos(x).

Note. Lors de la création de sous-graphiques, vérifiez que la taille de la figure (figsize) est
adaptée au nombre de sous-graphiques pour éviter des graphiques trop petits ou des étiquettes
illisibles. Utilisez tight_layout pour optimiser l’espacement.

[Link] Partage d’axes et personnalisation globale

Lorsque vous comparez des sous-graphiques, il est souvent utile de synchroniser leurs échelles
d’axes pour faciliter les comparaisons visuelles. [Link] permet de partager les axes x ou
y entre sous-graphiques avec les arguments sharex et sharey. De plus, des personnalisations
globales, comme un titre principal ou un ajustement de l’espacement, peuvent être appliquées à la
figure entière.
Soit une figure avec quatre sous-graphiques comparant des fonctions trigonométriques (sin(x),
cos(x), sin(2x), cos(2x)) avec des axes y partagés :
1 import numpy as np
2 import [Link] as plt
3
4 x = [Link](0, 2 * [Link], 100)

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

158 Chapitre 7. Bibliothèques scientifiques

5 y1 = [Link](x)
6 y2 = [Link](x)
7 y3 = [Link](2 * x)
8 y4 = [Link](2 * x)
9
10 fig, axs = [Link](2, 2, figsize=(10, 8), sharey=True)
11
12 axs[0, 0].plot(x, y1, 'b−', label='sin(x)')
13 axs[0, 0].set_title('Sinus')
14 axs[0, 0].legend()
15
16 axs[0, 1].plot(x, y2, 'r−−', label='cos(x)')
17 axs[0, 1].set_title('Cosinus')
18 axs[0, 1].legend()
19
20 axs[1, 0].plot(x, y3, 'g−', label='sin(2x)')
21 axs[1, 0].set_title('Sinus double')
22 axs[1, 0].legend()
23
24 axs[1, 1].plot(x, y4, 'm−−', label='cos(2x)')
25 axs[1, 1].set_title('Cosinus double')
26 axs[1, 1].legend()
27
28 for ax in [Link]:
29 ax.set_xlabel('x (radians)')
30 ax.set_ylabel('Valeur')
31
32 [Link]('Comparaison des fonctions trigonométriques', fontsize=16)
33 plt.tight_layout()
34 fig.subplots_adjust(top=0.9) # Ajuste pour le titre principal
35 [Link]()

Ce code crée une grille 2x2 de sous-graphiques, avec une taille de figure de 10 pouces par 8 pouces.
L’argument sharey=True synchronise l’échelle des axes y et fixe la plage à [−1, 1] pour toutes les
courbes.
Chaque sous-graphique a un titre et une légende et les étiquettes d’axes sont appliquées via une
boucle sur [Link]. La fonction suptitle ajoute un titre principal à la figure et subplots_adjust
réserve de l’espace pour éviter le chevauchement avec les sous-titres.
Comparaison des fonctions trigonométriques
Sinus Cosinus
1.0
sin(x)
0.5

0.0
Valeur

Valeur

0.5

1.0 cos(x)
1 0 1 2 3 4 5 0 1 2 3 4 5 6
x (radians) x (radians)
Sinus double Cosinus double
1.0
sin(2x)
0.5

0.0
Valeur

Valeur

0.5

1.0 cos(2x)
0 1 2 3 4 5 6 0 1 2 3 4 5 6
x (radians) x (radians)

F IGURE 7.18 – Grille 2x2 de sous-graphiques.

Pour un autre exemple, visualisons des histogrammes de différentes distributions avec des axes y
partagés pour comparer les fréquences :

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

7.3 Matplotlib : visualisation des données scientifiques 159

1 import numpy as np
2 import [Link] as plt
3
4 [Link](42)
5 data1 = [Link](0, 1, 1000) # Normale standard
6 data2 = [Link](2, 1.5, 1000) # Moyenne 2, écart−type 1.5
7
8 fig, (ax1, ax2) = [Link](1, 2, figsize=(12, 5), sharey=True)
9
10 [Link](data1, bins=20, color='skyblue', edgecolor='black', label='Normale
(mu=0, sigma=1)')
11 ax1.set_xlabel('Valeur')
12 ax1.set_ylabel('Fréquence')
13 ax1.set_title('Distribution normale standard')
14 [Link]()
15
16 [Link](data2, bins=20, color='salmon', edgecolor='black', label='Normale (
mu=2, sigma=1.5)')
17 ax2.set_xlabel('Valeur')
18 ax2.set_ylabel('Fréquence')
19 ax2.set_title('Distribution normale décalée')
20 [Link]()
21
22 [Link]('Comparaison des distributions normales', fontsize=16)
23 plt.tight_layout()
24 fig.subplots_adjust(top=0.85)
25 [Link]()

Ce code génère deux histogrammes côte à côte dans une figure de 12 pouces par 5 pouces.
L’argument sharey=True synchronise l’axe des y, facilitant la comparaison des fréquences. Le
premier histogramme (bleu clair) montre une distribution normale centrée à 0, et le second (saumon)
une distribution centrée à 2 avec une dispersion plus large. Le titre principal et l’ajustement de
l’espacement (subplots_adjust) assurent une présentation soignée.

Comparaison des distributions normales

Distribution normale standard Distribution normale décalée
160
Normale ( =0, =1) Normale ( =2, =1.5)
140

120

100
Fréquence

Fréquence

80

60

40

20

0
3 2 1 0 1 2 3 4 2 0 2 4 6
Valeur Valeur

F IGURE 7.19 – Deux histogrammes comparant des distributions normales.

Note. Lorsque vous partagez des axes avec sharex ou sharey, les limites et échelles sont syn-
chronisées. Si les données ont des plages très différentes, cela peut rendre certains sous-graphiques
illisibles. Vérifiez les échelles avant de partager.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 160 Chapitre 7. Bibliothèques scientifiques

7.3.5 Sauvegarde et exportation des graphiques

Une fois vos graphiques créés et personnalisés, il est souvent nécessaire de les sauvegarder pour
les intégrer dans des rapports, des présentations ou des publications. Matplotlib offre des outils
puissants pour exporter vos figures dans différents formats de fichiers, avec des options pour
contrôler leur qualité et leur apparence.
Matplotlib permet de sauvegarder les graphiques dans plusieurs formats de fichiers, chacun adapté
à des usages spécifiques. Les formats les plus courants sont PNG (Portable Network Graphics),
PDF (Portable Document Format) et SVG (Scalable Vector Graphics). La fonction [Link] est
utilisée pour exporter une figure en spécifiant le nom du fichier et son extension qui détermine le
format.

• PNG : Un format d’image matricielle, idéal pour les présentations ou les documents né-
cessitant une bonne qualité sans perte de détails. Il est compact mais ne permet pas de
redimensionner sans perte de qualité.
• PDF : Un format vectoriel, parfait pour les documents imprimés ou les publications scienti-
fiques, car il conserve la netteté à toutes les échelles. Il est largement utilisé dans les articles
académiques.
• SVG : Un format vectoriel adapté aux graphiques redimensionnables, souvent utilisé pour
les visualisations interactives sur le web ou pour une édition ultérieure dans des logiciels.

Pour illustrer, créez un graphique simple et sauvegardez-le en PNG et PDF :

1 import numpy as np
2 import [Link] as plt
3
4 x = [Link](0, 10, 100)
5 y = [Link](x)
6
7 [Link](x, y, 'b−', label='sin(x)')
8 [Link]('x (radians)')
9 [Link]('Valeur')
10 [Link]('Courbe sinusoidale')
11 [Link]()
12 [Link]()
13
14 [Link]('[Link]')
15 [Link]('[Link]')
16 [Link]()

La fonction [Link] crée deux fichiers dans le répertoire courant : [Link] et

[Link]. Le graphique est également affiché à l’écran avec [Link]. Les fichiers
sauvegardés peuvent être intégrés dans des documents ou ouverts directement.
Note. Placez [Link] avant [Link], car [Link] peut réinitialiser la figure dans certains
environnements et peut rendre l’exportation vide. Assurez-vous également que le répertoire de
sauvegarde est accessible et que le nom du fichier inclut l’extension correcte (.png, .pdf, .svg).
Le choix du format dépend de l’usage : PNG pour les images rapides, PDF pour les documents
professionnels et SVG pour les graphiques modifiables.

Lors de l’exportation d’un graphique avec [Link], vous pouvez ajuster des paramètres pour
contrôler la qualité, la taille et l’apparence du fichier généré. Les paramètres clés incluent dpi
(résolution), bbox_inches (ajustement des marges) et transparent (fond transparent). Ces options
vous permettent d’adapter le graphique à des besoins spécifiques, comme une impression haute

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.4 Pandas : manipulation et analyse des données 161

résolution ou une intégration dans un document avec un fond particulier.

• Résolution (dpi) : Le paramètre dpi (dots per inch, points par pouce) définit la résolution de
l’image pour les formats matriciels comme PNG. Une valeur plus élevée augmente la qualité
mais aussi la taille du fichier. Par exemple, dpi=300 est adapté pour l’impression, tandis que
dpi=100 suffit pour les écrans.
• Ajustement des marges (bbox_inches) : Le paramètre bbox_inches='tight' ajuste auto-
matiquement les marges pour inclure toutes les étiquettes, titres et légendes en évitant qu’ils
ne soient coupés. Sans cet ajustement, des éléments peuvent être tronqués dans le fichier
exporté.
• Fond transparent (transparent) : Le paramètre transparent=True rend le fond du gra-
phique transparent, utile pour l’intégration dans des documents avec des arrière-plans colorés
ou texturés. Cela est pertinent pour les formats PNG et SVG.
Pour aller plus loin, vous pouvez consulter le site de matplotlib qui fournit de nombreux exemples
détaillés 7 ou encore ces cheatsheets 8 qui vous seront extrêmement utiles.

7.4 Pandas : manipulation et analyse des données

7.4.1 Introduction à Pandas et ses structures de données
La bibliothèque Pandas est un outil incontournable pour la manipulation et l’analyse des données
en Python. Elle permet de travailler avec des données tabulaires, comme des feuilles de calcul ou
des bases de données de manière simple et efficace. Vous trouverez que Pandas simplifie des tâches
complexes, comme organiser des données, filtrer des informations ou calculer des statistiques, grâce
à ses structures de données : les Series et les DataFrames.

[Link] Les Series : vecteurs de données

Une Series est une structure de données unidimensionnelle, comparable à une colonne dans une
feuille de calcul ou à une liste Python avec des étiquettes. Chaque élément d’une Series est associé
à un index qui peut être un numéro (par défaut, commençant à 0) ou une étiquette personnalisée
(par exemple, des noms ou des dates). C’est un tableau unidimensionnel contenant des données de
même type (par exemple, entiers, flottants, chaînes) et un index qui identifie chaque élément.
Pour créer une Series, vous pouvez utiliser la fonction [Link] en passant une liste ou un
tableau NumPy. Voici un exemple simple représentant les notes de cinq étudiants :
>>> import pandas as pd
>>> notes = [Link]([15.5, 12.0, 18.0, 9.5, 14.0])
>>> print(notes)
0 15.5
1 12.0
2 18.0
3 9.5
4 14.0
dtype: float64

Ce code crée une Series avec cinq notes, associées à un index par défaut (0 à 4). La sortie
montre les valeurs et leur type (float64), indiquant que les données sont des nombres à virgule
flottante. Vous pouvez accéder à une note spécifique en utilisant l’index, par exemple notes[2] ou
[Link][2] renvoie 18.0.

7. [Link]
8. [Link]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 162 Chapitre 7. Bibliothèques scientifiques

Note. Par convention, on utilise pd comme nom raccourci pour pandas.

Pour rendre la Series plus explicite, vous pouvez spécifier un index personnalisé, comme les noms
des étudiants :
>>> notes = [Link]([15.5, 12.0, 18.0, 9.5, 14.0], index=['Alice', 'Bob', '
Claire', 'David', 'Emma'])
>>> print(notes)
Alice 15.5
Bob 12.0
Claire 18.0
David 9.5
Emma 14.0
dtype: float64

Ici, chaque note est associée à un nom, ce qui facilite l’identification des données. Par exemple,
notes['Claire'] ou [Link]['Claire'] renvoie 18.0. Cela permet de travailler avec des
données étiquetées de manière naturelle, ce qui fait l’une des forces de Pandas.
Note. Lors de la création d’une Series, assurez-vous que la longueur de l’index correspond à celle
des données. Par exemple, fournir cinq valeurs avec seulement quatre étiquettes d’index générera
une erreur.
Les Series sont la base des structures de Pandas. Elles sont souvent utilisées comme composants
des DataFrames.

[Link] Les DataFrames : tableaux bidimensionnels

Un DataFrame est une structure de données bidimensionnelle, comparable à une feuille de calcul
ou une table de base de données, avec des lignes et des colonnes. Chaque colonne d’un DataFrame
est une Series et partage un même index pour les lignes.
Pour illustrer, créons un DataFrame représentant les notes et les matières de trois étudiants :
>>> donnees = {
... 'Nom': ['Alice', 'Bob', 'Claire'],
... 'Maths': [15.5, 12.0, 18.0],
... 'Physique': [14.0, 13.5, 16.5]
... }
>>> df = [Link](donnees)
>>> print(df)
Nom Maths Physique
0 Alice 15.5 14.0
1 Bob 12.0 13.5
2 Claire 18.0 16.5

Ce code crée un DataFrame à partir d’un dictionnaire où chaque clé ('Nom', 'Maths', 'Physique')
devient une colonne et les valeurs forment les lignes. L’index par défaut est 0, 1, 2. La sortie
montre un tableau clair avec les noms des étudiants et leurs notes dans deux matières. Vous pouvez
accéder à une colonne comme une Series, par exemple df['Maths'] ou à une cellule spécifique,
comme df['Maths'][0] pour obtenir 15.5.
Vous pouvez également définir un index personnalisé, par exemple en utilisant la colonne 'Nom' :
>>> df = [Link](donnees).set_index('Nom')
>>> print(df)
Maths Physique
Nom
Alice 15.5 14.0

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.4 Pandas : manipulation et analyse des données 163

Bob 12.0 13.5

Claire 18.0 16.5

Ici, la colonne 'Nom' devient l’index, rendant le DataFrame plus intuitif pour identifier les lignes
par nom. Par exemple, [Link]['Alice'] renvoie les notes d’Alice en Maths et Physique.
Note. Lorsque vous créez un DataFrame à partir d’un dictionnaire, assurez-vous que toutes les
listes associées aux clés ont la même longueur. Une incohérence (par exemple, quatre noms mais
trois notes) provoquera une erreur.

[Link] Création et inspection des structures

Créer des Series et des DataFrames est la première étape pour travailler avec Pandas. Ces struc-
tures peuvent être construites à partir de différentes sources, comme des listes, des dictionnaires ou
des tableaux NumPy. Une fois créées, vous pouvez utiliser des méthodes d’inspection pour explorer
leurs propriétés, comme leur taille, leurs index ou leurs colonnes. Ces outils sont essentiels pour
comprendre vos données avant de les manipuler ou de les analyser.
Création de Series et DataFrames : Vous pouvez créer une Series à partir d’une liste, d’un
dictionnaire ou d’un tableau NumPy. Par exemple, pour une Series à partir d’un dictionnaire :
>>> d = {'Lundi': 20, 'Mardi': 22, 'Mercredi': 19}
>>> temperatures = [Link](d)
>>> print(temperatures)
Lundi 20
Mardi 22
Mercredi 19
dtype: int64

On crée une Series avec des températures associées à des jours comme index. Le type int64
indique des entiers.
Pour un DataFrame, vous pouvez utiliser un dictionnaire de listes, un dictionnaire de Series ou un
tableau NumPy. Voici un exemple avec un tableau NumPy :
>>> data = [Link]([[15, 14], [12, 13], [18, 16]])
>>> df = [Link](data, columns=['Maths', 'Physique'],
... index=['Alice', 'Bob', 'Claire'])
>>> print(df)
Maths Physique
Alice 15 14
Bob 12 13
Claire 18 16

Cela crée un DataFrame à partir d’un tableau NumPy 3x2, avec des colonnes nommées 'Maths'
et 'Physique', et un index basé sur les noms des étudiants. Le résultat est un tableau structuré,
similaire à l’exemple précédent.

Inspection des structures : Pandas fournit des méthodes pour examiner les Series et DataFrames.
Les plus courantes sont head(), tail(), index, columns et shape. Le tableau suivant récapitule
ces méthodes :
Pour illustrer, inspectez le DataFrame précédent :
>>> print([Link](2))
Maths Physique

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 164 Chapitre 7. Bibliothèques scientifiques

TABLE 7.8 – Méthodes d’inspection des structures Pandas

Méthode Description
head(n) Affiche les n premières lignes (par défaut, 5).
tail(n) Affiche les n dernières lignes (par défaut, 5).
index Retourne l’index de la Series ou du DataFrame.
columns Retourne les noms des colonnes du DataFrame.
shape Retourne un tuple avec le nombre de lignes et de
colonnes.
size Renvoie un entier représentant le nombre d’éléments
de la Series ou du DataFrame.

Alice 15 14
Bob 12 13
>>> print([Link])
Index(['Alice', 'Bob', 'Claire'], dtype='object')
>>> print([Link])
Index(['Maths', 'Physique'], dtype='object')
>>> print([Link])
(3, 2)
>>> print([Link])
6

7.4.2 Importation et exploration des données

Pandas facilite la lecture de fichiers tabulaires, comme les fichiers CSV ou Excel, qui sont couram-
ment utilisés pour stocker des données structurées.

[Link] Lecture de fichiers : CSV, Excel

Les fichiers CSV (Comma-Separated Values) et Excel sont des formats standards pour stocker des
données tabulaires. Un fichier CSV est un fichier texte où chaque ligne représente une observation
et les valeurs sont séparées par des virgules (ou d’autres délimiteurs, comme des points-virgules).
Un fichier Excel, souvent au format .xlsx, organise les données dans des feuilles de calcul, avec
des colonnes et des lignes similaires à un DataFrame. Pandas fournit les fonctions pd.read_csv et
pd.read_excel pour charger ces fichiers directement dans un DataFrame.

Pour commencer, créez un fichier CSV fictif contenant des notes d’étudiants puis lisez-le avec
pd.read_csv. Voici un exemple où on génère d’abord le fichier puis le charge :

1 import pandas as pd
2
3 # Création d'un DataFrame et sauvegarde en CSV
4 donnees = {
5 'Nom': ['Alice', 'Bob', 'Claire', 'David', 'Emma', 'Florent'],
6 'Maths': [15.5, 12.0, 18.0, 9.5, 14.0, 16.0],
7 'Physique': [14.0, 13.5, 16.5, 11.0, 15.0, 10.5]
8 }
9 df = [Link](donnees)
10 df.to_csv('[Link]', index=False)
11
12 # Lecture du fichier CSV
13 df_notes = pd.read_csv('[Link]')
14 print(df_notes)

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

7.4 Pandas : manipulation et analyse des données 165

Nom Maths Physique

0 Alice 15.5 14.0
1 Bob 12.0 13.5
2 Claire 18.0 16.5
3 David 9.5 11.0
4 Emma 14.0 15.0
5 Florent 16.0 10.5

On commence par créer un DataFrame avec les notes de six étudiants en Maths et Physique puis on
le sauvegarde dans un fichier [Link] sans inclure l’index (index=False), en utilisant la méthode
.to_csv(). Le fichier est enregistré dans le répertoire courant. La fonction pd.read_csv('notes.
csv') charge le fichier dans un nouveau DataFrame, df_notes. La sortie affiche un tableau clair
avec trois colonnes (Nom, Maths, Physique) et six lignes, correspondant aux données initiales.
Chaque colonne est interprétée comme une Series et les types de données sont automatiquement
détectés (float64 pour les notes, object pour les noms).
Note. Lors de la lecture d’un fichier CSV, assurez-vous que le chemin du fichier est correct
(par exemple, '[Link]' si le fichier est dans le répertoire courant). Si le fichier utilise un
délimiteur autre que la virgule, comme un point-virgule, spécifiez-le avec l’argument sep=';' dans
pd.read_csv. Un fichier mal formaté peut provoquer une erreur ou des données mal alignées.

Pour un fichier Excel, l’approche est similaire, mais vous utilisez pd.read_excel. Voici un exemple
où on crée un fichier Excel fictif avec des données météorologiques puis le lit :
1 import pandas as pd
2
3 # Création d'un DataFrame et sauvegarde en Excel
4 meteo = {
5 'Date': ['2023−01−01', '2023−01−02', '2023−01−03', '2023−01−04',
6 '2023−01−05', '2023−01−06', '2023−01−07'],
7 'Température': [5.0, 6.5, 4.0, 7.0, 8.5, 5.5, 6.0],
8 'Précipitations': [0.0, 2.5, 10.0, 0.0, 1.0, 5.0, 3.0]
9 }
10 df_meteo = [Link](meteo)
11 df_meteo.to_excel('[Link]', index=False)
12
13 # Lecture du fichier Excel
14 df_meteo_lu = pd.read_excel('[Link]')
15 print(df_meteo_lu)

Date Température Précipitations

0 2023−01−01 5.0 0.0
1 2023−01−02 6.5 2.5
2 2023−01−03 4.0 10.0
3 2023−01−04 7.0 0.0
4 2023−01−05 8.5 1.0
5 2023−01−06 5.5 5.0
6 2023−01−07 6.0 3.0

Dans cet exemple, on crée un DataFrame avec des données météorologiques sur sept jours (dates,
températures, précipitations), le sauvegarde dans [Link] avec .to_excel(), puis le charge
avec pd.read_excel. La sortie montre un tableau avec trois colonnes et sept lignes, où Date est
interprété comme une chaîne (object) et les autres colonnes comme float64.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 166 Chapitre 7. Bibliothèques scientifiques

[Link] Aperçu des données : head, tail, info

Après avoir importé des données dans un DataFrame, il est essentiel d’en obtenir un aperçu pour
comprendre sa structure, ses dimensions et les types de données de ses colonnes. Pandas propose
des méthodes simples, comme head(), tail(), vues précédemment et info() qui permettent
d’examiner rapidement un DataFrame sans avoir à afficher toutes les données, ce qui est utile pour
des ensembles volumineux.
Pour rappel, la méthode head(n) affiche les n premières lignes du DataFrame (par défaut, n=5),
tandis que tail(n) montre les n dernières lignes. Ces méthodes sont idéales pour vérifier si les
données ont été correctement chargées. Par exemple, reprenez le DataFrame des notes :
>>> df_notes = pd.read_csv('[Link]')
>>> print(df_notes.head(3))
Nom Maths Physique
0 Alice 15.5 14.0
1 Bob 12.0 13.5
2 Claire 18.0 16.5
>>> print(df_notes.tail(2))
Nom Maths Physique
4 Emma 14.0 15.0
5 Florent 16.0 10.5

La méthode info() fournit un résumé plus détaillé : le nombre de lignes, les noms des colonnes,
leurs types de données et le nombre de valeurs non nulles. Appliquons-la au DataFrame météorolo-
gique :
>>> df_meteo = pd.read_excel('[Link]')
>>> print(df_meteo.info())
<class '[Link]'>
RangeIndex: 7 entries, 0 to 6
Data columns (total 3 columns):
# Column Non−Null Count Dtype
−−− −−−−−− −−−−−−−−−−−−−− −−−−−
0 Date 7 non−null object
1 Température 7 non−null float64
2 Précipitations 7 non−null float64
dtypes: float64(2), object(1)
memory usage: 300.0+ bytes
>>> print(df_meteo.info(memory_usage="deep"))
<class '[Link]'>
RangeIndex: 7 entries, 0 to 6
Data columns (total 3 columns):
# Column Non−Null Count Dtype
−−− −−−−−− −−−−−−−−−−−−−− −−−−−
0 Date 7 non−null object
1 Température 7 non−null float64
2 Précipitations 7 non−null float64
dtypes: float64(2), object(1)
memory usage: 657.0 bytes

Cette sortie indique que df_meteo contient 7 lignes (index de 0 à 6) et 3 colonnes : Date (type
object, c’est-à-dire une chaîne), Température et Précipitations (type float64). Toutes les
colonnes ont 7 valeurs non nulles, confirmant l’absence de données manquantes. Avec l’argument
memory_usage="deep", la méthode .info() permet de connaitre avec précision la quantité de
mémoire vive occupée par le Dataframe (environ 657 octets).
Note. La méthode info() affiche les types de données détectés automatiquement par Pandas. Si

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.4 Pandas : manipulation et analyse des données 167

une colonne, comme Date, est lue comme object (correspond la plupart du temps à des chaînes de
caractères) au lieu d’un type date (datetime), vous devrez peut-être convertir le type explicitement.
Pour le faire, vous utiliserez la méthode .to_datetime(). pandas détectera alors automatiquement
le format de date utilisé, si le format est homogène sur tout le jeu de données et non ambigu.
>>> df_meteo['Date'] = pd.to_datetime(df_meteo['Date'])
>>> print(df_meteo.info(memory_usage="deep"))
<class '[Link]'>
RangeIndex: 7 entries, 0 to 6
Data columns (total 3 columns):
# Column Non−Null Count Dtype
−−− −−−−−− −−−−−−−−−−−−−− −−−−−
0 Date 7 non−null datetime64[ns]
1 Température 7 non−null float64
2 Précipitations 7 non−null float64
dtypes: datetime64[ns](1), float64(2)
memory usage: 300.0 bytes

On remarque maintenant que le type de données de la colonne Date est maintenant une date
(datetime64[ns]).

[Link] Statistiques descriptives de base

Les statistiques descriptives permettent de résumer les propriétés numériques d’un DataFrame,
comme la moyenne, l’écart-type ou les valeurs extrêmes et offre un premier aperçu des tendances et
de la variabilité des données. Pandas fournit la méthode describe() pour calculer automatiquement
ces statistiques pour les colonnes numériques, ainsi que des fonctions spécifiques comme mean(),
std() ou min() pour des calculs ciblés. Ces outils peuvent se révéler utiles pour identifier des
motifs ou des anomalies avant une analyse plus approfondie.
Appliquons describe() au DataFrame des notes pour examiner les colonnes numériques :
>>> print(df_notes.describe())
Maths Physique
count 6.000000 6.000000
mean 14.166667 13.416667
std 3.044120 2.311205
min 9.500000 10.500000
25% 12.500000 11.625000
50% 14.750000 13.750000
75% 15.875000 14.750000
max 18.000000 16.500000

Cette sortie résume les colonnes Maths et Physique :

• count : Nombre de valeurs (6 pour chaque colonne).

• mean : Moyenne (14.16 et 13.41 respectivement).
• std : Écart-type, indiquant la dispersion (plus élevé pour Maths, suggérant une plus grande
variabilité).
• min, max : Valeurs minimale et maximale.
• 25\%, 50\%, 75\% : Quartiles (25e, 50e, 75e centiles), montrant la répartition des données.

La colonne Nom (type object) est exclue, car describe() se concentre sur les colonnes numériques
par défaut. Pour inclure toutes les colonnes, vous pouvez utiliser df_notes.describe(include='
all'), mais cela ajoute des statistiques pour les chaînes (comme le nombre de valeurs uniques),
moins pertinentes ici.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 168 Chapitre 7. Bibliothèques scientifiques

Pour des calculs spécifiques, utilisez des fonctions comme mean() ou median(). Par exemple, pour
le DataFrame météorologique :
>>> print(df_meteo[['Température', 'Précipitations']].mean())
Température 6.071429
Précipitations 3.071429
dtype: float64
>>> print(df_meteo['Température'].median())
6.0

Ce code calcule :
• La moyenne des colonnes Température (6.07°C) et Précipitations (3.07 mm).
• La médiane de Température (6.0°C) qui est la valeur centrale lorsque les données sont
ordonnées.
Note. Ne vous inquiétez pas si la syntaxe df_meteo[['Température', 'Précipitations']] ou
df_meteo['Température'] ne vous est pas encore familière. Il s’agit de la sélection de colonnes
dans un tableau de données et nous verrons cela en détail dans la section suivante.
Le tableau suivant récapitule les principales fonctions statistiques :

TABLE 7.9 – Fonctions statistiques descriptives dans Pandas

Fonction Description
describe() Génère un résumé statistique (comptage, moyenne,
écart-type, quartiles, etc.) pour les colonnes numé-
riques.
mean() Calcule la moyenne des valeurs d’une colonne ou
d’un DataFrame.
median() Retourne la médiane (50e centile) des valeurs.
std() Calcule l’écart-type, mesurant la dispersion des don-
nées.
min(), max() Retourne les valeurs minimale et maximale.
count() Compte le nombre de valeurs non nulles.

Note. Les fonctions comme mean() ou std() s’appliquent aux colonnes numériques. Si une
colonne contient des chaînes ou des données non numériques, elles seront ignorées, sauf si vous
convertissez les données au préalable.

7.4.3 Manipulation des données

[Link] Sélection de colonnes et de lignes

La sélection consiste à extraire des parties spécifiques d’un DataFrame, comme une colonne, une
ligne ou un sous-ensemble de données, pour se concentrer sur les informations pertinentes. Pandas
propose plusieurs méthodes pour effectuer ces sélections, notamment l’utilisation des crochets
([]) et les méthodes loc[] et iloc[] qui permettent d’accéder aux données par étiquettes ou par
positions numériques.
Pour illustrer, reprenez le fichier [Link] créé dans la section précédente, contenant les noms
et les notes en Maths et Physique de six étudiants. Commencez par sélectionner une ou plusieurs
colonnes :
>>> df_notes = pd.read_csv('[Link]')
>>> print(df_notes['Maths'])

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

7.4 Pandas : manipulation et analyse des données 169

0 15.5
1 12.0
2 18.0
3 9.5
4 14.0
5 16.0
Name: Maths, dtype: float64
>>> print(df_notes[['Nom', 'Physique']])
Nom Physique
0 Alice 14.0
1 Bob 13.5
2 Claire 16.5
3 David 11.0
4 Emma 15.0
5 Florent 10.5

La commande df_notes['Maths'] retourne une Series avec les notes en Maths, tandis que
df_notes[['Nom', 'Physique']] produit un DataFrame contenant uniquement les colonnes
colonnes Nom et Physique. Cette distinction est importante : une seule colonne donne une Series,
tandis que plusieurs colonnes donnent un DataFrame.
Pour sélectionner des lignes, utilisez loc[] (basé sur les étiquettes) ou iloc[] (basé sur les
positions numériques). Supposons que vous définissez Nom comme index pour faciliter l’accès par
nom :
>>> df_notes = df_notes.set_index('Nom')
>>> print(df_notes.loc['Alice'])
Maths 15.5
Physique 14.0
Name: Alice, dtype: float64
>>> print(df_notes.iloc[1])
Maths 12.0
Physique 13.5
Name: Bob, dtype: float64

Ici, df_notes.loc['Alice'] retourne une Series avec les notes d’Alice et df_notes.iloc[1]
retourne les notes de Bob (deuxième ligne). Vous pouvez également sélectionner des sous-ensembles
précis :
>>> print(df_notes.loc[['Alice', 'Claire'], 'Maths'])
Nom
Alice 15.5
Claire 18.0
Name: Maths, dtype: float64
>>> print(df_notes.iloc[0:2, 1])
Nom
Alice 14.0
Bob 13.5
Name: Physique, dtype: float64

Ces commandes extraient des sous-ensembles spécifiques, comme les notes en Maths pour Alice et
Claire ou les notes en Physique pour les deux premiers étudiants.
Note. Vérifiez les étiquettes d’index et de colonnes avant d’utiliser loc[], car une étiquette
inexistante provoque une erreur. Avec iloc[], assurez-vous que les indices numériques sont dans
les limites du DataFrame (de 0 à n−1 pour n lignes).
Le tableau suivant récapitule les méthodes de sélection :

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 170 Chapitre 7. Bibliothèques scientifiques

TABLE 7.10 – Méthodes de sélection dans Pandas

Méthode Description
df['colonne'] Sélectionne une colonne sous forme de Series.
df[['col1', 'col2']] Sélectionne plusieurs colonnes sous forme de
DataFrame.
loc[étiquette] Sélectionne des lignes ou cellules par étiquettes d’in-
dex ou de colonnes.
iloc[position] Sélectionne des lignes ou cellules par positions nu-
mériques.

[Link] Filtrage des données avec des conditions

Le filtrage consiste à extraire les lignes d’un DataFrame qui satisfont des critères spécifiques,
comme des notes supérieures à une certaine valeur ou des jours avec des précipitations. À l’instar de
NumPy, Pandas utilise des masques booléens, créés avec des conditions, pour effectuer ce filtrage.

Reprenez le DataFrame df_notes (avec Nom comme index). Pour sélectionner les étudiants ayant
une note en Maths supérieure à 15 :
>>> print(df_notes[df_notes['Maths'] > 15])
Maths Physique
Nom
Alice 15.5 14.0
Claire 18.0 16.5
Florent 16.0 10.5

Le masque df_notes['Maths'] > 15 crée une Series de valeurs booléennes (True si la note
est supérieure à 15, False sinon). Appliquer df_notes[df_notes['Maths'] > 15] retourne un
DataFrame avec les lignes d’Alice, de Claire et de Florent dont les notes en Maths sont supérieures
à 15.
Pour des conditions multiples, combinez les masques avec des opérateurs logiques (& pour « ET », |
pour « OU », ~ pour « NON »). Par exemple, pour trouver les étudiants avec une note en Maths
supérieure à 15 et en Physique supérieure à 14 :
>>> masque = (df_notes['Maths'] > 15) & (df_notes['Physique'] > 14)
>>> print(df_notes[masque])
Maths Physique
Nom
Claire 18.0 16.5

Les parenthèses garantissent l’ordre correct des opérations et & combine les conditions. Le résultat
montre que seule Claire satisfait les deux critères.
La méthode isin() permet de filtrer basé sur une liste de valeurs. Par exemple, pour sélectionner
Alice et Bob :
>>> print(df_notes[df_notes.[Link](['Alice', 'Bob'])])
Maths Physique
Nom
Alice 15.5 14.0
Bob 12.0 13.5

Ici, df_notes.[Link](['Alice', 'Bob']) crée un masque pour les lignes dont l’index est

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.4 Pandas : manipulation et analyse des données 171

Alice ou Bob.
Une alternative est la méthode query(), qui utilise une syntaxe de chaîne pour exprimer des
conditions. Par exemple, avec le DataFrame [Link] :
>>> df_meteo = pd.read_excel('[Link]')
>>> print(df_meteo.query('Température > 6'))
Date Température Précipitations
1 2023−01−02 6.5 2.5
3 2023−01−04 7.0 0.0
4 2023−01−05 8.5 1.0

La requête 'Température > 6' retourne les lignes où la température dépasse 6°C, montrant trois
jours correspondants. query() est concise mais moins flexible pour des conditions complexes.
Note. Lors de l’utilisation de conditions multiples, placez chaque condition entre parenthèses
pour éviter des erreurs de priorité d’opérateurs. Par exemple, df['A'] > 5 & df['B'] < 10 peut
produire des résultats incorrects sans parenthèses.
Note. La méthode query() est utile pour des filtres simples, mais les masques booléens sont plus
courants dans la pratique, car ils sont plus flexibles et compatibles avec des opérations avancées.
Le tableau suivant récapitule les outils de filtrage :

TABLE 7.11 – Outils de filtrage dans Pandas

Outil Description
df[condition] Filtre les lignes avec un masque booléen (par
exemple, df['col'] > valeur).
isin(liste) Filtre les lignes où une colonne ou l’index est dans
une liste de valeurs.
query('condition') Filtre avec une condition exprimée sous forme de
chaîne.

[Link] Modification et ajout de données

Modifier et ajouter des données dans un DataFrame permet de corriger des erreurs, d’enrichir les
données avec de nouvelles informations ou de supprimer des éléments inutiles. Ces opérations
sont essentielles pour préparer un dataset à une analyse. Pandas offre des méthodes simples pour
modifier des valeurs, ajouter des colonnes ou des lignes et supprimer des éléments.
Reprenez df_notes. Pour corriger une note erronée, par exemple en changeant la note en Maths de
David à 10.0 :
>>> df_notes.loc['David', 'Maths'] = 10.0
>>> print(df_notes)
Maths Physique
Nom
Alice 15.5 14.0
Bob 12.0 13.5
Claire 18.0 16.5
David 10.0 11.0
Emma 14.0 15.0
Florent 16.0 10.5

La commande df_notes.loc['David', 'Maths'] = 10.0 met à jour la cellule spécifiée, rem-

plaçant 9.5 par 10.0. Pour modifier plusieurs valeurs selon une condition, par exemple augmenter

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

172 Chapitre 7. Bibliothèques scientifiques

toutes les notes en Physique inférieures à 12 de 1 point :

1 df_notes.loc[df_notes['Physique'] < 12, 'Physique'] += 1
2 print(df_notes)

Maths Physique
Nom
Alice 15.5 14.0
Bob 12.0 13.5
Claire 18.0 16.5
David 10.0 12.0
Emma 14.0 15.0

Ici, le masque df_notes['Physique'] < 12 identifie les lignes de David et de Florent, et ajoute 1
à leurs notes.
Pour ajouter une nouvelle colonne, par exemple une moyenne des notes en Maths et Physique :
>>> df_notes['Moyenne'] = (df_notes['Maths'] + df_notes['Physique']) / 2
>>> print(df_notes)
Maths Physique Moyenne
Nom
Alice 15.5 14.0 14.75
Bob 12.0 13.5 12.75
Claire 18.0 16.5 17.25
David 10.0 12.0 11.00
Emma 14.0 15.0 14.50
Florent 16.0 11.5 13.75

La nouvelle colonne Moyenne est calculée comme la moyenne des deux notes pour chaque étudiant.
Pour ajouter une nouvelle ligne, par exemple un nouvel étudiant, utilisez [Link]. Créez un
DataFrame pour le nouvel étudiant et concaténez-le :

>>> nouvel_etudiant = [Link]({

... 'Maths': [16.0],
... 'Physique': [15.5],
... 'Moyenne': [15.75]
... }, index=['Georges'])
>>> df_notes = [Link]([df_notes, nouvel_etudiant])
>>> print(df_notes)
Maths Physique Moyenne
Alice 15.5 14.0 14.75
Bob 12.0 13.5 12.75
Claire 18.0 16.5 17.25
David 10.0 12.0 11.00
Emma 14.0 15.0 14.50
Florent 16.0 11.5 13.75
Georges 16.0 15.5 15.75

La fonction [Link] ajoute la ligne de Georges en alignant les colonnes existantes. La Moyenne
est précalculée pour correspondre à la structure du DataFrame.
Enfin, pour supprimer une colonne ou une ligne, utilisez drop. Par exemple, pour supprimer la
colonne Physique :
>>> df_notes = df_notes.drop('Physique', axis=1)
>>> print(df_notes)

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.4 Pandas : manipulation et analyse des données 173

Maths Moyenne
Alice 15.5 14.75
Bob 12.0 12.75
Claire 18.0 17.25
David 10.0 11.00
Emma 14.0 14.50
Florent 16.0 13.75
Georges 16.0 15.75

L’argument axis=1 indique une suppression de colonne. Pour supprimer une ligne, par exemple
David :
1 df_notes = df_notes.drop('David', axis=0)
2 print(df_notes)

>>> df_notes = df_notes.drop('David', axis=0)

>>> print(df_notes)
Maths Moyenne
Alice 15.5 14.75
Bob 12.0 12.75
Claire 18.0 17.25
Emma 14.0 14.50
Florent 16.0 13.75
Georges 16.0 15.75

L’argument axis=0 spécifie une suppression de ligne. Notez que drop ne modifie pas le DataFrame
original à moins d’assigner le résultat ou d’utiliser inplace=True.
Note. Lors de l’ajout de lignes ou de colonnes, assurez-vous que les types et les noms des colonnes
correspondent à ceux du DataFrame existant pour éviter des erreurs d’alignement. Avec drop,
vérifiez l’argument axis pour distinguer les lignes (axis=0) des colonnes (axis=1).
Le tableau suivant récapitule les méthodes de modification :

TABLE 7.12 – Méthodes de modification dans Pandas

Méthode Description
loc[], iloc[] Modifie des cellules ou sous-ensembles spécifiques.
df['col'] = ... Ajoute ou modifie une colonne avec des valeurs ou
calculs.
[Link] Ajoute des lignes en combinant des DataFrames.
drop(label, axis) Supprime des lignes (axis=0, par défaut) ou des co-
lonnes (axis=1). Lorsqu’on ajoute inplace=True,
le DataFrame est modifié sur place.

7.4.4 Analyse des données

[Link] Regroupement et agrégation

Le regroupement consiste à organiser les données en catégories basées sur une ou plusieurs colonnes
puis à appliquer des fonctions d’agrégation, comme la moyenne ou la somme, pour résumer chaque
groupe. Cette opération est réalisée avec la méthode groupby. Elle est utile pour analyser des
données structurées.
Reprenez le fichier [Link] créé précédemment, contenant les noms et les notes en Maths et

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

174 Chapitre 7. Bibliothèques scientifiques

Physique de six étudiants.

Créons un nouveau DataFrame pour illustrer ce concept :
1 import pandas as pd
2
3 notes = {
4 'Nom': ['Alice', 'Alice', 'Bob', 'Bob', 'Claire', 'Claire', 'David', '
David', 'Emma', 'Emma'],
5 'Matière': ['Maths', 'Physique', 'Maths', 'Physique', 'Maths', 'Physique
', 'Maths', 'Physique', 'Maths', 'Physique'],
6 'Note': [15.5, 14.0, 12.0, 13.5, 18.0, 16.5, 9.5, 11.0, 14.0, 15.0]
7 }
8 df_notes = [Link](notes)
9 print(df_notes)
10
11 # Regroupement par matière et calcul de la moyenne
12 groupe = df_notes.groupby('Matière')
13 print(groupe['Note'].mean())

Nom Matière Note

0 Alice Maths 15.5
1 Alice Physique 14.0
2 Bob Maths 12.0
3 Bob Physique 13.5
4 Claire Maths 18.0
5 Claire Physique 16.5
6 David Maths 9.5
7 David Physique 11.0
8 Emma Maths 14.0
9 Emma Physique 15.0
Matière
Maths 13.8
Physique 14.0
Name: Note, dtype: float64

Ce code crée un DataFrame où chaque ligne représente une note pour une matière spécifique. La
méthode groupby('Matière') regroupe les lignes par valeur de la colonne Matière (Maths ou
Physique) et mean() calcule la moyenne des notes pour chaque groupe. Le résultat montre que la
moyenne en Maths est de 13.8 et en Physique de 14.0.
Vous pouvez appliquer plusieurs fonctions d’agrégation avec agg. Par exemple, pour obtenir la
moyenne et le nombre de notes par matière :
1 print(groupe['Note'].agg(['mean', 'count']))

mean count
Matière
Maths 13.8 5
Physique 14.0 5

La fonction agg(['mean', 'count']) produit un DataFrame avec la moyenne et le nombre de

notes pour chaque matière.
Pour un exemple avec [Link], regroupez les données par précipitations (par exemple, jours
secs vs pluvieux) :
>>> df_meteo = pd.read_excel('[Link]')

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.4 Pandas : manipulation et analyse des données 175

>>> df_meteo['Statut'] = df_meteo['Précipitations'].apply(lambda x: 'Sec' if x

== 0 else 'Pluvieux')
>>> print(df_meteo.groupby('Statut')['Température'].mean())
Statut
Pluvieux 6.1
Sec 6.0
Name: Température, dtype: float64

Ce code ajoute une colonne Statut indiquant si le jour est sec (Précipitations == 0) ou pluvieux
puis calcule la température moyenne pour chaque groupe. Les jours pluvieux ont une température
moyenne de 6.1°C, contre 6°C pour les jours secs.
Note. Lors de l’utilisation de groupby, assurez-vous que la colonne de regroupement contient des
catégories bien définies. Une colonne avec trop de valeurs uniques (par exemple, des températures
continues) peut produire un grand nombre de groupes inutiles.
Le tableau suivant récapitule les fonctions d’agrégation courantes :

TABLE 7.13 – Fonctions d’agrégation pour groupby

Fonction Description
mean() Calcule la moyenne des valeurs dans chaque groupe.
sum() Calcule la somme des valeurs dans chaque groupe.
count() Compte le nombre de valeurs non nulles par groupe.
min(), max() Retourne les valeurs minimale et maximale par
groupe.
agg([f1, f2]) Applique plusieurs fonctions d’agrégation simultané-
ment.

[Link] Statistiques avancées et corrélations

Au-delà des statistiques descriptives de base, Pandas permet de calculer des mesures avancées,
comme l’écart-type, la variance, les quantiles et les corrélations entre variables. Ces outils, bien
que reposant sur des concepts statistiques, sont accessibles grâce à des fonctions simples et aident
à comprendre la variabilité et les relations dans vos données. Par exemple, vous pourriez vouloir
savoir si les notes en Maths et en Physique sont corrélées ou identifier les températures extrêmes
dans un relevé météorologique.
Reprenez le DataFrame [Link] initial. Pour calculer l’écart-type et la variance des notes :
>>> df_notes = pd.read_csv('[Link]')
>>> print(df_notes[['Maths', 'Physique']].std())
Maths 3.044120
Physique 2.311205
dtype: float64
>>> print(df_notes[['Maths', 'Physique']].var())
Maths 9.266667
Physique 5.341667
dtype: float64

L’écart-type (std()) mesure la dispersion des notes autour de la moyenne : un écart-type plus élevé
en Maths (3.04) indique une plus grande variabilité qu’en Physique (2.31). La variance (var()),
qui est le carré de l’écart-type, confirme cette observation (9.2 pour Maths, 5.3 pour Physique).
Pour calculer les quantiles, qui divisent les données en pourcentages, utilisez quantile. Par

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

176 Chapitre 7. Bibliothèques scientifiques

exemple, pour trouver le 90e centile des notes en Maths :

>>> print(df_notes['Maths'].quantile(0.9))
17.0

Le résultat (17.0) indique que 90% des notes en Maths sont inférieures ou égales à 17.1, une mesure
utile pour identifier les performances exceptionnelles.
La corrélation mesure la relation linéaire entre deux variables numériques. Pandas utilise corr()
pour calculer le coefficient de corrélation de Pearson, qui varie de -1 (corrélation négative parfaite)
à 1 (corrélation positive parfaite), avec 0 indiquant aucune corrélation. Pour examiner la corrélation
entre les notes en Maths et en Physique :
>>> print(df_notes[['Maths', 'Physique']].corr())
Maths Physique
Maths 1.000000 0.514054
Physique 0.514054 1.000000

La corrélation de 0.51 entre Maths et Physique suggère une corrélation positive modérée : les
étudiants qui ont de bonnes notes en Maths ont souvent aussi de bonnes notes en Physique, et
inversement. La diagonale (1.0) reflète la corrélation d’une variable avec elle-même.
Pour un exemple avec [Link], calculez la corrélation entre Température et Précipitations :
>>> print(df_meteo[['Température', 'Précipitations']].corr())
Température Précipitations
Température 1.000000 −0.655985
Précipitations −0.655985 1.000000

La corrélation de -0.16 indique une relation négative modérée à forte : plus la température est
élevée, moins il y a de précipitations, et inversement. Plus simplement, il fait souvent plus sec
quand il fait chaud.
Notes.
• La corrélation de Pearson suppose une relation linéaire. Si les variables ont une relation non
linéaire ou contiennent des valeurs aberrantes, le coefficient peut ne pas refléter fidèlement
leur lien. Vérifiez toujours vos données avec des visualisations, comme des diagrammes de
dispersion, avant d’interpréter les corrélations.
• Pour des analyses avancées, vous pouvez utiliser corr(method='spearman') ou corr(
method='kendall') pour des corrélations non linéaires, mais ces méthodes sont générale-
ment abordées dans des cours plus avancés.
Le tableau suivant résume les types de corrélations disponibles dans corr() :

TABLE 7.14 – Types de corrélations dans corr()

Méthode Description
'pearson' Mesure la corrélation linéaire (par défaut).
'spearman' Mesure la corrélation basée sur les rangs, adaptée
aux relations non linéaires.
'kendall' Mesure la corrélation ordinale, robuste pour les petits
échantillons.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.4 Pandas : manipulation et analyse des données 177

[Link] Tableau récapitulatif des fonctions d’analyse

Pandas propose une large gamme de fonctions pour analyser les données, allant des statistiques
descriptives aux mesures de relation. Ces fonctions, appliquées à des Series ou des DataFrames,
sont essentielles pour résumer, comparer et interpréter les données. Le tableau suivant liste les
fonctions couramment utilisées, avec leurs descriptions et cas d’usage, pour vous offrir une référence
complète et pratique.

TABLE 7.15 – Fonctions d’analyse courantes dans Pandas

Fonction Description
mean() Calcule la moyenne des valeurs, utile pour résumer une variable
(par exemple, moyenne des notes).
median() Retourne la médiane (50e centile), robuste aux valeurs aberrantes
(par exemple, médiane des températures).
std() Calcule l’écart-type, mesurant la dispersion autour de la moyenne
(par exemple, variabilité des notes).
var() Calcule la variance, indiquant la dispersion au carré (par exemple,
variance des précipitations).
min() Retourne la valeur minimale, pour identifier les extrêmes (par
exemple, température la plus basse).
max() Retourne la valeur maximale, pour identifier les pics (par exemple,
note la plus élevée).
sum() Calcule la somme des valeurs, utile pour les totaux (par exemple,
total des précipitations).
count() Compte le nombre de valeurs non nulles, pour vérifier la complé-
tude (par exemple, nombre de notes).
quantile(q) Calcule le quantile spécifié (par exemple, q=0.25 pour le 25e
centile), pour étudier la répartition.
describe() Génère un résumé statistique (comptage, moyenne, écart-type,
quartiles, etc.) pour les colonnes numériques.
corr() Calcule la matrice de corrélations entre colonnes numériques, pour
étudier les relations (par exemple, corrélation Maths-Physique).
cov() Calcule la covariance entre colonnes, mesurant la variation
conjointe (par exemple, covariance des notes).
mode() Retourne la valeur la plus fréquente, utile pour les données catégo-
riques (par exemple, statut météo le plus courant).
nunique() Compte le nombre de valeurs uniques, pour évaluer la diversité
(par exemple, nombre de matières distinctes).
value_counts() Compte la fréquence de chaque valeur dans une Series, pour ana-
lyser les distributions (par exemple, fréquence des statuts météo).

Note. Certaines fonctions, comme sum() ou count(), peuvent être utilisées avec groupby pour des
analyses par groupe, tandis que corr() et cov() s’appliquent uniquement aux colonnes numériques.
Testez toujours vos données pour vous assurer qu’elles sont adaptées à la fonction choisie.

7.4.5 Gestion des données manquantes

Dans les ensembles de données réels, il est fréquent de rencontrer des valeurs manquantes, re-
présentées par NaN (Not a Number) ou None dans Pandas. Ces absences peuvent survenir pour
diverses raisons : erreurs de collecte, données non disponibles ou problèmes lors de l’importation.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 178 Chapitre 7. Bibliothèques scientifiques

La gestion des données manquantes est une étape importante pour garantir la fiabilité des analyses,
car elles peuvent fausser les statistiques ou empêcher certaines opérations. Pandas offre des outils
simples et puissants pour détecter, traiter et évaluer l’impact des valeurs manquantes, permettant de
préparer les données pour des analyses performantes.

[Link] Détection des valeurs manquantes

La première étape pour gérer les données manquantes consiste à les identifier dans un DataFrame.
Pandas fournit des méthodes comme isna(), notna() et info() pour localiser et quantifier ces
valeurs, vous permettant de comprendre l’étendue du problème avant de décider comment le traiter.
Pour illustrer, modifiez le fichier [Link] utilisé précédemment pour inclure des valeurs man-
quantes en simulant un scénario où certaines notes n’ont pas été enregistrées :
1 import pandas as pd
2 import numpy as np
3
4 # Création d'un DataFrame avec des valeurs manquantes
5 notes = {
6 'Nom': ['Alice', 'Bob', 'Claire', 'David', 'Emma'],
7 'Maths': [15.5, 12.0, [Link], 9.5, 14.0],
8 'Physique': [14.0, [Link], 16.5, 11.0, [Link]]
9 }
10 df_notes = [Link](notes)
11 df_notes.to_csv('notes_manquantes.csv', index=False)
12
13 # Détection avec info()
14 print(df_notes.info())

<class '[Link]'>
RangeIndex: 5 entries, 0 to 4
Data columns (total 3 columns):
# Column Non−Null Count Dtype
−−− −−−−−− −−−−−−−−−−−−−− −−−−−
0 Nom 5 non−null object
1 Maths 4 non−null float64
2 Physique 3 non−null float64
dtypes: float64(2), object(1)
memory usage: 252.0+ bytes

La méthode info() montre que la colonne Maths a 4 valeurs non nulles (une manquante) et
Physique a 3 valeurs non nulles (deux manquantes), tandis que Nom est complète. Cela indique que
des données sont absentes pour certains étudiants.
Pour localiser précisément les valeurs manquantes, utilisez isna(), qui retourne un DataFrame de
valeurs booléennes (True pour les NaN, False sinon) :
>>> df_notes = pd.read_csv('notes_manquantes.csv')
>>> print(df_notes.isna())
Nom Maths Physique
0 False False False
1 False False True
2 False True False
3 False False False
4 False False True

Ce résultat montre que Claire manque une note en Maths, Bob et Emma manquent une note en

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.4 Pandas : manipulation et analyse des données 179

Physique. Pour compter le nombre de valeurs manquantes par colonne, combinez isna() avec
sum() :

>>> print(df_notes.isna().sum())
Nom 0
Maths 1
Physique 2
dtype: int64

La méthode notna() fonctionne de manière inverse, retournant True pour les valeurs présentes.
Par exemple, pour vérifier les lignes avec des notes complètes :
>>> print(df_notes[df_notes.notna().all(axis=1)])
Nom Maths Physique
0 Alice 15.5 14.0
3 David 9.5 11.0

On a utilisé notna().all(axis=1) pour identifier les lignes où toutes les colonnes sont non nulles,
cela montre que seuls Alice et David ont des notes complètes.
Note. Lors de l’importation de fichiers, Pandas peut interpréter certaines valeurs (par exemple, «
NA », « - ») comme manquantes si spécifié dans pd.read_csv ou pd.read_excel avec l’argument
na_values. Vérifiez toujours les données importées avec info() pour détecter ces cas.

[Link] Traitement : suppression ou imputation

Une fois les valeurs manquantes identifiées, vous devez décider de les supprimer ou de les remplacer
(imputer) par des valeurs appropriées. La suppression, réalisée avec dropna, élimine les lignes
ou colonnes contenant des NaN, tandis que l’imputation, via fillna ou des méthodes comme
l’interpolation, remplace les NaN par des estimations. Chaque approche a ses avantages et ses limites
et le choix dépend du contexte et de l’impact sur l’analyse.
Reprenez df_notes avec les valeurs manquantes. Pour supprimer les lignes contenant au moins
une valeur manquante :
>>> df_notes = pd.read_csv('notes_manquantes.csv')
>>> df_clean = df_notes.dropna()
>>> print(df_clean)
Nom Maths Physique
0 Alice 15.5 14.0
3 David 9.5 11.0

La méthode dropna() supprime les lignes de Bob, Claire, et Emma, car elles contiennent des NaN,
ne laissant que les lignes complètes. Pour supprimer uniquement les lignes où toutes les valeurs
numériques sont manquantes, utilisez how='all' (inutile ici, car aucune ligne n’est entièrement
NaN).

Pour supprimer des colonnes avec des valeurs manquantes :

>>> df_clean_cols = df_notes.dropna(axis=1)
>>> print(df_clean_cols)
Nom
0 Alice
1 Bob
2 Claire
3 David
4 Emma

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

180 Chapitre 7. Bibliothèques scientifiques

L’argument axis=1 supprime Maths et Physique, car elles contiennent des NaN, ne laissant que
Nom. Cette approche est rarement utilisée, car elle peut éliminer des variables essentielles.

L’imputation remplace les NaN par des valeurs estimées. Une méthode courante est de remplir avec
la moyenne de la colonne :
>>> df_impute = df_notes.copy()
>>> df_impute['Maths'] = df_impute['Maths'].fillna(df_impute['Maths'].mean())
>>> df_impute['Physique'] = df_impute['Physique'].fillna(df_impute['Physique
'].mean())
>>> print(df_impute)
Nom Maths Physique
0 Alice 15.50 14.000000
1 Bob 12.00 13.833333
2 Claire 12.75 16.500000
3 David 9.50 11.000000
4 Emma 14.00 13.833333

Ce code remplace la note manquante en Maths (Claire) par la moyenne des notes en Maths (12.75)
et les notes manquantes en Physique (Bob, Emma) par la moyenne en Physique (13.833). La
méthode copy() évite de modifier df_notes original.
Pour un exemple avec [Link], imputez les précipitations manquantes (en supposant une valeur
manquante ajoutée) par interpolation linéaire, adaptée aux données temporelles :
1 import pandas as pd
2 import numpy as np
3
4 meteo = {
5 'Date': ['2023−01−01', '2023−01−02', '2023−01−03', '2023−01−04',
6 '2023−01−05', '2023−01−06', '2023−01−07'],
7 'Température': [5.0, 6.5, 4.0, 7.0, 8.5, 5.5, 6.0],
8 'Précipitations': [0.0, 2.5, [Link], 0.0, 1.0, 5.0, 3.0]
9 }
10 df_meteo = [Link](meteo)
11 df_meteo.to_excel('meteo_manquantes.xlsx', index=False)
12
13 df_meteo['Précipitations'] = df_meteo['Précipitations'].interpolate(method='
linear')
14 print(df_meteo)

Date Température Précipitations

0 2023−01−01 5.0 0.00
1 2023−01−02 6.5 2.50
2 2023−01−03 4.0 1.25
3 2023−01−04 7.0 0.00
4 2023−01−05 8.5 1.00
5 2023−01−06 5.5 5.00
6 2023−01−07 6.0 3.00

L’interpolation linéaire estime la valeur manquante du 3 janvier (1.25 mm) comme la moyenne des
valeurs adjacentes (2.5 et 0.0), ce qui est adapté aux données continues comme les précipitations.
Note. L’imputation par la moyenne peut introduire un biais, surtout si les valeurs manquantes ne
sont pas aléatoires. L’interpolation est plus adaptée aux données séquentielles, comme les séries
temporelles, mais peut être inexacte si les variations sont irrégulières.
Le tableau suivant récapitule les méthodes de traitement :

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.4 Pandas : manipulation et analyse des données 181

TABLE 7.16 – Méthodes de traitement des valeurs manquantes

Méthode Description
dropna() Supprime les lignes (axis=0, par défaut) ou colonnes
(axis=1) contenant des NaN.
dropna(how='all') Supprime les lignes ou colonnes où toutes les valeurs
sont NaN.
fillna(valeur) Remplace les NaN par une valeur fixe (par exemple,
0, moyenne).
interpolate(method='linear') Estime les NaN par interpolation linéaire, adapté aux
données continues.

Le traitement des valeurs manquantes prépare vos données pour l’analyse, mais il est important
d’évaluer son impact.

[Link] Impact sur l’analyse

Le choix de supprimer ou d’imputer les valeurs manquantes peut influencer les résultats de vos
analyses, comme les moyennes, les corrélations ou les regroupements. Une suppression excessive
peut réduire la taille de l’échantillon, entraînant une perte d’information, tandis qu’une imputation
inappropriée peut introduire des biais.
Reprenez df_notes avec les valeurs manquantes et comparez la moyenne des notes avant et après
traitement. Calculez d’abord la moyenne sans traitement :
>>> df_notes = pd.read_csv('notes_manquantes.csv')
>>> print(df_notes[['Maths', 'Physique']].mean())
Maths 12.750000
Physique 13.833333
dtype: float64

Les moyennes sont calculées en ignorant les NaN (4 notes pour Maths, 3 pour Physique). Après
suppression des lignes avec NaN :
>>> print(df_notes.dropna()[['Maths', 'Physique']].mean())
Maths 12.5
Physique 12.5
dtype: float64

La suppression réduit l’échantillon à deux lignes (Alice, David), modifiant légèrement les moyennes
(12.5 au lieu de 12.75 et 13.83). Cela montre une perte d’information, car les données de Claire,
Bob et Emma sont exclues.
Comparez avec l’imputation par la moyenne (utilisant df_impute créé précédemment) :
>>> print(df_impute[['Maths', 'Physique']].mean())
Maths 12.750000
Physique 13.833333
dtype: float64

L’imputation préserve toutes les lignes, maintenant les moyennes initiales (12.75, 13.83), mais elle
suppose que les valeurs manquantes sont similaires à la moyenne, ce qui peut ne pas refléter la
réalité (par exemple, la note manquante de Claire pourrait être plus élevée).

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 182 Chapitre 7. Bibliothèques scientifiques

Note. Avant de finaliser le traitement, comparez toujours les statistiques (moyennes, écarts-types)
ou les visualisations avant et après pour évaluer l’impact. Si possible, documentez la méthode
choisie et ses hypothèses pour garantir la transparence de votre analyse.

7.4.6 Fusion et jointure de datasets

L’analyse des données nécessite souvent de combiner plusieurs sources d’information pour obtenir
une vue complète, comme réunir les notes des étudiants avec leurs informations personnelles ou
agréger des relevés météorologiques de différentes périodes. Pandas offre des outils puissants pour
fusionner des datasets, soit en les concaténant pour ajouter des lignes ou des colonnes, soit en les
joignant à l’aide de clés communes pour relier des informations complémentaires.

[Link] Concaténation de datasets

La concaténation consiste à combiner plusieurs DataFrames en les alignant soit verticalement (ajout
de lignes, comme empiler des pages) soit horizontalement (ajout de colonnes, comme juxtaposer
des tableaux). La fonction [Link] est utilisée pour cette tâche.
Pour illustrer la concaténation verticale, créez deux DataFrames représentant des notes d’étudiants
de deux classes différentes, puis combinez-les :
1 import pandas as pd
2
3 # Création de deux DataFrames
4 classe1 = {
5 'Nom': ['Alice', 'Bob', 'Claire'],
6 'Maths': [15.5, 12.0, 18.0],
7 'Physique': [14.0, 13.5, 16.5]
8 }
9 classe2 = {
10 'Nom': ['David', 'Emma'],
11 'Maths': [9.5, 14.0],
12 'Physique': [11.0, 15.0]
13 }
14 df_classe1 = [Link](classe1)
15 df_classe2 = [Link](classe2)
16
17 # Concaténation verticale
18 df_notes = [Link]([df_classe1, df_classe2], ignore_index=True)
19 print(df_notes)

Nom Maths Physique

0 Alice 15.5 14.0
1 Bob 12.0 13.5
2 Claire 18.0 16.5
3 David 9.5 11.0
4 Emma 14.0 15.0

La fonction [Link]([df_classe1, df_classe2]) combine les deux DataFrames verticale-

ment en alignant les colonnes par leurs noms (Nom, Maths, Physique). L’argument ignore_index=
True réinitialise l’index pour obtenir une numérotation continue (0 à 4), évitant des index dupliqués.
Enlevez cet argument et observez la différence.
Pour une concaténation horizontale, ajoutez une nouvelle colonne, par exemple une note en Chimie,
à df_notes :

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.4 Pandas : manipulation et analyse des données 183

1 chimie = [Link]({
2 'Chimie': [13.0, 11.5, 17.0, 10.0, 14.5]
3 })
4 df_notes_avec_chimie = [Link]([df_notes, chimie], axis=1)
5 print(df_notes_avec_chimie)

Nom Maths Physique Chimie

0 Alice 15.5 14.0 13.0
1 Bob 12.0 13.5 11.5
2 Claire 18.0 16.5 17.0
3 David 9.5 11.0 10.0
4 Emma 14.0 15.0 14.5

L’argument axis=1 indique une concaténation horizontale, ajoutant la colonne Chimie à droite du
DataFrame. Les lignes sont alignées par index, ce qui nécessite que les DataFrames aient le même
nombre de lignes.
Note. Lors de la concaténation, assurez-vous que les DataFrames ont des structures compatibles.
Pour une concaténation verticale, les colonnes doivent avoir les mêmes noms ; pour une concaténa-
tion horizontale, le nombre de lignes doit correspondre. Des incohérences peuvent introduire des
NaN ou des erreurs.

Le tableau suivant récapitule les paramètres clés de [Link] :

TABLE 7.17 – Paramètres de [Link]

Paramètre Description
objs Liste des DataFrames à concaténer.
axis 0 pour une concaténation verticale (lignes), 1 pour
horizontale (colonnes).
ignore_index Si True, réinitialise l’index du DataFrame résultant.
join Type d’alignement ('inner' pour l’intersection, '
outer' pour l’union des colonnes).

[Link] Jointure avec merge et join

La jointure relie deux DataFrames en fonction d’une ou plusieurs colonnes clés. Pandas propose
merge pour des jointures basées sur des colonnes et join pour des jointures basées sur des index,
avec différents types de jointures : inner (intersection), left (priorité au premier DataFrame),
right (priorité au second) et outer (union).

Pour illustrer, créez un DataFrame avec des informations sur les étudiants (par exemple, leur classe)
et joignez-le à df_notes :
1 # Création d'un DataFrame d'informations
2 infos = {
3 'Nom': ['Alice', 'Bob', 'Claire', 'Fiona'],
4 'Classe': ['A', 'B', 'A', 'B']
5 }
6 df_infos = [Link](infos)
7
8 # Jointure avec merge
9 df_merge = [Link](df_notes, df_infos, on='Nom', how='inner')
10 print(df_merge)

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

184 Chapitre 7. Bibliothèques scientifiques

Nom Maths Physique Classe

0 Alice 15.5 14.0 A
1 Bob 12.0 13.5 B
2 Claire 18.0 16.5 A

La fonction [Link] joint df_notes et df_infos sur la colonne Nom, avec une jointure inner
(seules les lignes avec des Nom présents dans les deux DataFrames sont conservées). David et
Emma (absents de df_infos) et Fiona (absente de df_notes) sont exclus.
Pour inclure tous les étudiants de df_notes, utilisez une jointure left :
1 df_merge_left = [Link](df_notes, df_infos, on='Nom', how='left')
2 print(df_merge_left)

Nom Maths Physique Classe

0 Alice 15.5 14.0 A
1 Bob 12.0 13.5 B
2 Claire 18.0 16.5 A
3 David 9.5 11.0 NaN
4 Emma 14.0 15.0 NaN

La jointure left conserve toutes les lignes de df_notes et ajoute NaN pour David et Emma qui
n’ont pas de correspondance dans df_infos.
La méthode join est utile lorsque les DataFrames partagent un index commun. Définissez Nom
comme index pour les deux DataFrames et effectuez une jointure :
1 df_notes_idx = df_notes.set_index('Nom')
2 df_infos_idx = df_infos.set_index('Nom')
3 df_join = df_notes_idx.join(df_infos_idx, how='inner')
4 print(df_join)

Maths Physique Classe

Nom
Alice 15.5 14.0 A
Bob 12.0 13.5 B
Claire 18.0 16.5 A

La méthode join aligne les DataFrames sur leurs index (Nom) et produit un résultat similaire à la
jointure inner de merge. join est plus concise lorsque les index sont déjà définis.
Note. Lors d’une jointure, vérifiez que la colonne ou l’index de jointure (par exemple, Nom) est
présent dans les deux DataFrames et a des valeurs compatibles. Des clés dupliquées ou des types
de données différents (par exemple, chaînes vs nombres) peuvent provoquer des erreurs ou des
résultats inattendus.
Le tableau suivant récapitule les types de jointures :

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.4 Pandas : manipulation et analyse des données 185

TABLE 7.18 – Types de jointures dans merge et join

Type Description
inner Conserve uniquement les lignes avec des clés pré-
sentes dans les deux DataFrames.
left Conserve toutes les lignes du premier DataFrame,
avec NaN pour les clés absentes du second.
right Conserve toutes les lignes du second DataFrame,
avec NaN pour les clés absentes du premier.
outer Conserve toutes les lignes des deux DataFrames,
avec NaN là où les clés ne correspondent pas.

[Link] Gestion des doublons après fusion

Une fusion ou une concaténation peut créer des doublons, c’est-à-dire des lignes identiques ou
partiellement redondantes qui risquent de fausser les analyses (par exemple, en comptant deux fois
un étudiant). Pandas fournit duplicated pour détecter les doublons et drop_duplicates pour les
supprimer.
Pour illustrer, modifiez df_infos pour inclure un doublon (deux entrées pour Alice) et effectuez
une jointure :
1 # Création d'un DataFrame avec un doublon
2 infos_doublon = {
3 'Nom': ['Alice', 'Alice', 'Bob', 'Claire'],
4 'Classe': ['A', 'A', 'B', 'A']
5 }
6 df_infos_doublon = [Link](infos_doublon)
7
8 # Jointure avec doublon
9 df_merge_doublon = [Link](df_notes, df_infos_doublon, on='Nom', how='inner
')
10 print(df_merge_doublon)

Nom Maths Physique Classe

0 Alice 15.5 14.0 A
1 Alice 15.5 14.0 A
2 Bob 12.0 13.5 B
3 Claire 18.0 16.5 A

La jointure crée deux lignes pour Alice, car Nom='Alice' apparaît deux fois dans df_infos_doublon
. Détectez les doublons avec duplicated :
1 print(df_merge_doublon.duplicated())

0 False
1 True
2 False
3 False
dtype: bool

La méthode duplicated() marque la deuxième ligne d’Alice comme un doublon (True). Pour
compter les doublons :

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 186 Chapitre 7. Bibliothèques scientifiques

1 print(df_merge_doublon.duplicated().sum())

Pour supprimer les doublons, utilisez drop_duplicates :

1 df_sans_doublon = df_merge_doublon.drop_duplicates()
2 print(df_sans_doublon)

Nom Maths Physique Classe

0 Alice 15.5 14.0 A
2 Bob 12.0 13.5 B
3 Claire 18.0 16.5 A

La méthode drop_duplicates() conserve la première occurrence de chaque ligne unique, suppri-

mant la ligne dupliquée d’Alice. Vous pouvez spécifier keep='last' pour conserver la dernière
occurrence ou keep=False pour supprimer toutes les lignes dupliquées.
Note. Après une fusion, vérifiez toujours la présence de doublons avec duplicated, surtout si les
clés de jointure (comme Nom) ne sont pas uniques. Vous pouvez aussi utiliser subset=['col1', '
col2'] dans duplicated ou drop_duplicates pour ne considérer que certaines colonnes.

7.4.7 Exportation des résultats

Après avoir manipulé, analysé et enrichi vos données avec Pandas, il est essentiel de pouvoir
sauvegarder les résultats pour les partager, les archiver ou les utiliser dans d’autres outils. Pandas
permet d’exporter les DataFrames vers des formats courants comme CSV et Excel et de générer
des visualisations avec Matplotlib pour illustrer vos analyses.

[Link] Sauvegarde vers des fichiers : CSV, Excel

Exporter un DataFrame vers un fichier consiste à le convertir en un format lisible par d’autres
logiciels, comme un tableur ou un système de gestion de données. Pandas propose des méthodes
comme to_csv pour les fichiers CSV (Comma-Separated Values) et to_excel pour les fichiers
Excel, qui sont largement utilisés pour leur simplicité et leur compatibilité. Nous avons déjà utilisé
ces deux méthodes plus haut.
Reprenez le DataFrame [Link] initial, contenant les noms et les notes en Maths et Physique
de six étudiants. Après avoir ajouté une colonne Moyenne, exportez le DataFrame modifié vers un
nouveau fichier CSV (pour un fichier Excel, utilisez to_excel) :
1 import pandas as pd
2
3 # Chargement et ajout de la colonne Moyenne
4 df_notes = pd.read_csv('[Link]')
5 df_notes['Moyenne'] = (df_notes['Maths'] + df_notes['Physique']) / 2
6
7 # Exportation vers CSV
8 df_notes.to_csv('notes_avec_moyenne.csv')

La méthode to_csv('notes_avec_moyenne.csv') crée un fichier CSV contenant le DataFrame,

incluant la nouvelle colonne Moyenne. Par défaut, l’index du DataFrame (les numéros de lignes 0

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 7.4 Pandas : manipulation et analyse des données 187

à 5) est inclus comme première colonne dans le fichier. Pour vérifier le contenu du fichier, vous
pouvez le recharger :
1 print(pd.read_csv('notes_avec_moyenne.csv'))

Unnamed: 0 Nom Maths Physique Moyenne

0 0 Alice 15.5 14.0 14.75
1 1 Bob 12.0 13.5 12.75
2 2 Claire 18.0 16.5 17.25
3 3 David 9.5 11.0 10.25
4 4 Emma 14.0 15.0 14.50
5 5 Florent 16.0 10.5 13.25

Le fichier contient une colonne Unnamed: 0 correspondant à l’index, ce qui peut être indésirable et
compliquer la lecture du fichier. Pour exclure l’index :
1 df_notes.to_csv('notes_sans_index.csv', index=False)
2 print(pd.read_csv('notes_sans_index.csv'))

Nom Maths Physique Moyenne

0 Alice 15.5 14.0 14.75
1 Bob 12.0 13.5 12.75
2 Claire 18.0 16.5 17.25
3 David 9.5 11.0 10.25
4 Emma 14.0 15.0 14.50
5 Florent 16.0 10.5 13.25

L’argument index=False supprime la colonne d’index (Unnamed: 0) et produit un fichier plus

propre. Pour to_excel, le même paramètre est utilisé.
Note. D’autres formats d’exportation, comme JSON (to_json), Pickle (to_pickle) ou SQL
(to_sql), sont disponibles dans Pandas, mais CSV et Excel sont les plus courants pour les débutants
en raison de leur simplicité et de leur compatibilité avec les tableurs.

[Link] Intégration avec Matplotlib pour visualisations

Les visualisations, comme les graphiques ou les diagrammes, complètent les données exportées
en offrant une représentation visuelle des résultats, facilitant leur interprétation. Matplotlib, une
bibliothèque de visualisation en Python, s’intègre parfaitement avec Pandas pour générer des
graphiques que vous pouvez sauvegarder et inclure dans des rapports ou des présentations.
Pour illustrer, créez un nuage de points montrant la relation entre les notes en Maths et en Physique
à partir de df_notes :
1 import pandas as pd
2 import [Link] as plt
3
4 df_notes = pd.read_csv('[Link]')
5
6 [Link](df_notes['Maths'], df_notes['Physique'], color='blue', alpha
=0.6)
7 [Link]('Notes en Maths')
8 [Link]('Notes en Physique')
9 [Link]('Relation entre les notes en Maths et en Physique')
10 [Link](True)
11 [Link]('nuage_notes.png', dpi=150, bbox_inches='tight')

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

188 Chapitre 7. Bibliothèques scientifiques

12 [Link]()

Ce code génère un nuage de points où chaque point représente un étudiant, avec les notes en Maths
sur l’axe des abscisses et celles en Physique sur l’axe des ordonnées.

Relation entre les notes en Maths et en Physique

16

15
Notes en Physique

14

13

12

11

10 12 14 16 18
Notes en Maths

F IGURE 7.20 – Nuage de points des notes en Maths et en Physique.

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 8. Introduction à la programmation orientée
objet

La programmation, telle que vous l’avez découverte dans les chapitres précédents, repose sur des
outils comme les variables, les fonctions et les modules pour structurer et résoudre des problèmes.
Ces outils sont puissants pour manipuler des données et automatiser des tâches, mais ils peuvent
devenir limités lorsque vous devez modéliser des entités complexes. La programmation orientée
objet (POO) introduit une nouvelle approche, où le code est organisé autour d’objets qui combinent
des données (comme les coordonnées d’un point) et des comportements (comme calculer une
distance). Ce paradigme, largement utilisé en informatique, permet de représenter des concepts du
monde réel de manière simple, facilitant la conception de programmes clairs, réutilisables et adaptés
aux problèmes scientifiques que vous rencontrerez dans vos études. Par exemple, représenter une
particule avec ses propriétés (masse, vitesse) et ses comportements (calcul d’énergie) devient
naturel avec la POO, car vous pouvez regrouper ces éléments dans un seul concept cohérent. De
plus, la POO favorise la réutilisabilité, car une classe bien conçue peut être utilisée dans plusieurs
projets et la modularité, car les classes peuvent être intégrées dans des modules.

[Link] Pourquoi utiliser la POO ?

Avant de plonger dans les détails techniques, il est utile de comprendre pourquoi la POO est un
outil puissant, en particulier pour des étudiants en CPGE. Voici quelques avantages clés :

• Représentation simple : La POO permet de modéliser des entités du monde réel, comme
une particule ou un vecteur, en regroupant leurs propriétés (par exemple, masse, coordonnées)
et leurs comportements (par exemple, calculer une force) dans une seule unité logique. Cela
rend le code plus proche de la manière dont vous pensez à un problème scientifique.
• Réutilisabilité : Une classe bien conçue, comme une classe Point pour la géométrie, peut
être réutilisée dans différents programmes (par exemple, pour des calculs vectoriels ou des
simulations).
• Maintenance : En regroupant les données et les opérations associées, la POO facilite la mo-
dification du code. Par exemple, ajouter une nouvelle fonctionnalité à une classe Particule
(comme calculer l’énergie cinétique) ne nécessite pas de réécrire tout le programme.
• Collaboration : Dans des projets plus complexes, la POO permet à plusieurs programmeurs
de travailler sur des classes distinctes, intégrées ensuite dans un module ou un package.

Cependant, la POO peut sembler abstraite au début, surtout si vous êtes habitués à écrire des
programmes linéaires avec des fonctions. Ne vous inquiétez pas : les concepts seront introduits
 190 Chapitre 8. Introduction à la programmation orientée objet

étape par étape, avec des exemples concrets pour que vous puissiez rapidement appliquer la POO à
vos propres projets.

8.1 Classes, objets, attributs

Le point de départ de la programmation orientée objet est la compréhension des classes, des objets
et des attributs. Une classe est un modèle qui décrit ce qu’un type d’entité peut contenir (ses
données ou attributs) et ce qu’il peut faire (ses actions ou méthodes). Un objet est une instance de
cette classe, c’est-à-dire une entité spécifique créée à partir du modèle, avec des valeurs concrètes
pour ses attributs. Les attributs sont les variables qui stockent ces données, soit pour un objet
spécifique (attributs d’instance), soit pour toutes les instances de la classe (attributs de classe).
Pour illustrer, imaginez une classe comme un modèle de voiture dans une usine. Le modèle (la
classe) spécifie les caractéristiques générales : quatre roues, un moteur, une couleur, un nombre
de sièges, etc. Chaque voiture produite (un objet) a des valeurs spécifiques : une voiture rouge
avec quatre sièges, une autre bleue avec six sièges. Les attributs sont les caractéristiques, comme la
couleur ou le nombre de sièges, qui peuvent varier d’une voiture à l’autre (attributs d’instance) ou
être communes à toutes les voitures du modèle, comme la marque (attribut de classe).

8.1.1 Création d’une classe et instanciation d’objets

En Python, une classe est définie avec le mot-clé class, suivi du nom de la classe, généralement en
PascalCase (par exemple, MaClasse), où chaque mot commence par une majuscule pour respecter
les conventions de nommage. Le corps de la classe contient les définitions de ses attributs et
méthodes. Pour créer un objet, vous « appelez » la classe comme une fonction, ce qui instancie une
nouvelle entité basée sur le modèle.
Voici une classe minimale représentant un étudiant, avec une création manuelle d’attributs pour
l’instant :
1 # Définition de la classe
2 class Etudiant:
3 pass # Corps vide pour l'instant
4
5 if __name__ == "__main__":
6 # Création d'objets
7 etudiant1 = Etudiant()
8 etudiant2 = Etudiant()
9
10 # Ajout manuel d'attributs
11 [Link] = "Alice"
12 [Link] = 18
13 [Link] = "Bob"
14 [Link] = 19
15
16 print(f"Étudiant 1 : {[Link]}, {[Link]} ans")
17 print(f"Étudiant 2 : {[Link]}, {[Link]} ans")
18
19 # Vérification du type avec isinstance()
20 print(isinstance(etudiant1, Etudiant)) # Vrai, car etudiant1 est une
instance de Etudiant
21 print(isinstance(etudiant2, Etudiant)) # Vrai
22 print(isinstance(etudiant1, str)) # Faux, car etudiant1 n'est pas
une chaîne

Exécution du script :

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 8.1 Classes, objets, attributs 191

Étudiant 1 : Alice, 18 ans

Étudiant 2 : Bob, 19 ans
True
True
False

Dans cet exemple, Etudiant est une classe vide, définie avec pass pour indiquer qu’elle ne contient
encore ni attributs ni méthodes. Les objets etudiant1 et etudiant2 sont créés en « appelant » la
classe (Etudiant()). Des attributs nom et age sont ajoutés manuellement à chaque objet, ce qui
leur permet de stocker des informations spécifiques. La fonction isinstance() est utilisée pour
vérifier que etudiant1 et etudiant2 sont bien des instances de la classe Etudiant. Elle prend
deux arguments : l’objet à tester et la classe (ou le type) à vérifier, et retourne True si l’objet est
une instance de cette classe, False sinon.
Notes.

1. Ajouter des attributs manuellement, comme dans l’exemple ci-dessus, est possible mais
risqué et déconseillé, car il est facile d’oublier un attribut ou de faire des erreurs (par exemple,
écrire [Link] au lieu de age ou encore oublier d’ajouter un attribut). De plus, cela
rend le code moins structuré. La section 10.2 introduira le constructeur __init__, qui permet
d’initialiser les attributs de manière systématique et sécurisée.
2. La création d’un objet est appelée instanciation, car elle produit une instance de la classe.
Chaque objet est indépendant : modifier les attributs de etudiant1 (par exemple, etudiant1
.age = 20) n’affecte pas etudiant2. La fonction isinstance() permet de confirmer qu’un
objet est une instance d’une classe donnée, ce qui est utile pour vérifier le type d’un objet
avant de manipuler ses attributs ou méthodes. Cela reflète la puissance de la POO : une seule
classe peut générer de nombreux objets, chacun avec ses propres données.

8.1.2 Attributs d’instance

Les attributs d’instance sont des variables propres à chaque objet, stockant des données spécifiques
à cette instance. Ils sont généralement définis à l’intérieur d’une méthode, comme le constructeur
__init__, mais pour illustrer leur concept, nous pouvons les créer via une méthode dédiée. Les
attributs d’instance sont associés à l’objet via le paramètre self, qui représente l’instance en cours
de manipulation.
Voici une classe Point pour représenter un point dans un espace bidimensionnel, avec une méthode
pour définir ses coordonnées :
1 class Point:
2 def definir_coordonnees(self, x, y):
3 """Définit les coordonnées x et y du point."""
4 self.x = x # Attribut d'instance
5 self.y = y # Attribut d'instance
6
7 if __name__ == "__main__":
8 point1 = Point()
9 point2 = Point()
10
11 point1.definir_coordonnees(3, 4)
12 point2.definir_coordonnees(−1, 2)
13
14 print(f"Point 1 : ({point1.x}, {point1.y})")
15 print(f"Point 2 : ({point2.x}, {point2.y})")
16

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 192 Chapitre 8. Introduction à la programmation orientée objet

17 # Modification d'un attribut

18 point1.x = 5
19 print(f"Point 1 après modification : ({point1.x}, {point1.y})")

Point 1 : (3, 4)
Point 2 : (−1, 2)
Point 1 après modification : (5, 4)

Dans cet exemple, self.x et self.y sont des attributs d’instance, car chaque objet (point1 et
point2) possède ses propres valeurs pour x et y. La méthode definir_coordonnees() utilise
self pour associer les valeurs x et y à l’objet appelant. Modifier point1.x n’affecte pas point2.x,
car chaque objet a sa propre copie des attributs.
Note. Les attributs d’instance sont créés dynamiquement lorsqu’ils sont assignés (par exemple,
dans definir_coordonnees()). Si vous essayez d’accéder à un attribut d’instance non défini
(par exemple, point1.z), Python lèvera une erreur AttributeError. La section 10.2 montrera
comment éviter ce problème avec le constructeur.

8.1.3 Attributs de classe

Les attributs de classe sont des variables définies directement dans le corps de la classe, en dehors
de toute méthode et partagées par tous les objets de cette classe. Ils sont utilisés pour stocker des
données communes, comme une constante, un compteur global ou une propriété partagée par toutes
les instances. Contrairement aux attributs d’instance, qui sont uniques à chaque objet, les attributs
de classe existent en une seule copie, accessible via le nom de la classe ou n’importe quel objet.
Modifions la classe Point pour inclure un attribut de classe qui compte le nombre total de points
créés :
1 class Point:
2 nombre_points = 0 # Attribut de classe
3
4 def definir_coordonnees(self, x, y):
5 """Définit les coordonnées x et y du point et incrémente le compteur
."""
6 self.x = x
7 self.y = y
8 Point.nombre_points += 1 # Mise à jour de l'attribut de classe
9
10 if __name__ == "__main__":
11 point1 = Point()
12 point1.definir_coordonnees(3, 4)
13 point2 = Point()
14 point2.definir_coordonnees(−1, 2)
15
16 print(f"Point 1 : ({point1.x}, {point1.y})")
17 print(f"Point 2 : ({point2.x}, {point2.y})")
18 print(f"Nombre total de points : {Point.nombre_points}")
19
20 # Accès via un objet
21 print(f"Nombre via point1 : {point1.nombre_points}")

Point 1 : (3, 4)
Point 2 : (−1, 2)
Nombre total de points : 2
Nombre via point1 : 2

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

8.1 Classes, objets, attributs 193

Dans cet exemple, nombre_points est un attribut de classe, défini une seule fois dans la classe Point
. Chaque appel à definir_coordonnees() incrémente Point.nombre_points et cette valeur est
partagée par tous les objets. Vous pouvez y accéder via Point.nombre_points (recommandé) ou
via un objet comme point1.nombre_points, car les objets héritent des attributs de leur classe.
Pour visualiser la différence, supposons une école avec plusieurs étudiants. Les attributs d’instance
sont comme le nom ou l’âge de chaque étudiant, uniques à chacun. Un attribut de classe est comme
le nom de l’école, commun à tous les étudiants et stocké en un seul exemplaire. Si l’école change
de nom, tous les étudiants verront ce changement, tout comme modifier Point.nombre_points
affecte tous les objets.
Note. Si vous modifiez un attribut de classe via un objet en utilisant une assignation (par exemple,
point1.nombre_points = 10), Python crée un nouvel attribut d’instance nombre_points pour
point1, masquant l’attribut de classe sans affecter Point.nombre_points ni les autres objets.
Pour modifier l’attribut de classe, utilisez toujours le nom de la classe (par exemple, Point.
nombre_points = 5).

Voici ce qui se passe si vous modifiez un attribut de classe incorrectement :

1 class Point:
2 nombre_points = 0
3
4 def definir_coordonnees(self, x, y):
5 self.x = x
6 self.y = y
7 Point.nombre_points += 1
8
9 if __name__ == "__main__":
10 point1 = Point()
11 point1.definir_coordonnees(3, 4)
12 point2 = Point()
13 point2.definir_coordonnees(−1, 2)
14
15 print(f"Nombre total initial : {Point.nombre_points}")
16
17 # Erreur : assignation via un objet
18 point1.nombre_points = 10 # Crée un attribut d'instance
19
20 print(f"Nombre via point1 : {point1.nombre_points}") # Attribut d'
instance
21 print(f"Nombre via point2 : {point2.nombre_points}") # Attribut de
classe
22 print(f"Nombre total : {Point.nombre_points}") # Attribut de
classe inchangé

Nombre total initial : 2

Nombre via point1 : 10
Nombre via point2 : 2
Nombre total : 2

Cet exemple montre que point1.nombre_points = 10 ne modifie pas l’attribut de classe, mais
crée un attribut d’instance spécifique à point1. Cela peut entraîner des erreurs logiques dans votre
programme.
Récapitulatif : les classes, objets et attributs forment le socle de la programmation orientée objet.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 194 Chapitre 8. Introduction à la programmation orientée objet

Une classe définit un modèle, un objet est une instance concrète de ce modèle et les attributs
stockent les données, soit pour chaque objet (attributs d’instance) soit pour toutes les instances
(attributs de classe). Ces concepts vous permettent de représenter des entités complexes de manière
structurée.
Cependant, la méthode manuelle pour définir les attributs, comme dans les exemples ci-dessus, est
limitée, car elle oblige à appeler une méthode comme definir_coordonnees() après la création
de l’objet. La section suivante introduira le constructeur __init__ qui permet d’initialiser les
attributs d’instance automatiquement lors de la création d’un objet, ce qui rend le code plus robuste
et pratique.

8.2 Constructeur __init__

Le constructeur est une méthode spéciale d’une classe, nommée __init__, qui est appelée
automatiquement lorsqu’un objet est créé. Il permet d’initialiser les attributs d’instance de l’objet
en leur assignant des valeurs spécifiques, garantissant que l’objet est prêt à l’emploi dès sa création.

8.2.1 Rôle et syntaxe du constructeur

Le constructeur __init__ est une méthode spéciale, identifiable par ses doubles tirets bas, qui fait
partie des nombreuses méthodes prédéfinies de Python (vous en découvrirez une autre, __str__,
dans la section 10.3.2). Sa particularité est qu’elle est exécutée automatiquement lorsque vous
instanciez un objet avec MaClasse(). La méthode __init__ prend généralement :

• self, le premier paramètre, qui représente l’objet en cours de création (comme vu dans la
section 10.1 pour les attributs d’instance).
• Des paramètres supplémentaires, définis par vous, pour spécifier les valeurs initiales des
attributs.

La syntaxe typique d’un constructeur est la suivante :

1 class MaClasse:
2 def __init__(self, parametre1, parametre2):
3 self.attribut1 = parametre1 # Initialisation d'un attribut d'
instance
4 self.attribut2 = parametre2 # Initialisation d'un autre attribut d'
instance

Lorsque vous créez un objet avec objet = MaClasse(valeur1, valeur2), Python appelle auto-
matiquement __init__ en passant objet comme self et valeur1, valeur2 comme parametre1,
parametre2.

Voici une classe Point utilisant un constructeur pour initialiser les coordonnées d’un point dans un
espace bidimensionnel :
1 class Point:
2 def __init__(self, x, y):
3 """Initialise un point avec les coordonnées x et y."""
4 self.x = x
5 self.y = y
6
7 if __name__ == "__main__":
8 point1 = Point(3, 4)
9 point2 = Point(−1, 2)
10
11 print(f"Point 1 : ({point1.x}, {point1.y})")

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 8.2 Constructeur __init__ 195

12 print(f"Point 2 : ({point2.x}, {point2.y})")

Point 1 : (3, 4)
Point 2 : (−1, 2)

Dans cet exemple, le constructeur __init__ prend trois paramètres : self (l’objet en cours de
création), x et y (les coordonnées). Lorsque point1 = Point(3, 4) est exécuté, __init__ assigne
3 à self.x et 4 à self.y pour point1. Le résultat est un objet immédiatement utilisable, sans avoir
besoin d’appeler une méthode supplémentaire comme definir_coordonnees().
Note. Le nom __init__ est fixé par Python et ne peut pas être changé. Les doubles tirets bas
indiquent qu’il s’agit d’une méthode spéciale, gérée automatiquement par le langage. Vous ne
devez jamais appeler __init__ directement (par exemple, point1.__init__(5, 6)), car cela
réinitialiserait l’objet, ce qui est rarement souhaitable.

[Link] Le paramètre self

En Python, le paramètre self est utilisé dans les méthodes d’une classe pour faire référence
à l’instance de l’objet sur laquelle la méthode est appelée. Il permet d’accéder aux attributs et
autres méthodes de cet objet spécifique. Par convention, self est toujours le premier paramètre
des méthodes d’instance, car Python passe automatiquement l’instance comme argument lors de
l’appel de la méthode. Cela garantit que la méthode agit sur les données propres à l’instance. Par
exemple, si vous appelez point1.definir_coordonnees(3, 4), self fait référence à point1 en
garantissant que les attributs self.x et self.y sont assignés à point1 et non à un autre objet.
Omettre self entraînerait une erreur ou un comportement incorrect, car la méthode ne pourrait pas
identifier l’objet concerné. Bien que le nom self soit une convention (on pourrait utiliser un autre
nom), il est fortement recommandé pour la lisibilité et le respect des normes Python.

Le constructeur est généralement utilisé pour initialiser les attributs d’instance, mais il peut aussi
interagir avec les attributs de classe pour mettre à jour des données partagées. Par exemple, vous
pouvez utiliser un attribut de classe pour compter le nombre d’objets créés, en l’incrémentant dans
__init__.

En exemple, voici une classe Particule qui combine un attribut de classe et des attributs d’instance
avec un constructeur :
1 class Particule:
2 nombre_particules = 0 # Attribut de classe
3
4 def __init__(self, masse, vitesse):
5 """Initialise une particule avec une masse et une vitesse."""
6 [Link] = masse
7 [Link] = vitesse
8 Particule.nombre_particules += 1 # Incrémentation de l'attribut de
classe
9
10 if __name__ == "__main__":
11 particule1 = Particule(2.0, 10.0)
12 particule2 = Particule(1.5, 5.0)
13
14 print(f"Particule 1 : masse = {[Link]} kg, vitesse = {
[Link]} m/s")
15 print(f"Particule 2 : masse = {[Link]} kg, vitesse = {
[Link]} m/s")
16 print(f"Nombre total de particules : {Particule.nombre_particules}")

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

196 Chapitre 8. Introduction à la programmation orientée objet

Particule 1 : masse = 2.0 kg, vitesse = 10.0 m/s

Particule 2 : masse = 1.5 kg, vitesse = 5.0 m/s
Nombre total de particules : 2

Dans cet exemple, nombre_particules est un attribut de classe, partagé par toutes les instances de
Particule. Le constructeur __init__ incrémente cet attribut à chaque création d’objet, permettant
de suivre le nombre total de particules. Les attributs masse et vitesse sont des attributs d’instance,
spécifiques à chaque particule.

De plus, comme pour les fonctions, le constructeur peut inclure des paramètres optionnels avec des
valeurs par défaut.
1 class Rectangle:
2 def __init__(self, longueur, largeur=1.0):
3 """Initialise un rectangle avec une longueur et une largeur (par dé
faut 1.0)."""
4 [Link] = longueur
5 [Link] = largeur
6
7 if __name__ == "__main__":
8 rectangle1 = Rectangle(5.0) # Largeur par défaut (1.0)
9 rectangle2 = Rectangle(3.0, 2.0) # Largeur spécifiée
10
11 print(f"Rectangle 1 : longueur = {[Link]}, largeur = {
[Link]}")
12 print(f"Rectangle 2 : longueur = {[Link]}, largeur = {
[Link]}")

Rectangle 1 : longueur = 5.0, largeur = 1.0

Rectangle 2 : longueur = 3.0, largeur = 2.0

Dans cet exemple, le paramètre largeur a une valeur par défaut de 1.0. Si vous créez un rectangle
sans spécifier la largeur (Rectangle(5.0)), elle prend la valeur par défaut. Cela rend la classe plus
flexible et pratique.
Note. Les valeurs par défaut dans __init__ suivent les mêmes règles que dans les fonctions.
Évitez d’utiliser des objets mutables (comme des listes) comme valeurs par défaut, car ils sont
partagés entre toutes les instances, ce qui peut entraîner des comportements inattendus. Par exemple,
def __init__(self, liste=[]) crée une seule liste partagée, modifiée par tous les objets.

Voici un exemple illustrant ce piège :

1 class Etudiant:
2 def __init__(self, nom, notes=[]):
3 """Initialise un étudiant avec un nom et une liste de notes (défaut
: vide)."""
4 [Link] = nom
5 [Link] = notes
6
7 if __name__ == "__main__":
8 etudiant1 = Etudiant("Alice")
9 etudiant2 = Etudiant("Bob")
10
11 # Modification des notes

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 8.3 Méthodes 197

12 [Link](15)
13 print(f"Notes d'Alice : {[Link]}")
14 print(f"Notes de Bob : {[Link]}") # Erreur : les notes sont
partagées !

Notes d'Alice : [15]

Notes de Bob : [15]

Pour éviter ce problème, utilisez None comme valeur par défaut et initialisez une nouvelle liste dans
__init__ :
1 class Etudiant:
2 def __init__(self, nom, notes=None):
3 """Initialise un étudiant avec un nom et une liste de notes (défaut
: vide)."""
4 [Link] = nom
5 [Link] = notes if notes is not None else []
6
7 if __name__ == "__main__":
8 etudiant1 = Etudiant("Alice")
9 etudiant2 = Etudiant("Bob")
10
11 [Link](15)
12 print(f"Notes d'Alice : {[Link]}")
13 print(f"Notes de Bob : {[Link]}")

Notes d'Alice : [15]

Notes de Bob : []

Ce code garantit que chaque étudiant a sa propre liste de notes, évitant les effets secondaires.
Pour approfondir la compréhension du constructeur et des classes, consultez la documentation
officielle de Python sur les classes 1 .

8.3 Méthodes
Comme évoqué au début de ce chapitre, une classe ne se limite pas à stocker des données : elle peut
également définir des comportements, c’est-à-dire des actions que les objets peuvent effectuer. En
programmation orientée objet, ces comportements sont implémentés à l’aide de méthodes qui sont
des fonctions définies à l’intérieur d’une classe. Il existe quatre principaux types de méthodes en
Python : les méthodes d’instance qui opèrent sur un objet spécifique (comme celles que nous avons
déjà utilisées dans les exemples précédents) ; les méthodes de classe qui agissent sur la classe elle-
même ; les méthodes statiques qui sont des fonctions utilitaires liées à la classe mais indépendantes
des objets ou de la classe ; et les méthodes spéciales qui personnalisent le comportement des objets
dans des contextes spécifiques.
Une méthode est donc une fonction définie à l’intérieur d’une classe qui décrit un comportement
ou une action associée à la classe ou à ses objets. Les méthodes se divisent en quatre catégories :
• Méthodes d’instance : Liées à un objet spécifique, elles utilisent le paramètre self pour
accéder aux attributs et autres méthodes de cet objet.
• Méthodes de classe : Liées à la classe elle-même, elles utilisent le paramètre cls et le

1. [Link]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 198 Chapitre 8. Introduction à la programmation orientée objet

décorateur @classmethod pour manipuler des données communes à tous les objets.
• Méthodes statiques : Indépendantes des objets et de la classe, elles utilisent le décorateur
@staticmethod et ne prennent ni self ni cls. Elles servent à des opérations utilitaires liées
thématiquement à la classe.
• Méthodes spéciales : Identifiables par leurs doubles tirets bas (par exemple, __init__,
__str__), elles personnalisent le comportement des objets pour des opérations spécifiques,
comme l’affichage ou les calculs mathématiques.
Cette section se concentre sur les méthodes d’instance, qui sont les plus courantes, et sur la
méthode spéciale __str__ qui améliore l’affichage des objets. D’autres méthodes spéciales, comme
__call__ (pour rendre un objet « appelable » comme une fonction) ou des méthodes mathématiques
(__add__, __mul__, etc.), ainsi que les méthodes de classe et statiques, peuvent être explorées via
la documentation officielle de Python sur les classes et sur les méthodes spéciales 2 ou sur Real
Python(classes 3 , méthodes spéciales 4 ).

8.3.1 Méthodes d’instance

Dans les sections précédentes, vous avez rencontré les méthodes d’instance à travers des exemples
comme definir_coordonnees() pour assigner des attributs et __init__() pour initialiser des
objets. Ces méthodes, liées à un objet spécifique via le paramètre self, permettent aux objets
d’exécuter des actions en utilisant leurs propres données. Une méthode d’instance est donc une
fonction définie dans une classe, qui utilise self pour accéder aux attributs et autres méthodes d’un
objet spécifique, permettant de définir des comportements propres à chaque instance de la classe.
Pour rappel, grâce au paramètre self, une méthode d’instance sait sur quel objet elle opère, ce qui
la rend idéale pour manipuler ou calculer des informations propres à cet objet.

[Link] Composition de méthodes et valeurs de retour

Une méthode d’instance peut appeler d’autres méthodes de la même classe via self, ce qui
permet de composer des comportements complexes à partir de tâches plus simples. Cette approche,
appelée composition, rend le code modulaire. De plus, les méthodes d’instance peuvent retourner
des résultats de différents types (chaînes, nombres, booléens) pour fournir des informations ou
déclencher des actions ou ne rien retourner (None) si elles se contentent de modifier l’état de l’objet.
Voici une illustration avec une classe CompteBancaire :
1 class CompteBancaire:
2 def __init__(self, titulaire, solde):
3 """Initialise un compte bancaire avec un titulaire et un solde
initial."""
4 [Link] = titulaire
5 [Link] = solde
6
7 def deposer(self, montant):
8 """Ajoute le montant spécifié au solde, si positif."""
9 if montant > 0:
10 [Link] += montant
11 return f"Dépôt de {montant} effectué. Nouveau solde : {self.
solde}"
12 return "Erreur : le montant doit être positif."
13
14 def peut_retirer(self, montant):
15 """Vérifie si un retrait est possible (retourne un booléen)."""

2. [Link]
3. [Link]
4. [Link]

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 8.3 Méthodes 199

16 return montant > 0 and [Link] >= montant

17
18 def retirer(self, montant):
19 """Effectue un retrait si possible (retourne None)."""
20 if self.peut_retirer(montant):
21 [Link] −= montant
22 return f"Retrait de {montant} effectué. Nouveau solde : {self.
solde}"
23 return "Erreur : retrait impossible."
24
25 if __name__ == "__main__":
26 compte = CompteBancaire("Alice", 1000)
27
28 print(compte.peut_retirer(500)) # Vérifie la faisabilité
29 print([Link](500)) # Effectue le retrait
30 print([Link](700)) # Tente un retrait trop élevé
31 print([Link](100)) # Fait un dépôt

True
Retrait de 500 effectué. Nouveau solde : 500
Erreur : retrait impossible.
Dépôt de 100 effectué. Nouveau solde : 600

Dans cet exemple, peut_retirer() retourne un booléen pour indiquer si un retrait est possible,
tandis que retirer() modifie le solde et retourne une chaîne décrivant l’action. Cette variété de
retours illustre la polyvalence des méthodes d’instance. La composition des méthodes favorise la
réutilisabilité du code, car une méthode comme peut_retirer() peut être utilisée seule ou dans
d’autres méthodes. Cela reflète la modularité des fonctions, mais appliquée aux objets.
Note. Une méthode qui ne retourne rien explicitement (pas de return) renvoie None par défaut. Si
vous attendez un résultat spécifique, assurez-vous que la méthode inclut une instruction return
avec la valeur appropriée.

[Link] Interaction avec des données externes

Les méthodes d’instance peuvent accepter plusieurs paramètres pour interagir avec des données
externes, comme d’autres objets ou des valeurs fournies par l’utilisateur. Cela permet de modéliser
des relations ou des comparaisons entre objets.
Voici une classe Rectangle avec une méthode comparant deux rectangles :
1 class Rectangle:
2 def __init__(self, longueur, largeur):
3 """Initialise un rectangle avec une longueur et une largeur."""
4 [Link] = longueur
5 [Link] = largeur
6
7 def calculer_aire(self):
8 """Calcule l'aire du rectangle."""
9 return [Link] * [Link]
10
11 def est_plus_grand(self, autre_rectangle):
12 """Vérifie si ce rectangle a une aire plus grande qu'un autre."""
13 return self.calculer_aire() > autre_rectangle.calculer_aire()
14
15 if __name__ == "__main__":
16 rectangle1 = Rectangle(5, 3)
17 rectangle2 = Rectangle(2, 4)

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 200 Chapitre 8. Introduction à la programmation orientée objet

18
19 print(f"Aire de rectangle1 : {rectangle1.calculer_aire()}")
20 print(f"Aire de rectangle2 : {rectangle2.calculer_aire()}")
21 print(f"rectangle1 est plus grand : {rectangle1.est_plus_grand(
rectangle2)}")

Aire de rectangle1 : 15
Aire de rectangle2 : 8
rectangle1 est plus grand : True

La méthode est_plus_grand() prend un autre objet Rectangle comme paramètre et compare

leurs aires en appelant calculer_aire() sur les deux objets. Cela montre comment une méthode
d’instance peut interagir avec des données externes tout en utilisant les attributs de l’objet.

8.3.2 Méthode spéciale : __str__

Les méthodes d’instance permettent aux objets d’exécuter des actions spécifiques, comme modifier
leur état ou effectuer des calculs. Cependant, lorsqu’un objet est affiché avec print() ou intégré
dans une f-string, Python utilise par défaut une représentation technique peu informative, comme
<__main__.Personne object at 0x7f...>. La méthode spéciale __str__ résout ce problème
en permettant de définir une représentation textuelle claire de l’objet.
La méthode __str__ est une méthode d’instance, définie avec self comme paramètre. Elle doit
retourner une chaîne de caractères (type str) décrivant l’état de l’objet de manière lisible, générale-
ment en s’appuyant sur ses attributs d’instance. Python invoque __str__ automatiquement dans les
situations suivantes :
• Lors de l’utilisation de print(objet) pour afficher l’objet.
• Dans une f-string, comme f"{objet}", pour intégrer l’objet dans une chaîne formatée.
• Lors de la conversion explicite de l’objet en chaîne avec str(objet).
Sans __str__, Python affiche une représentation par défaut incluant le nom de la classe et l’adresse
mémoire de l’objet, ce qui est peu utile pour comprendre ses propriétés. En définissant __str__,
vous contrôlez l’affichage pour le rendre plus significatif, reflétant les données clés de l’objet.
Voici une classe Personne sans __str__ :
1 class Personne:
2 def __init__(self, nom, age):
3 """Initialise une personne avec un nom et un âge."""
4 [Link] = nom
5 [Link] = age
6
7 if __name__ == "__main__":
8 personne = Personne("Alice", 18)
9 print(personne)

<__main__.Personne object at 0x7f...>

Cet affichage technique ne révèle rien sur l’état de l’objet. Ajoutons __str__ pour personnaliser la
représentation :
1 class Personne:
2 def __init__(self, nom, age):
3 """Initialise une personne avec un nom et un âge."""

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 8.4 Introduction à l’héritage 201

4 [Link] = nom
5 [Link] = age
6
7 def __str__(self):
8 """Retourne une représentation textuelle de la personne."""
9 return f"{[Link]}, {[Link]} ans"
10
11 if __name__ == "__main__":
12 personne = Personne("Alice", 18)
13
14 print(personne)
15 print(f"Personne : {personne}")

Alice, 18 ans
Personne : Alice, 18 ans

Avec __str__, l’affichage devient intuitif, montrant les attributs nom et age de l’objet de manière
lisible. Cet exemple illustre comment __str__ améliore l’expérience utilisateur en rendant les
informations de l’objet immédiatement compréhensibles.
Note. La méthode __str__ doit impérativement retourner une chaîne de caractères (type str
). Retourner un autre type, comme un entier (return [Link]) ou une liste, provoque une
TypeError lorsque print(), une f-string ou str() est utilisé. Assurez-vous que le résultat est une
chaîne, par exemple en utilisant une f-string ou la fonction str() pour convertir les valeurs.

8.4 Introduction à l’héritage

Dans les sections précédentes, chaque classe était conçue de manière indépendante, mais dans
de nombreux cas, des classes partagent des caractéristiques communes. Par exemple, un carré est
un type particulier de rectangle, partageant ses propriétés mais avec des spécificités propres. Ce
concept a pour nom héritage.
L’héritage est un mécanisme de la programmation orientée objet qui permet à une classe dérivée
(ou classe enfant) d’acquérir les attributs et méthodes d’une classe de base (ou classe parent ou
classe mère), tout en pouvant ajouter de nouveaux attributs ou méthodes ou modifier ceux hérités.
La classe dérivée est définie avec la syntaxe class Enfant(Parent):.

8.4.1 Concepts de base

L’héritage repose sur une relation entre une classe de base qui fournit des attributs et méthodes
génériques et une classe dérivée qui hérite de ces éléments tout en pouvant les spécialiser. Par
exemple, une classe Rectangle peut définir des méthodes pour calculer l’aire et le périmètre, tandis
qu’une classe Carre, qui est un rectangle avec des côtés égaux, peut réutiliser ces méthodes tout en
imposant une contrainte sur ses dimensions.
Pour déclarer une classe dérivée, vous utilisez la syntaxe suivante :
1 class ClasseDeBase:
2 # Attributs et méthodes de la classe de base
3 pass
4
5 class ClasseDerivee(ClasseDeBase):
6 # Attributs et méthodes spécifiques, plus ceux hérités
7 pass

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 202 Chapitre 8. Introduction à la programmation orientée objet

La classe dérivée a automatiquement accès à tous les attributs et méthodes de la classe de base,
comme si elles étaient définies dans la classe dérivée elle-même. Cependant, pour initialiser
correctement les attributs hérités, le constructeur __init__ de la classe dérivée doit souvent appeler
celui de la classe de base à l’aide de la fonction super().
Voici un exemple simple avec une classe Personne (base) et une classe Etudiant (dérivée) :
1 class Personne:
2 def __init__(self, nom, age):
3 """Initialise une personne avec un nom et un âge."""
4 [Link] = nom
5 [Link] = age
6
7 def se_presenter(self):
8 """Retourne une présentation de la personne."""
9 return f"Je m'appelle {[Link]} et j'ai {[Link]} ans."
10
11 class Etudiant(Personne):
12 def __init__(self, nom, age, numero_matricule):
13 """Initialise un étudiant avec un nom, un âge et un numéro matricule
."""
14 super().__init__(nom, age) # Appelle le constructeur de Personne
15 self.numero_matricule = numero_matricule
16
17 if __name__ == "__main__":
18 etudiant = Etudiant("Alice", 18, "E12345")
19
20 print(etudiant.se_presenter())
21 print(f"Numéro matricule : {etudiant.numero_matricule}")

Je m'appelle Alice et j'ai 18 ans.

Numéro matricule : E12345

Etudiant hérite de Personne en réutilisant la méthode se_presenter et les attributs nom et age.
Le constructeur de Etudiant appelle super().__init__(nom, age) pour initialiser les attributs
hérités, puis ajoute l’attribut spécifique numero_matricule. Cela illustre comment l’héritage permet
d’étendre une classe existante sans dupliquer le code.
Note. Oublier d’appeler le constructeur de la classe de base avec super().__init__(...) peut
laisser les attributs hérités non initialisés, entraînant des erreurs comme AttributeError lorsque
vous essayez d’accéder à ces attributs. Par exemple, si Etudiant ne définit pas [Link] via
super(), se_presenter() échouera.

8.4.2 Réutilisation des méthodes

L’un des principaux avantages de l’héritage est la réutilisation des méthodes de la classe de base,
qui deviennent directement accessibles dans la classe dérivée. Cela permet de construire des classes
spécialisées sans réécrire les comportements génériques. Par exemple, un carré est un rectangle
avec des côtés égaux et peut donc réutiliser les méthodes de calcul d’aire et de périmètre d’un
rectangle.
1 class Rectangle:
2 def __init__(self, longueur, largeur):
3 """Initialise un rectangle avec une longueur et une largeur."""
4 [Link] = longueur
5 [Link] = largeur
6

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

 8.4 Introduction à l’héritage 203

7 def calculer_aire(self):
8 """Calcule l'aire du rectangle."""
9 return [Link] * [Link]
10
11 def calculer_perimetre(self):
12 """Calcule le périmètre du rectangle."""
13 return 2 * ([Link] + [Link])
14
15 def __str__(self):
16 """Retourne une représentation textuelle du rectangle."""
17 return f"Rectangle de {[Link]} x {[Link]}"
18
19 class Carre(Rectangle):
20 def __init__(self, cote):
21 """Initialise un carré avec un côté."""
22 super().__init__(cote, cote) # Un carré est un rectangle avec
longueur = largeur
23
24 if __name__ == "__main__":
25 rectangle = Rectangle(5, 3)
26 carre = Carre(4)
27
28 print(rectangle)
29 print(f"Aire du rectangle : {rectangle.calculer_aire()}")
30 print(f"Périmètre du rectangle : {rectangle.calculer_perimetre()}")
31 print(carre)
32 print(f"Aire du carré : {carre.calculer_aire()}")
33 print(f"Périmètre du carré : {carre.calculer_perimetre()}")

Rectangle de 5 x 3
Aire du rectangle : 15
Périmètre du rectangle : 16
Rectangle de 4 x 4
Aire du carré : 16
Périmètre du carré : 16

Dans cet exemple, Carre hérite de Rectangle et réutilise ses méthodes calculer_aire(), calculer_perimetre
() et __str__. Le constructeur de Carre appelle super().__init__(cote, cote) pour initialiser
les attributs longueur et largeur avec la même valeur, reflétant la contrainte d’un carré. Cela
montre comment l’héritage permet à Carre de bénéficier des fonctionnalités de Rectangle sans
redéfinir les méthodes.
Note. La classe Carre est une spécialisation de Rectangle, car elle impose une contrainte sup-
plémentaire (longueur = largeur). L’héritage est utile pour modéliser ce type de relations, où une
classe dérivée est un cas particulier de la classe de base.

8.4.3 Redéfinition des méthodes

Bien que les méthodes héritées soient directement utilisables, une classe dérivée peut redéfinir (ou
surcharger) une méthode pour adapter son comportement à ses besoins spécifiques. Cela s’appelle
l’override en programmation orientée objet. Par exemple, un carré peut vouloir un affichage différent
de celui d’un rectangle, en mettant l’accent sur son côté unique.
La redéfinition (ou override) d’une méthode consiste alors à redéfinir une méthode héritée dans
la classe dérivée en lui donnant un nouveau comportement tout en conservant le même nom et la
même signature.

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU

 204 Chapitre 8. Introduction à la programmation orientée objet

Pour redéfinir une méthode, vous déclarez une méthode avec le même nom dans la classe dérivée. Si
nécessaire, vous pouvez appeler la méthode de la classe de base à l’aide de super() pour combiner
les comportements.
Modifions Carre pour redéfinir __str__ et ajouter une méthode spécifique :
1 class Carre(Rectangle):
2 def __init__(self, cote):
3 """Initialise un carré avec un côté."""
4 super().__init__(cote, cote)
5 [Link] = cote # Stocke le côté pour usage spécifique
6
7 def __str__(self):
8 """Retourne une représentation textuelle du carré."""
9 return f"Carré de côté {[Link]}"
10
11 def est_carre(self):
12 """Confirme que l'objet est un carré."""
13 return True
14
15 if __name__ == "__main__":
16 rectangle = Rectangle(5, 3)
17 carre = Carre(4)
18
19 print(rectangle)
20 print(carre)
21 print(f"Aire du carré : {carre.calculer_aire()}")
22 print(f"Périmètre du carré : {carre.calculer_perimetre()}")
23 print(f"Est un carré ? {carre.est_carre()}")

Rectangle de 5 x 3
Carré de côté 4
Aire du carré : 16
Périmètre du carré : 16
Est un carré ? True

La classe Carre redéfinit __str__ pour afficher Carré de côté au lieu de Rectangle de longueur
x largeur, cela offre une description plus spécifique. Les méthodes calculer_aire() et calculer_perimetre
() sont héritées sans modification, tandis que est_carre est une nouvelle méthode propre à Carre.
Cela illustre comment une classe dérivée peut personnaliser les comportements hérités tout en
ajoutant des fonctionnalités uniques.
Note. Lors de la redéfinition d’une méthode, assurez-vous que la nouvelle version respecte l’objectif
de la méthode originale. Par exemple, __str__ doit toujours retourner une chaîne de caractères.
Une redéfinition incorrecte, comme retourner un entier, provoquerait des erreurs dans les contextes
où la méthode est utilisée.

8.4.4 Extension avec super()

Dans certains cas, une classe dérivée peut vouloir étendre le comportement d’une méthode héritée
plutôt que de le remplacer entièrement. La fonction super() permet d’appeler la méthode de la
classe de base depuis la classe dérivée afin de combiner les comportements.
Modifions Etudiant pour redéfinir se_presenter en étendant la version de Personne (qui reste
inchangée) :
1 class Etudiant(Personne):

Dr Ing Mahugnon Géraud AZEHOUN PAZOU Initiation à la Programmation Python

8.4 Introduction à l’héritage 205

2 def __init__(self, nom, age, numero_matricule):

3 """Initialise un étudiant avec un nom, un âge et un numéro matricule
."""
4 super().__init__(nom, age)
5 self.numero_matricule = numero_matricule
6
7 def se_presenter(self):
8 """Redéfinit la présentation pour inclure le numéro matricule."""
9 presentation_base = super().se_presenter() # Appelle la méthode de
Personne
10 return f"{presentation_base} Je suis étudiant, numéro {self.
numero_matricule}."
11
12 if __name__ == "__main__":
13 etudiant = Etudiant("Alice", 18, "E12345")
14 print(etudiant.se_presenter())

Je m'appelle Alice et j'ai 18 ans. Je suis étudiant, numéro E12345.

Ici, Etudiant redéfinit se_presenter() en appelant la version de Personne via super().se_presenter

(), puis en ajoutant des informations spécifiques. Cela montre comment super() permet d’étendre
un comportement existant sans le réécrire entièrement.
Note. L’héritage favorise la réutilisation, mais il doit être utilisé avec soin. Une classe dérivée doit
représenter une spécialisation logique de la classe de base (par exemple, un carré est un type de
rectangle, un chien est un type d’animal, etc.). Si les classes n’ont pas de relation claire, il peut être
préférable d’utiliser la composition 5 plutôt que l’héritage.
Note : Ce chapitre vous a introduit aux fondements de la programmation orientée objet, un
paradigme puissant pour structurer des programmes de manière modulaire et réutilisable. Vous
avez appris à créer des classes et des objets pour représenter des entités avec des données et des
comportements, à définir leurs actions via des méthodes d’instance et spéciales comme __str__ et
à organiser des relations entre classes grâce à l’héritage. Ces notions constituent une introduction
simplifiée à la programmation orientée objet, conçue pour vous familiariser avec ses principes
essentiels. D’autres concepts, tels que les méthodes statiques (fonctions utilitaires liées à une classe
sans dépendre d’un objet), les méthodes de classe (opérant sur la classe elle-même pour gérer des
données communes), les méthodes spéciales avancées (comme __len__ pour obtenir la taille d’un
objet ou __iter__ pour rendre un objet itérable), l’encapsulation (protection des données via des
attributs privés et des méthodes d’accès), le polymorphisme (capacité des objets à adopter des
comportements variés selon leur type), les décorateurs comme @property (simplifiant l’accès aux
attributs) ou la composition (intégration d’objets d’autres classes comme composants), enrichissent
la programmation orientée objet et élargissent ses possibilités. Ces notions avancées pourront
être explorées dans des cours avancés ou par des approfondissements personnels pour ceux qui
souhaitent approfondir leur compréhension de la programmation orientée objet.

5. [Link]

Initiation à la Programmation Python Dr Ing Mahugnon Géraud AZEHOUN PAZOU