LMD / Ingénierie

Programmation

Python
De l'initiation au calcul scientifique

Cours, exercices corrigés et programmes compilés

Abdelaziz DJELOUAH Hakim DJELOUAH

PhD
Professeur à l’USTHB

Ce livre est destiné :

 aux étudiants de licence et master en informatique (MI),
 aux étudiants de licence et master des filières scientifiques (SM et ST),
 aux étudiants des écoles d’ingénieurs,
 aux doctorants et enseignants-chercheurs

© Copyright Eurl Pages Bleues Internationales

 ©Copyright Eurl Pages Bleues Internationales
Maison d’édition au service de l’enseignement et de la formation

Siège social : Raffour 10041 Bouira Algérie

Edition : Cité 2068 lgts Smail yefsah bt 37B Bab ezzouar Alger
Tel/Fax : 023 93 81 64/82 Mob : 0551 34 82 92 /0551 14 48 65
E-mail : [email protected]
[email protected]
Facebook : Pages Bleues Editions
Site Web: www.pagesbleues-editions.com

ATTENTION !!

© Les Pages Bleues Internationales

Octobre 2021
Toute représentation ou reproduction intégrale ou partielle faite sans le
consentement de l’auteur, constitue une violation de la propriété intellectuelle
et une contrefaçon réprimée par le code pénal.
Nous mettons en garde les librairies ou tout autre organisme utilisant des
moyens de reproduction (Photocopieur, Imprimerie, web..) que la reproduction
de nos ouvrages est strictement interdite.
Nous faisons appel aux lecteurs afin de les alerter sur la menace que
représente la contrefaçon pour l’avenir de l’écrit et de la production
intellectuelle, particulièrement dans le domaine de l’édition scientifique et
technique. Pour cela nous les prions de nous signaler toute fraude en nous
contactant par e-mail.

ISBN : 978-9947-34-239-8
Dépôt légal : Octobre 2021
Avant Propos

Que ce soit dans le domaine de la recherche scientifique ou de l’ingénierie,

il est aujourd’hui nécessaire de maîtriser un langage de programmation. Se
pose alors la question du choix du langage de programmation à utiliser parmi
la pléthore des options existantes.
Python est le choix fait par de nombreux ingénieurs et chercheurs à tra-
vers le monde dans tous les domaines, en raison de la richesse des librairies
disponibles et de ses nombreuses interfaces.
Ce livre a pour objet l’apprentissage des bases fondamentales de Python
et de son application au calcul scientifique. Il s’adresse en premier lieu à des
lecteurs ayant quelques rudiments de programmation. Typiquement cela cor-
respond aux étudiants de deuxième année des filières scientifiques (MI, ST
et SM) des universités, des classes préparatoires et des écoles d’ingénieurs.
Il peut également être d’une grande utilité aux étudiants en master, aux in-
génieurs et chercheurs qui maîtrisent un langage de programmation tel que
MATLAB ou autre.
Les notions les plus élémentaires de la programmation Python sont pré-
sentées de manière concise, pour permettre au lecteur d’atteindre rapidement
un niveau suffisant pour aborder le calcul scientifique.
Pour les lecteurs n’ayant jamais programmé, certaines explications pour-
raient apparaître par moment sommaires. Dans ce cas de figure, nous recom-
mandons de considérer ce livre comme une feuille de route qui indique les
notions principales à acquérir . Le lecteur pourra l’accompagner de tutoriels
en ligne pour approfondir certaines de ces notions élémentaires de program-
mation.
Il reste maintenant à répondre de manière un peu plus élaborée à la ques-
tion : Pourquoi Python ?
— Python est un langage de programmation puissant et facile à apprendre.
ii Programmation Python

Il est gratuit, sous licence libre et multiplateforme avec une large base
d’utilisateurs. En 2021, il est le 3e langage le plus populaire sur le forum
de développement stackoverflow.
— Python est maintenant un langage établi. Son développement a été ini-
tié en 1989 par le hollandais Guido van Rossum et la version 1 est sortie
en 1994, soit deux ans avant la première version officielle de Java.
— il dispose d’un nombre de librairies gratuites en progression constante,
qui vont du calcul scientifique aux applications Web.
En ce qui concerne les applications scientifiques, l’écosystème SciPy,
avec son ensemble de librairies gratuites et open source, offre une base puis-
sante sur laquelle l’utilisateur peut construire ses propres programmes. Ces
librairies tirent avantage des interfaces existantes entre Python et C/C++ ou
Fortran pour allier rapidité et facilité d’utilisation.
La liste suivante donne une idée des possibilités offertes sous Python :
— Calcul scientifique (librairie NumPy),
— Graphisme (librairie matplotlib),
— Traitement du son, de la synthèse vocale (librairie eSpeak),
— Traitement d’image (OpenCV),
— Bio-informatique (librairie BioPython ),
— Applications Web (frameworks Web Flask, Django),
— Bases de données (librairie MySQLdb...),
— ...
Ce livre est structuré en deux parties. Les fondamentaux de Python sont
présentés dans la première partie, tandis que la seconde partie est consacrée
à l’utilisation de Python pour le calcul scientifique tel que pratiqué dans le
domaine des sciences et techniques.
La première partie du livre, du chapitre I au chapitre V, introduit les notions
essentielles en Python . Dans le chapitre I, sont présentées les principales
commandes de base ainsi que les règles du langage. Nous abordons ensuite les
types de données au chapitre II, et présentons les différents types de conteneurs
au chapitre III.
Dans ces premiers chapitres nous avons utilisé principalement le mode
interactif pour visualiser rapidement les résultats. Au chapitre IV, nous com-
mençons à écrire les premiers scripts grâce aux instructions de contrôle, avant
de passer à la notion de fonctions au chapitre V.
 iii

La seconde partie du livre, du chapitre VI au chapitre IX, se focalise sur les

modules et librairies qui font de Python un langage puissant pour le calcul
scientifique. Nous commençons par présenter la notion de module au chapitre
VI. Le chapitre VII est dédié aux paquets Numpy et Scipy dont la maitrise
est indispensable pour le calcul scientifique. Le chapitre VIII est consacré aux
possibilités de tracé des graphes sous Python . Le calcul symbolique sous
Python est présenté dans le chapitre IX.
Deux annexes sont respectivement consacrées au format d’impression des
chaînes de caractères et à la gestion des fichiers sous Python .
Nous souhaiterions vivement avoir un retour des lecteurs sur ce document.
Les lecteurs qui souhaitent nous faire part de leurs commentaires et sugges-
tions peuvent le faire en ligne à l’adresse correspondant au QRcode suivant :

A. Djelouah
H. Djelouah
Table des matières

Avant Propos i

1 Prise en Main 7
1 Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.1 Installation simplifiée avec Anaconda . . . . . . . . 9
1.2 Installation manuelle . . . . . . . . . . . . . . . . . . 10
1.3 Lancer Python . . . . . . . . . . . . . . . . . . . . 11
2 Utiliser Python . . . . . . . . . . . . . . . . . . . . . . . . 12
2.1 Exemples en mode interactif avec IPython . . . . . . . 12
2.2 Exécuter un programme dans un terminal . . . . . . . 14
3 Spyder et Jupyter . . . . . . . . . . . . . . . . . . . . . . . . 14
3.1 Exemple avec Spyder . . . . . . . . . . . . . . . . . . 15
3.2 Exemple avec Jupyter . . . . . . . . . . . . . . . . . . 19
4 Comment utiliser ce livre . . . . . . . . . . . . . . . . . . . . 20

2 Types de données 23
1 Les types numériques . . . . . . . . . . . . . . . . . . . . . . 24
1.1 Le type int . . . . . . . . . . . . . . . . . . . . . . 24
1.2 Le type float . . . . . . . . . . . . . . . . . . . . 25
1.3 Le type complex . . . . . . . . . . . . . . . . . . . . 26
1.4 Le type boolean . . . . . . . . . . . . . . . . . . . . . 27
1.5 Transtypage . . . . . . . . . . . . . . . . . . . . . . . 27
1.6 Opérateurs arithmétiques . . . . . . . . . . . . . . . . 29
2 Chaînes de caractères . . . . . . . . . . . . . . . . . . . . . . 31
2.1 Création . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.2 Fonctions de chaînes . . . . . . . . . . . . . . . . . . 31
2.3 Méthodes . . . . . . . . . . . . . . . . . . . . . . . . 31

1
2 Programmation Python

2.4 Opérations sur les chaines . . . . . . . . . . . . . . . 34

Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Correction des exercices . . . . . . . . . . . . . . . . . . . . . . . 42

3 Conteneurs 45
1 Listes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
1.1 Création d’une liste . . . . . . . . . . . . . . . . . . . 47
1.2 Accès aux éléments d’une liste . . . . . . . . . . . . . 47
1.3 Fonctions de listes . . . . . . . . . . . . . . . . . . . 49
1.4 Méthodes . . . . . . . . . . . . . . . . . . . . . . . . 50
1.5 Concaténation et répétition . . . . . . . . . . . . . . . 52
2 Tuples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
2.1 Créer un tuple . . . . . . . . . . . . . . . . . . . . . . 53
2.2 Accès aux éléments d’un tuple . . . . . . . . . . . . . 54
3 Dictionnaires . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.1 Les éléments des dictionnaires . . . . . . . . . . . . . 56
3.2 Méthodes . . . . . . . . . . . . . . . . . . . . . . . . 58
4 Set . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
Correction des exercices . . . . . . . . . . . . . . . . . . . . . . . 67

4 Instructions de contrôle 71
1 Tests logiques . . . . . . . . . . . . . . . . . . . . . . . . . . 72
2 L’instruction if . . . . . . . . . . . . . . . . . . . . . . . . . 72
2.1 elif . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
2.2 else . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
2.3 inline if . . . . . . . . . . . . . . . . . . . . . . . . . 74
2.4 Opérateurs logiques and et or . . . . . . . . . . . . . 74
2.5 if imbriqué . . . . . . . . . . . . . . . . . . . . . . . 75
2.6 pass . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
3 La boucle while . . . . . . . . . . . . . . . . . . . . . . . . 76
3.1 L’instruction break . . . . . . . . . . . . . . . . . . 76
3.2 L’instruction continue . . . . . . . . . . . . . . . . 77
3.3 L’instruction else . . . . . . . . . . . . . . . . . . . 77
4 La boucle for . . . . . . . . . . . . . . . . . . . . . . . . . 78
4.1 for . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
4.2 break . . . . . . . . . . . . . . . . . . . . . . . . . 78
 3

4.3 continue . . . . . . . . . . . . . . . . . . . . . . . 79
4.4 range . . . . . . . . . . . . . . . . . . . . . . . . . 79
4.5 else dans une boucle for . . . . . . . . . . . . . . 80
4.6 Boucles for imbriquées . . . . . . . . . . . . . . . . 80
4.7 Application aux listes . . . . . . . . . . . . . . . . . . 81
Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
Correction des exercices . . . . . . . . . . . . . . . . . . . . . . . 87

5 Fonctions 95
1 Fonctionnement . . . . . . . . . . . . . . . . . . . . . . . . . 96
2 Fonctions intégrées . . . . . . . . . . . . . . . . . . . . . . . 96
3 Fonctions définies par l’utilisateur . . . . . . . . . . . . . . . 98
3.1 Paramètres d’une fonction . . . . . . . . . . . . . . . 99
3.2 Valeur de retour d’une fonction . . . . . . . . . . . . 100
3.3 Le mot-clé pass . . . . . . . . . . . . . . . . . . . . . 103
4 Docstrings . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
5 Arguments d’une fonction en Python . . . . . . . . . . . . 106
5.1 Arguments de position . . . . . . . . . . . . . . . . . 106
5.2 Arguments avec étiquettes . . . . . . . . . . . . . . . 107
5.3 Arguments par défaut . . . . . . . . . . . . . . . . . . 108
5.4 Arguments de longueur variable . . . . . . . . . . . . 109
6 Fonction récursive . . . . . . . . . . . . . . . . . . . . . . . . 110
7 Portée et durée de vie des variables . . . . . . . . . . . . . . . 111
7.1 Mot-clé global . . . . . . . . . . . . . . . . . . . . 114
7.2 Mot clé nonlocal . . . . . . . . . . . . . . . . . . 115
8 Fonction Python Anonyme / Lambda . . . . . . . . . . . . . . 115
9 Fonction map() . . . . . . . . . . . . . . . . . . . . . . . . 117
10 Fonction filter() . . . . . . . . . . . . . . . . . . . . . . 117
Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
Correction des exercices . . . . . . . . . . . . . . . . . . . . . . . 123

6 Fonctions et Modules 133

1 Import . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
2 Aide . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
3 Le module math . . . . . . . . . . . . . . . . . . . . . . . . 137
4 Le module cmath . . . . . . . . . . . . . . . . . . . . . . . 139
5 Le module random . . . . . . . . . . . . . . . . . . . . . . . 140
4 Programmation Python

6 Le module statistics . . . . . . . . . . . . . . . . . . . 143

7 Le module os . . . . . . . . . . . . . . . . . . . . . . . . . . 145
8 Le module glob . . . . . . . . . . . . . . . . . . . . . . . . 145
9 Importer un module depuis un package . . . . . . . . . . . . . 146
10 Comment écrire un module . . . . . . . . . . . . . . . . . . 146
Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
Correction des exercices . . . . . . . . . . . . . . . . . . . . . . . 149

7 Calcul Scientifique 153

1 Principaux packages . . . . . . . . . . . . . . . . . . . . . . 154
2 Numpy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154
2.1 Type ndarray . . . . . . . . . . . . . . . . . . . . . 155
2.2 Création de tableaux . . . . . . . . . . . . . . . . . . 156
2.3 Tableaux particuliers . . . . . . . . . . . . . . . . . . 158
2.4 Vérification du type de données d’un tableau . . . . . 159
2.5 Dimension d’un tableau . . . . . . . . . . . . . . . . 159
2.6 Obtenir la forme d’un tableau . . . . . . . . . . . . . 159
2.7 Accès aux éléments d’un tableau . . . . . . . . . . . . 160
2.8 Extraction d’une partie du tableau . . . . . . . . . . . 160
2.9 Remodelage des tableaux . . . . . . . . . . . . . . . . 162
2.10 Action d’une fonction mathématique sur un tableau . . 162
2.11 Polynômes . . . . . . . . . . . . . . . . . . . . . . . 163
2.12 Opérations avec les tableaux et les matrices . . . . . . 164
2.13 Algèbre linéaire . . . . . . . . . . . . . . . . . . . . . 166
3 Scipy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
3.1 Fonctions spéciales avec scipy.special . . . . . 169
3.2 scipy.integrate . . . . . . . . . . . . . . . . . 170
3.3 Optimisation . . . . . . . . . . . . . . . . . . . . . . 172
Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
Correction des exercices . . . . . . . . . . . . . . . . . . . . . . . 180

8 Graphisme 189
1 Graphes à deux-dimensions . . . . . . . . . . . . . . . . . . . 190
1.1 Tracé de fonction . . . . . . . . . . . . . . . . . . . . 190
1.2 Superposition de plusieurs fonctions . . . . . . . . . . 193
2 Autres types de graphes . . . . . . . . . . . . . . . . . . . . . 196
2.1 Courbes paramétrées . . . . . . . . . . . . . . . . . . 196
 5

2.2 Tracé en coordonnées polaires . . . . . . . . . . . . . 197

2.3 Tracé en échelle semi-logarithmique ou log-log . . . . 198
2.4 Remplissage . . . . . . . . . . . . . . . . . . . . . . 200
2.5 Cas des données discrètes . . . . . . . . . . . . . . . 201
2.6 La commande subplot . . . . . . . . . . . . . . . . 203
3 Graphes 3D . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
3.1 Courbes paramétrées . . . . . . . . . . . . . . . . . . 205
3.2 Contour . . . . . . . . . . . . . . . . . . . . . . . . . 206
3.3 Surfaces . . . . . . . . . . . . . . . . . . . . . . . . . 207
4 Gestion des fenêtres graphiques . . . . . . . . . . . . . . . . . 208
4.1 Ouverture-fermeture . . . . . . . . . . . . . . . . . . 208
4.2 Sauvegarde . . . . . . . . . . . . . . . . . . . . . . . 209
4.3 Sauvegarde et modificationd’une figure . . . . . . . . 209
Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
Correction des exercices . . . . . . . . . . . . . . . . . . . . . . . 214

9 Calcul symbolique 223

1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
2 Les bases du calcul symbolique . . . . . . . . . . . . . . . . . 224
2.1 Objets symboliques . . . . . . . . . . . . . . . . . . . 225
2.2 Expressions symboliques . . . . . . . . . . . . . . . . 226
3 Calcul symbolique . . . . . . . . . . . . . . . . . . . . . . . 226
3.1 Simplification d’expressions . . . . . . . . . . . . . . 226
3.2 Développement d’expressions . . . . . . . . . . . . . 228
3.3 Factorisation d’expressions . . . . . . . . . . . . . . . 229
3.4 Substitution dans des expressions symboliques . . . . 229
3.5 Affichage . . . . . . . . . . . . . . . . . . . . . . . . 230
3.6 Dérivation . . . . . . . . . . . . . . . . . . . . . . . 231
3.7 Limites . . . . . . . . . . . . . . . . . . . . . . . . . 232
3.8 Integration . . . . . . . . . . . . . . . . . . . . . . . 232
3.9 Sommation symbolique . . . . . . . . . . . . . . . . 234
3.10 Produit symbolique . . . . . . . . . . . . . . . . . . . 234
3.11 Séries de Taylor . . . . . . . . . . . . . . . . . . . . . 235
3.12 Transformations intégrales . . . . . . . . . . . . . . . 235
3.13 Résolution d’équations . . . . . . . . . . . . . . . . . 235
4 Graphes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 237
Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 238
6 Programmation Python

Correction des exercices . . . . . . . . . . . . . . . . . . . . . . . 240

A Format 243
1 Formatage avec f-strings . . . . . . . . . . . . . . . . . . . . 244
1.1 Prise en main . . . . . . . . . . . . . . . . . . . . . . 244
1.2 Spécification de format . . . . . . . . . . . . . . . . . 244
2 Formatage de chaîne avec l’opérateur % . . . . . . . . . . . . 247
3 Formatage avec la méthode .format . . . . . . . . . . . . . 248
4 Choix de la méthode de formatage . . . . . . . . . . . . . . . 249

B Fichiers 251
1 La gestion des fichiers . . . . . . . . . . . . . . . . . . . . . . 251
2 Syntaxe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 253
3 Lecture d’un fichier . . . . . . . . . . . . . . . . . . . . . . . 253
3.1 Lecture de la totalité du fichier . . . . . . . . . . . . . 253
3.2 Lecture partielle d’un fichier . . . . . . . . . . . . . . 254
4 Fermeture de fichiers . . . . . . . . . . . . . . . . . . . . . . 255
5 Écriture de fichiers . . . . . . . . . . . . . . . . . . . . . . . 256
5.1 Écrire dans un fichier existant . . . . . . . . . . . . . 256
5.2 Créer un nouveau fichier . . . . . . . . . . . . . . . . 257
6 Contexte with . . . . . . . . . . . . . . . . . . . . . . . . . 258
7 Supprimer un fichier . . . . . . . . . . . . . . . . . . . . . . 259
7.1 Supprimer un fichier . . . . . . . . . . . . . . . . . . 259
7.2 Vérifier si le fichier existe . . . . . . . . . . . . . . . 259
7.3 Supprimer un répertoire . . . . . . . . . . . . . . . . 259

Bibliographie 261
Chapitre 1

Prise en Main

Dans ce chapitre :
— Installation
— Premiers pas

Travaux Dirigés:
Exercices

7
8 Programmation Python

Pour la plupart des langages de programmation, il existe deux techniques

principales pour traduire un code source en langage machine :
— la compilation : une application tierce, appelée compilateur, transforme
les lignes de code en un fichier exécutable en langage machine. A chaque
fois que l’on apporte une modification au programme, il faut recompiler
avant de voir le résultat.
— l’interprétation : un interpréteur traduit le programme en instructions
machines, en interprétant le programme ligne par ligne. Ce type de lan-
gage offre une plus grande commodité pour le développement, mais les
exécutions sont souvent plus lentes.
Dans le cas de Python , on peut admettre pour commencer qu’il s’agit d’un
langage interprété, qui fait appel à des modules compilés. Pour les opérations
algorithmiques coûteuses, le langage Python peut s’interfacer à des biblio-
thèques écrites en langage de plus bas niveau comme le langage C.
L’interpréteur Python et sa vaste bibliothèque standard sont disponibles
librement, sous forme de sources ou de binaires, pour toutes les plateformes
majeures depuis le site Internet :
https ://www.python.org/
et peuvent être librement redistribués. Ce même site distribue et pointe
vers des modules, des programmes et des outils tiers. Enfin, il constitue une
source de documentation. La documentation python est également extrême-
ment bien faite, aussi bien pour les débutants que pour les experts. L’environ-
nement python est riche en librairies. Des dizaines de milliers de librairies sont
disponibles sur le dépôt officiel PyPI.

1 Installation
Python et ses librairies peuvent être installés dans quasiment tout envi-
ronnement matériel et système d’exploitation. Nous décrirons ici deux pro-
cédures d’installation : l’une simplifiée, qui repose sur le gestionnaire de pa-
ckages Anaconda, et l’autre manuelle, qui peut s’avérer plus complexe pour
le néophyte.
Chapitre 1. Prise en Main 9

1.1 Installation simplifiée avec Anaconda

On peut voir Anaconda comme une manière simplifiée d’installer l’in-
terpréteur Python et un ensemble de libraires liées aux applications scien-
tifiques. Plus précisément il s’agit d’un gestionnaire de packages, un gestion-
naire d’environnement et une distribution Python . Ceci est avantageux car
lorsque vous travaillez sur un projet, vous constaterez que vous avez besoin
de différents packages tels que numpy, scikit-learn, scipy ou pandas pour n’en
nommer que quelques-uns. Plusieurs de ces packages sont installés par dé-
faut avec Anaconda et les librairies supplémentaires pourront facilement être
ajoutées par le gestionnaire de packages (conda ou pip).
Pour commencer, téléchargez la distribution Anaconda correspondant à
votre système d’exploitation, en vous rendant à l’adresse :
https ://www.anaconda.com/products/individual
Pour plus de détails, les procédures d’installations détaillées selon chaque
système d’exploitation sont décrites à l’adresse :
https ://docs.anaconda.com/anaconda/install/

Installation sur Windows ou Mac

1. Téléchargez l’installeur Windows ou MacOS, et double-cliquez pour

lancer l’installation.
2. Répondez aux différentes questions (les options par défaut suffisent !).

Installation sur Linux

1. Téléchargez l’installeur pour Linux.

2. Exécuter le fichier téléchargé avec bash puis suivre la procédure d’ins-
tallation (il n’est pas nécessaire d’installer VS Code).
3. L’installeur affiche :“In order to continue the installation process, please
review the license agreement.”
Affichez les termes de la licence d’utilisation, faites défiler jusqu’en bas
et cliquez sur yes pour accepter.
4. Répondez "yes" à la question qui suit :
Do you wish the installer to prepend the
Anaconda 3 install location
to PATH in your /home/ec2-user/.bashrc ? [yes | no]}
10 Programmation Python

La commande précédente a ajouté au fichier .bashrc le chemin (le dos-

sier) dans lequel se trouve Anaconda. Ainsi, vous pourrez lancer l’ins-
tallation de Anaconda directement en tapant seulement "anaconda"
dans votre console. Cette opération prendra effet au redémarrage de
votre ordinateur.

1.2 Installation manuelle

Installation

Vous pourrez télécharger l’application d’installation pour MacOS et Win-

dows en vous rendant l’adresse :
https://www.python.org/
Vous pourrez ainsi télécharger l’application d’installation pour MacOS et
Windows. Il suffira ensuite de lancer l’installation avec les options par défaut.
Pour les autres systèmes d’exploitation, il est recommandé d’utiliser le ges-
tionnaire d’application pour installer Python . Par exemple, avec les distribu-
tion Linux Debian, Ubuntu et Mint, il faut utiliser les commandes suivantes :
$ sudo apt-get update
$ sudo apt-get install python3.6
Sous Fedora, il suffit d’utiliser la commande :
$ sudo dnf install python3
Contrairement à l’installation simplifiée avec Anaconda, il n’y a aucun
paquet supplémentaire installé par défaut. Il faudra installer soi-même les li-
brairies utilisées tout au long de ce livre.

Installer des paquets supplémentaires

Le gestionnaire de paquets de python permet d’installer des libraires sup-

plémentaires, Par exemple Pillow est une librairie populaire pour lire et enre-
gistrer des images. La commande pour installer ce paquet est :
$ pip install pillow

Remarque : Si pour lancer Python vous devez utiliser python3 (voir la sec-
tion 1.3), alors il faudra utiliser pip3 pour installer des paquets.
Chapitre 1. Prise en Main 11

La commande suivante permet d’installer tous les paquets utilisées dans

ce livre :
$ pip install numpy scipy ipython
Sous Windows, en fonction de la version et des paramètres d’installation, il
faudra mettre à jour la variable d’environnement PATH. Par défaut les nou-
veaux paquets sont installés dans
C : \ U s e r s \ < u s e r > \ AppData \ Roaming \ P y t h o n \ Python <XX> \ S c r i p t s

Les éléments indiqués avec le symbole < >, sont à adapter en fonction de votre
installation et système. Ce chemin doit être ajouté à la variable PATH. Pour
cela il faut utiliser l’interface d’édition des variables d’environnement de Win-
dows.

1.3 Lancer Python

Quelle que soit la méthode d’installation choisie, et peu importe votre sys-
tème d’exploitation, il maintenant possible exécuter le programme Python
dans un terminal en tapant :
python
On obtient alors l’affichage
Python 3.7.6 (default, Jan 8 2020, 19:59:22)
[GCC 7.3.0] :: Anaconda, Inc. on linux
>>>
Les information affichées décrivent la version de Python et votre sys-
tème. Dans le cas où cette commande indique qu’il s’agit de la version 2 de
Python , il vous faudra utiliser python3 comme commande pour accéder à la
version 3. Ceci est dû au fait que la nouvelle installation ne supprimera pas la
version 2 si elle est déjà présente.
Pour quitter, entrer la commande
>>> exit()
12 Programmation Python

2 Utiliser Python
Sous Python il est commun de considérer deux modes d’utilisation :
— le mode interactif
— le mode programmation (également appelé mode scripts Python).
Lorsqu’on travaille en mode interactif on tape les commandes Python une
par une. Python interprète immédiatement ces commandes et les exécute.
Le mode interactif devient inconfortable lorsque l’on écrit de longs codes, qui
sont mieux gérés par les scripts et le mode programmation. Dans ce cas, les
scripts sont d’abords entièrement écrits avant d’être exécutés par l’interpréteur
Python .

2.1 Exemples en mode interactif avec IPython

Pour travailler en mode interactif, nous utiliserons IPython qui est un
terminal Python interactif amélioré. Pour cela, il faut ouvrir un terminal et
taper
ipython
Le début de l’affichage résultant indique la version de Python utilisée (ici
la version 3.8.11).

L’invite IPython affiche In[1] au début d’une session. Cela signifie

que l’invite IPython attend que l’utilisateur tape la première entrée. Lorsque
vous saisissez une entrée et exécutez l’expression en appuyant sur la touche
Entrée, vous obtenez une sortie avec l’invite Out[1], ce qui signifie que
c’est la sortie correspondant à la première expression Python introduite après
l’invite In[1]. Les nombres entre crochets continuent d’augmenter de un, ce
qui est particulièrement utile lors du suivi du flux de travail au cours d’une
Chapitre 1. Prise en Main 13

session. Ces numéros sont réinitialisés à chaque fois qu’une nouvelle session
démarre.
Par exemple si on écrit :
In [1]: print(’hello world’)
on obtient :
In [1]: print(’hello world’)
hello world
La commande Python est exécutée immédiatement après la validation à l’aide
de la touche Entrée.
Beaucoup d’exemples de ce manuel, même ceux saisis à l’invite de l’inter-
préteur, incluent des commentaires. Les commentaires en Python commencent
avec un caractère croisillon, #, et s’étendent jusqu’à la fin de la ligne. Un com-
mentaire peut apparaître au début d’une ligne ou à la suite d’un espace ou
d’une ligne de code, mais pas à l’intérieur d’une chaîne de caractères littérale.
Comme les commentaires ne servent qu’à expliquer le code et ne sont pas in-
terprétés par Python, ils peuvent être ignorés lorsque vous tapez les exemples.
Exemple 1 : Utilisation comme calculatrice.

In [2]: 1+2 #Addition de deux nombres

Out[2]: 3

Exemple 2 : Utilisation comme calculatrice scientifique.

Pour calculer x2 pour x = 3 :
In [3]: x=3

In [4]: x**2 # x puissance 2

Out[4]: 9

Exemple 3 : Message d’erreur lors d’une erreur de syntaxe

In [5]: print(’Hello,World)
File "<ipython-input-5-54c57ebe48d8>", line 1
print(’Hello,World)
^
SyntaxError: EOL while scanning string literal
14 Programmation Python

Nous utiliserons le mode interactif dans les premiers chapitres de ce livre,

pour éviter d’être distraits par le grand nombre d’informations contenues dans
les interfaces graphiques.

2.2 Exécuter un programme dans un terminal

Un script Python est un fichier texte, ASCII ou UTF-8, contenant le code
Python . Les fichiers scripts sont habituellement sauvegardés avec des noms
ayant une extension finale .py, par exemple myscript.py.
Reprenons notre exemple hello world. Cette fois, nous utilisons un éditeur
de texte standard pour taper le texte suivant : :
print(’hello world’)
Puis nous enregistrons ce texte dans un fichier texte hello.py Une fois
que l’on a écrit et enregistré ce script, on peut l’exécuter dans le terminal en
tapant simplement :
python3 hello.py
La commande python3 suivie d’un nom de fichier n’entre pas en mode in-
teractif, mais lit le fichier, l’interprète et l’exécute. C’est le mode programme.

3 Spyder et Jupyter
L’objet de cette section est d’apprendre à utiliser le mode script avec Spyder
et le mode interactif avec Jupyter. Nous utiliserons ces deux applications
successivement pour résoudre l’exercice suivant.

Exercice :
Écrire un programme pour calculer la surface d’un cercle de rayon connu.
Méthode :
— Définir le nombre π,
— Définir le rayon du cercle
— Calculer la surface à l’aide de la formule : S = πr2 ,
— Afficher le résultat.
Chapitre 1. Prise en Main 15

Le programme Python traduisant ces étapes est :

pi=3.14
r=2 # rayon en m
S=pi*r**2 # surface en m^2
# --------Affichage ------------
print(f’rayon = {r} m’)
print(f’surface = {S} m^2’)

3.1 Exemple avec Spyder

Spyder est un environnement de développement intégré créé pour la
programmation scientifique. Spyder est livré avec plusieurs fonctionnalités
telles qu’un éditeur de code, une console interactive IPython et un explorateur
de variables. La fenêtre Spyder contient plusieurs volets comme illustré par
la Figure ci-dessous. Les lecteurs ayant utilisé MATLAB trouveront ici une in-
terface familière, particulièrement utile pour la modélisation et la simulation.
L’IDE Spyder est déjà inclus dans l’installation d’Anaconda.
Pour lancer Spyder, on peut le sélectionner dans la liste des programmes
installés sur l’ordinateur ou à partir d’un terminal (console) ou une fenêtre de
commande, en exécutant la commande :
spyder

Aide

Editeur

Console IPython

Interface Spyder.
16 Programmation Python

Console IPython

Dans le volet situé en bas à droite de la fenêtre, Spyder propose une console
interactive (ou shell Python ). Par défaut, il lance IPython que nous avons
vu plus haut et, de façon similaire, on peut taper des commandes Python qui
seront exécutées immédiatement.

L’explorateur d’objets

La partie supérieure droite de la fenêtre affiche le volet Aide. Il affichera au-

tomatiquement la documentation d’une fonction ou d’un objet en cours d’uti-
lisation dans l’éditeur ou la console. Vous pouvez aussi taper un nom de fonc-
tion dans le champ Objet en haut de la fenêtre pour afficher la documentation
correspondante.
Dans le même volet que l’aide se trouve l’explorateur de variables. Un
clic sur le bouton Explorateur de variables en bas du volet fera basculer la
vue vers l’Explorateur de variables. Cela vous donne une vue sur les variables
globales pour la console actuelle. Il sera vide jusqu’à ce que l’on saisisse des
commandes pour créer ou modifier des variables dans la console ou exécute
un script dans l’éditeur. Les types de variables les plus courants peuvent être
affichés et les variables peuvent être modifiées dans cette interface. On peut
également faire des tracés rapides de tableaux et afficher des matrices sous
forme d’images. De plus, à l’aide de l’icône Importer des données
(icône flèche pointant vers le bas), il est possible d’importer des données à
partir de la grande variété de formats pris en charge.

La fenêtre de l’éditeur

Le volet de gauche affiche l’éditeur Spyder. L’éditeur de code est l’es-

pace où vous pouvez écrire vos codes et scripts Python . Il permet l’édition
de Python et inclut des fonctionnalités telles que la coloration syntaxique, la
navigation fonction/classe/méthode, l’analyse de code, l’introspection, etc...
En haut de la fenêtre Spyder se trouvent des contrôles de débogage qui vous
permettent d’exécuter le fichier actuel du volet Éditeur dans la console
IPython.
Chapitre 1. Prise en Main 17

— Lancer Spyder : Dans la console, taper

spyder

— Spyder se lance.

Explorateur de variables

Editeur

Volet IPython

Interface Spyder.
— En mode script on utilise la fenêtre de gauche, appelée éditeur de
Spyder, dans laquelle les premières lignes sont :
#!/usr/bin/env python
# -* - coding: utf -8 -* -

À la suite de ces lignes, on écrit les unes à la suite des autres les lignes
d’instruction Python qui répondent au problème posé.
18 Programmation Python

— On sauvegarde le programme dans un fichier qui recevra par défaut l’ex-

tension .py, comme par exemple python chap1exo1.py.

— On lance l’exécution du programme avec run.

— Quand le texte ne contient plus aucune erreur de syntaxe, le programme
s’exécute et toutes les entrées-sorties s’effectuent dans la console IPy-
thon, volet en bas à droite.

— On peut vérifier la nature et le nombre de variables créées dans le volet

exploration de variables, volet en haut à droite.

— Pour quitter, aller dans le menu à fichier->quitter.

Chapitre 1. Prise en Main 19

Remarque : Par la suite, le programme ainsi sauvegardé pourra être exécuté

en lançant dans un terminal la commande python chap1exo1.py.

3.2 Exemple avec Jupyter

Jupyter est une application Web qui permet d’exécuter du code infor-
matique. Pour cela Jupyter s’appuie sur des programmes indépendants ca-
pables d’interpréter le langage dans lequel est écrit ce code. Nous utiliserons
le noyau pour le langage Python 3 . Les documents Jupyter sont appelés
des notebooks. Un fichier notebook est reconnaissable par son extension
.ipynb.
- Lancer Jupyter en tapant dans une console :

jupyter notebook

- Jupyter ouvre une fenêtre avec l’adresse url :

http://localhost:8888/tree

- Ouvrir un nouveau fichier en cliquant Nouveau et choisir Python .

- Une nouvelle fenêtre s’ouvre. Dans la première cellule taper les lignes
d’instruction Python . Puis cliquer sur Exécuter. S’il n’y a pas d’erreurs
de syntaxe, les résultats sont affichés dans la cellule de sortie suivante.
20 Programmation Python

- Sauvegarder le fichier en allant dans la barre de menu à fichier->

save as. Dans la boîte de dialogue qui s’ouvre, choisir le nom du fichier, par
exemple chap1exo1. Les fichiers Jupyter recoivent par défaut l’extension
.ipynb.
- Quitter Jupyter en cliquant sur Quit puis se déconnecter.

Remarque : Il est très utile de créer un répertoire dans lequel seront sauve-
gardés tous les programmes.

4 Comment utiliser ce livre

Dans la partie cours, le lecteur est invité à écrire tous les exemples proposés
en utilisant soit IPython soit Jupyter notebook.
Pour résoudre les exercices, le lecteur utilisera de préférence, Jupyter
notebook ou l’IDE Spyder. Le lecteur pourra choisir l’une ou l’autre selon
sa convenance.
Chapitre 1. Prise en Main 21

Exercice d’application
Dans les premiers chapitres de ce livre nous utilisons le mode interactif à
l’aide de IPython. Cette procédure permettra au lecteur de suivre de manière
interactive le résultat de chaque commande Python .
Pour cela, il suffit d’ouvrir un terminal et de taper ipython. On obtient alors
l’affichage suivant qui indique que dans cet exemple on utilise la version 3.8.11
de Python .
Python 3.8.11 (default, Aug 3 2021, 15:09:35)
Type "copyright", "credits" or "license"
for more information.

IPython 7.22.0 -- An enhanced Interactive Python.

L’invite IPython affiche In[1] au début d’une session. Cela signifie que
l’invite IPython attend que l’utilisateur tape la première entrée. Lorsque vous
saisissez une entrée et exécutez l’expression en appuyant sur la touche Entrée,
vous obtenez une sortie avec l’invite Out[1], ce qui signifie que c’est la sortie
de la première expression Python à In[1].
Pour un premier essai, nous allons tester quelques commandes Python en
mode interactif. Pour cet exercice il suffit simplement de taper les commandes
Python en respectant la syntaxe et de noter les différentes réponses obtenues
Le résultat de chaque entrée In[n]: est affiché par la sortie correspon-
dante Out[n] :.
In [1]: 1.25+3.51
Out[1]: 4.76

In [2]: x=3

In [3]: y=x**2

In [4]: print(y)
9

In [5]: modele=’berline’

In [6]: print(’le carré de {} vaut {}’.format(x,y))

le carré de 3 vaut 9
22 Programmation Python

In [7]: print(f’Cette voiture est une {modele}’)

Cette voiture est une berline
Pour fermer la console IPython, il faut taper exit() :
In [6]: exit()
Chapitre 2

Types de données

Dans ce chapitre :
— Types de données
— Types numériques : bool, int, float, complex
— Chaînes de caractères
— Listes
— Dictionnaires
— Tuples
— Set

Travaux Dirigés:
Exercices corrigés

23
24 Programmation Python

En informatique, les variables sont des symboles qui associent un nom

(l’identifiant) à une valeur. Dans la plupart des langages et notamment les plus
courants, les variables peuvent changer de valeur au cours du temps (dyna-
mique). Le type d’une variable correspond à la nature de celle-ci.
Nous commençons par les types de base (ou primitifs) de Python . Il
s’agit de :
— bool : type booléen dont les seules valeurs permises sont True ou
False correspondant aux valeurs 0 ou 1 respectivement.
— int : type entier correspondant à des nombres entiers tels que 42 ou
100000000 par exemple.
— float : nombres réels ou en virgule flottante (comme par exemple
3.14159 ou 1.0e8, qui correspond à 108 ).
— complex : type complexe correspondant aux nombres complexes (comme
par exemple 2+3i)
— str : type chaîne de caractères (séquence de caractères)

Remarque : La fonction type permet de connaître la nature d’une variable

ou d’une donnée (voir les exemples plus loin).

1 Les types numériques

1.1 Le type int

int est un nombre entier, positif ou négatif, sans décimales, de longueur
illimitée.
Exemple 1 :

In [1]: x=123456789

In [2]: y=12386669999999999456

In [3]: z=-128

In [4]: type(x)
Out[4]: int
Chapitre 2. Types de données 25

In [5]: type(y)
Out[5]: int

In [6]: type(z)
Out[6]: int

1.2 Le type float

Sous Python un type nombre réel, ou nombre à virgule flottante, est
désigné par float. Ce type autorise les calculs sur de très grands ou très
petits nombres (données scientifiques, par exemple), avec un degré de préci-
sion constant. Le type float permet de manipuler des nombres (positifs ou
négatifs)compris entre 10−308 et 10308 avec une précision de 12 chiffres signi-
ficatifs. Pour qu’une donnée numérique soit considérée par Python comme
étant du type float, il suffit qu’elle contienne dans sa formulation un élément
tel qu’un point décimal ou un exposant de 10.
Exemple 2 :

In [6]: a=3.14

In [7]: b=10.

In [8]: c=0.001

In [9]: d=1.e100

In [10]: e=1e100

In [11]: f=3.14e-10

In [12]: type(a)
Out[12]: float

In [13]: type(b)
Out[13]: float

In [14]: type(c)
26 Programmation Python

Out[14]: float

In [15]: type(d)
Out[15]: float

In [16]: type(e)
Out[16]: float

In [17]: type(f)
Out[17]: float

1.3 Le type complex

Le type complex définit les nombres complexes. La syntaxe est +j
comme illustré dans les exemples suivants.
Exemple 3 :
In [1]: z1=2+3j

In [2]: type(z1)
Out[2]: complex

In [3]: z1.real
Out[3]: 2.0

In [4]: z1.imag
Out[4]: 3.0

In [5]: z2=1+4j

In [6]: somme=z1+z2

In [7]: somme
Out[7]: (3+7j)

In [8]: produit=z1*z2

In [9]: produit
Out[9]: (-10+11j)
Chapitre 2. Types de données 27

1.4 Le type boolean

Le type boolean est le type logique ; les seules valeurs permises sont
True ou False.
Exemple 4 :

In [1]: 4<5
Out[1]: True

In [2]: test=(4<5)

In [3]: test
Out[3]: True

In [4]: type(test)
Out[4]: bool

1.5 Transtypage
A partir d’une donnée numérique, il est possible de créer une variable
d’un autre type à l’aide des fonctions int() , float(), complex() et
bool().
Exemple 5 :

In [1]: a=1

In [2]: type(a)
Out[2]: int

In [3]: float(a)
Out[3]: 1.0

In [4]: type(a)
Out[4]: int

In [5]: b=1.2

In [6]: type(b)
28 Programmation Python

Out[6]: float

In [7]: int(b)
Out[7]: 1

In [8]: c=2+3j

In [9]: type(c)
Out[9]: complex

In [12]: complex(a)
Out[12]: (1+0j)

In [13]: complex(b)
Out[13]: (1.2+0j)

In [14]: d=True

In [15]: int(d)
Out[15]: 1

In [16]: e=False

In [17]: int(e)
Out[17]: 0

In [18]: float(d)
Out[18]: 1.0

In [19]: type(e)
Out[19]: bool

In [20]: bool(0)
Out[20]: False

In [21]: bool(1)
Out[21]: True

In [22]: bool(1.)
Chapitre 2. Types de données 29

Out[22]: True

In [23]: bool(0.5)
Out[23]: True

In [24]: bool(0)
Out[24]: False

In [25]: bool(0.)
Out[25]: False

Remarque : Il faut remarquer que la variable initiale n’est pas modifiée. On

crée une nouvelle variable correspondant au transtypage demandé.

Remarque : Pour une variable c de type complexe, les instructions int(c)

et float(c) renvoient un message d’erreur.

1.6 Opérateurs arithmétiques

Les opérateurs arithmétiques sont utilisés pour effectuer les opérations ma-
thématiques courantes sur les données numériques.

Operateur Nom Exemple

+ Addition x+y
- Soustraction x-y
* Multiplication x*y
/ Division x/y
% Modulo x%y
** Exponentiation x ** y
// Division entière x // y
30 Programmation Python

Exemple 6 : Utilisation comme calculatrice

In [1]: 2*5
Out[1]: 10

In [2]: 3.2+5.4
Out[2]: 8.600000000000001

In [3]: 4.22-0.21
Out[3]: 4.01

In [4]: 2**10
Out[4]: 1024

In [5]: 10/3
Out[5]: 3.3333333333333335

In [6]: 10//3
Out[6]: 3

In [7]: 10%3
Out[7]: 1

Remarque : Certains résultats montrent les limites de précision des opéra-

tions sur les nombres à virgule flottante.
Chapitre 2. Types de données 31

2 Chaînes de caractères

2.1 Création
La création de chaînes de caractères se fait comme pour les nombres. Il faut
simplement écrire le contenu de la chaîne entre guillemets simples ou doubles.
Exemple 7 :
In [1]: s="Hello World"

In [2]: s
Out[2]: ’Hello World’

2.2 Fonctions de chaînes

Python possède un certain nombre de fonctions qui permettent d’obte-
nir les caractéristiques des chaînes de caractères, de modifier l’aspect de leur
affichage (format) et de les manipuler.
Exemple 8 : La fonction len() permet d’obtenir le nombre de caractères
contenus dans une chaîne.
In [10]: nom="Benmohamed"

In [11]: len(nom)
Out[11]: 10

Exemple 9 : La fonction print permet d’afficher les chaînes à l’écran.

In [8]: salut="Bonjour"

In [9]: print(salut)
Bonjour

2.3 Méthodes
En Python, les variables sont également dotées de fonctionnalités sup-
plémentaires, appelées méthodes. Ces méthodes dépendent du type de la va-
riables. La syntaxe est assez simple : les méthodes sont ajoutées à la fin du
32 Programmation Python

nom de la variable et sont suivies de parenthèses. Ces parenthèses contiennent

toutes les informations dont la méthode pourrait avoir besoin.
Commençons par des méthodes simples applicables aux chaînes de carac-
tères. Celles-ci ne nécessitent pas d’arguments et sont utilisées pour modifier
la façon dont les lettres des chaînes sont formatées.
• .upper()convertit toutes les lettres de la chaîne en majuscules,
• .lower()convertit toutes les lettres de la chaîne en minuscules,
• .capitalize()convertit en majuscule uniquement la première lettre
de la chaîne,
• .title()convertit en majuscule la première lettre de la chaîne et la
première lettre du mot qui suit une ponctuation ou une espace.

Exemple 10 :

In [12]: titre="le Corbeau et le Renard"

In [13]: titre.lower()
Out[13]: ’le corbeau et le renard’

In [14]: titre.upper()
Out[14]: ’LE CORBEAU ET LE RENARD’

In [15]: titre.capitalize()
Out[15]: ’Le corbeau et le renard’

In [16]: titre.title()
Out[16]: ’Le Corbeau Et Le Renard’
Ces méthodes ne modifient pas le contenu de la chaîne mais retournent une
nouvelle chaîne. La variable originale reste inchangée.
Exemple 11 :

In [17]: titre
Out[17]: ’le Corbeau et le Renard’
Chapitre 2. Types de données 33

Exemple 12 : Deux autres méthodes, .isalpha() et .isdigit() per-

mettent de tester si une chaîne contient uniquement des lettres ou des chiffres.
In [18]: mot1="lecorbeau"

In [19]: mot2="le corbeau"

In [20]: mot3="5 renards"

In [21]: mot4="1980"

In [22]: mot1.isalpha()
Out[22]: True

In [23]: mot1.isdigit()
Out[23]: False

In [24]: mot2.isalpha()
Out[24]: False

In [25]: mot2.isdigit()
Out[25]: False

In [26]: mot3.isalpha()
Out[26]: False

In [27]: mot3.isdigit()
Out[27]: False

In [28]: mot4.isalpha()
Out[28]: False

In [29]: mot4.isdigit()
Out[29]: True
34 Programmation Python

2.4 Opérations sur les chaines

Concatenation

Les chaines de caractères peuvent être concaténées, c’est-à-dire collées les

unes à la suite des autres pour créer une nouvelle chaîne. Pour réaliser cette
opération, on utilise le symbole +.
Exemple 13 :

In [1]: nom="Ali"
In [2]: prenom="Benmohamed"
In [3]: nom+prenom
Out[3]: ’AliBenmohamed’

Remarque : Python n’ajoute pas un espace entre les deux chaînes. Pour le
faire, il ajouter explicitement cet espace.

Exemple 14 :

In [4]: nom+" "+prenom

Out[4]: ’Ali Benmohamed’

Répétition

Pour répéter une chaîne, on utilise le symbole de multiplication ∗ suivi par

un entier (int).
Exemple 15 :

In [5]: objet="stylo"
In [6]: objet*5
Out[6]: ’stylostylostylostylostylo’

Exemple 16 : On peut ajouter une espace entre les différentes répétitions de

la chaîne.
In [7]: objet="stylo "
In [8]: objet*5
Out[8]: ’stylo stylo stylo stylo stylo ’
Chapitre 2. Types de données 35

Exemple 17 : Si la chaîne contient un nombre, la répétition de la chaîne donne

une nouvelle chaîne sans faire le calcul numérique.
In [9]: s=’4’
In [10]: 4*s
Out[10]: ’4444’

Exemple 18 : La multiplication par un entier négatif donne une chaîne vide.

In [11]: objet*-5
Out[11]: ’’

Remarque : La multiplication par un float donne un message d’erreur.

Comparaison de chaînes

La comparaison de deux chaînes s’obtient à l’aide de l’opérateur logique

==. Si les deux chaînes sont identiques on obtient True, sinon on obtient
False.
Exemple 19 :

In [30]: ville1="Alger"

In [31]: ville2="Oran"

In [32]: ville3="alger"

In [33]: ville4=’Alger’

In [34]: ville1==ville2
Out[34]: False

In [35]: ville1==ville3
Out[35]: False

In [36]: ville1==ville4
Out[36]: True
36 Programmation Python

In [37]: ’Alger’==’Alger ’
Out[37]: False

Remarque : En Python les seules opérations permises avec les chaînes

sont : l’addition entre chaînes et la multiplication par un nombres entier.

Exemple 20 :

In [38]: ville1*5
Out[38]: ’AlgerAlgerAlgerAlgerAlger’

In [39]: ville1+" et "+ville2

Out[39]: ’Alger et Oran’

Format des chaînes

Le symbole \(barre oblique inversée) est appelé antislash ou échappement

(escape en anglais). Il permet de faire apparaître certains caractères spéciaux
dans les chaînes comme illustré avec les exemples ci-dessous.
Exemple 21 : On utilise \n pour un retour à la ligne.

In [41]: fable="Maitre Corbeau \nTenait en son bec

un fromage"

In [42]:print(fable)
Maitre Corbeau
Tenait en son bec un fromage

Exemple 22 : \t permet d’insérer une tabulation dans une chaîne de carac-

tères.
In [43]: entete="Ordinateur\t Modèle\t Prix"

In [44]: print(entête)
Ordinateur Modèle Prix
Pour supprimer tous les espaces se trouvant au début et à la fin d’une chaîne on
utilise la méthode strip(). Elle permet également de supprimer une lettre
se trouvant aux extrémités de la chaîne.
Chapitre 2. Types de données 37

Exemple 23 :
In [45]: ville=’Sétif ’

In [46]: ville.strip()
Out[46]: ’Sétif’

In [47]: ville=’******Sétif*******’

In [49]: ville.strip(’*’)
Out[49]: ’Sétif’
Les méthodes lstrip() et rstrip() permettent de supprimer un ca-
ractère ou un espace se trouvant respectivement au début ou à la fin de de la
chaîne. Ces méthodes ne modifient pas la chaîne originale mais en créent une
nouvelle.
Exemple 24 :
In [50]: ville.lstrip(’*’)
Out[50]: ’Sétif*******’

In [51]: ville.rstrip(’*’)
Out[51]: ’******Sétif’

Rechercher-Remplacer

Exemple 25 : La méthode count() permet de retrouver le nombre de fois

où une sous-chaîne se trouve à l’intérieur d’une chaîne.
In [52]: mot=’Ali Baba’

In [53]: mot.count(’a’)
Out[53]: 2
Le caractère ’a’ apparaît 2 fois dans la chaîne ’Ali Baba’.
Exemple 26 : Pour trouver la première fois où une sous-chaîne apparaît dans
une chaîne on fait appel à la méthode find().
In [54]: mot.find(’ba’)
Out[54]: 6
38 Programmation Python

Dans la chaîne ’Ali Baba’, la sous-chaîne ’ba’ apparaît à la sixième position.

Exemple 27 : Pour remplacer une sous chaîne par une autre on utilise la mé-
thode replace().
In [55]: mot.replace(’li’,’mar’)
Out[55]: ’Amar Baba’

Format

La méthode format() permet d’afficher un ensemble de chaînes selon

un format particulier. On souhaite afficher M’hend a 30 ans.
Exemple 28 :

In [1]: nom="M’hend"

In [2]: age=30

Remarque : Le mot M’hend contient une apostrophe ; La méthode la plus

simple consiste à définir la chaîne avec des guillemets doubles. Il devient
ainsi possible d’utiliser le symbole ’ dans la chaîne.

In [3]: "{ } a { } ans".format(nom,age)

Out[3]: "M’hend a 30 ans"
Lors de l’affichage la chaîne nom est placée à l’intérieur des deux premières
accolades, tandis que la chaîne correspondant à l’entier age est placée entre
les secondes accolades.
Depuis la version Python 3.6, on peut utiliser une méthode beaucoup
plus simple, la méthode f-strings.
Exemple 29 :

In [4]: f"{nom} a {age} ans"

Out[4]: "M’hend a 30 ans"
La connaissance des formats des chaînes est importante pour l’affichage
des résultats des programmes. La lecture de l’annexe A intitulée Format est
primordiale.
Chapitre 2. Types de données 39

Aide

On peut avoir accès à une aide succincte sur les chaînes de caractères à
l’aide du symbole ?
Exemple 30 :

In [5]: str?
La commande dir permet d’avoir la liste des méthodes associées à un
objet.
Exemple 31 :

In [6]: dir(str)
Out[6]:[...
’capitalize’,
’casefold’,
’center’,
’count’,
’encode’,
’endswith’,
’expandtabs’,
’find’,
’format’,
’format\_map’,
’index’,
....]

Transtypage

Les fonctions int(), float(), complex et str() permettent de conver-

tir des données numériques en chaînes de caractères et réciproquement.
Exemple 32 :

In [1]: a=1

In [2]: b=2.

In [3]: c=3+4j
40 Programmation Python

In [4]: s=’abc’

In [5]: type(a)
Out[5]: int

In [6]: type(b)
Out[6]: float

In [7]: type(c)
Out[7]: complex

In [8]: str(a)
Out[8]: ’1’

In [9]: str(b)
Out[9]: ’2.0’

In [10]: str(c)
Out[10]: ’(3+4j)’

In [12]: s=’3.5’

In [14]: float(s)
Out[14]: 3.5

In [15]: s+s
Out[15]: ’3.53.5’

In [16]: float(s)+float(s)
Out[16]: 7.0

Remarque : Si s est une chaîne qui contient des lettres, l’instruction int(s)
renvoie un message d’erreur
Chapitre 2. Types de données 41

Exercices

Exercice 1 :
Ecrire un programme pour calculer la vitesse d’un mobile ayant parcouru
une distance 19.7 mètres en 6.892 secondes.
— Affectez aux variables temps et distance, les valeurs 6.892 et 19.7.
— Calculez et affichez la valeur de la vitesse.
— Améliorez l’affichage en imposant un chiffre après le point décimal.

Exercice 2 :
Saisir un nom et un âge en utilisant l’instruction input() . Les afficher.
Exercice 3 :
Écrire un programme pour convertir en radians un angle exprimé en de-
grés, minutes, secondes.
Exercice 4 :
Écrire un programme pour convertir en degrés, minutes, secondes un angle
exprimé en radians.
Exercice 5 :
Écrire un programme pour calculer le volume d’un parallélépipède de hau-
teur et longueur et largeur de base connues.
Exercice 6 :
Écrire un programme pour convertir en années, mois, jours, heures, mi-
nutes et secondes, un nombre de secondes donné.
Exercice 7 :
Écrire un programme qui compte le nombre d’occurrences d’un caractère
donné dans une chaîne.
Exercice 8 :
Écrire un programme qui recopie une chaîne (dans une nouvelle variable)
en l’inversant.
42 Programmation Python

Corrigé des exercices

Corrigé exercice 1 :

temps=6.892
distance=19.7
vitesse=distance/temps
print(f’vitesse = {vitesse:.1f}’)

Corrigé exercice 2 :

nom=input(’Nom : ’)
age=input(’Age : ’)
print(’Nom : ’,nom)
print(’Age : ’,age)

Corrigé exercice 3 :

degres=float(input(’Degrés =’))
minutes=float(input(’Minutes =’))
secondes=float(input(’Secondes =’))
radians=3.14*(degres+minutes/60+secondes/3600)/180
sortie=f’{degres:.0f}deg {minutes:.0f}min \
{secondes:.0f}s={radians:.2f} rad’
print(sortie)

Corrigé exercice 4 :

pi=3.14
angleradians=float(input(’Angle en radians = ’))
angledegres=angleradians*180/pi
degres=int(angledegres)
minsec=angledegres%1
mn=int(minsec*60)
sec=(minsec*60-mn)*60
sortie=f’{angleradians}rad = \
{degres}deg {mn}mn {sec:.2f}s’
print(sortie)
Chapitre 2. Types de données 43

Corrigé exercice 5 :

hauteur=float(input(’Hauteur = ’))
longueur=float(input(’Longueur = ’))
largeur=float(input(’Largeur = ’))
volume=longueur*largeur*hauteur
print(’Volume = ’,volume)

Corrigé exercice 6 :

secondes=float(input(’Nombre de secondes = ’))

nombrem=secondes // 60 #Nombre de minutes
restes=secondes % 60
nombreh=nombrem // 60 #Nombre d’heures
restem=nombrem % 60
nombrej=nombreh // 24 #Nombre de jours
resteh=nombreh % 24
nombremois=nombrej // 30 #Nombre de mois
restej=nombrej % 30
nombrea=nombremois // 12 #Nombre d’années
restemois=nombremois % 12
print(secondes,’s=’,nombrea,’années’,\
restemois,’mois’,restej,’jours’,\
resteh,’h’,restem,’mn’,restes,’s’)

Corrigé exercice 7 :

chaine= input(’Entrez la chaine : ’)

caractere=input (’Caractère à rechercher : ’)
napp=chaine.count(caractere)
print(f’{caractere} apparait \
{napp} fois dans {chaine}’)

Corrigé exercice 8 :

chaine_in = input(’Entrer une chaine : ’)

chaine_out=chaine_in[::-1]
print(chaine_out)
Chapitre 3

Conteneurs

Dans ce chapitre : Introduire les différents types de conte-

neurs
— Listes
— Tuples
— Dictionnaires
— Sets

Travaux Dirigés:
Exercices corrigés

45
46 Programmation Python

Un conteneur est un objet contenant un nombre arbitraire d’autres objets.

En règle générale, les conteneurs permettent d’accéder aux objets contenus
et de les parcourir. Python propose différents conteneurs. Les plus courants
sont :
— list est une collection ordonnée et modifiable qui autorise les élé-
ments en double.
— tuple est une collection ordonnée et immuable qui autorise les élé-
ments en double.
— set est une collection non ordonnée et non indexée qui ne possède au-
cun membre en double.
— dict est une collection non ordonnée et modifiable qui associe une clé
à une valeur. Les clés sont uniques.

1 Listes
Une liste est une séquence de valeurs, similaire à un tableau dans d’autres
langages de programmation mais plus polyvalente. Les valeurs d’une liste sont
appelées éléments.
Les propriétés importantes des listes Python sont les suivantes :
• Les listes sont ordonnées : les listes mémorisent l’ordre des éléments
insérés.
• Accès par indice : les éléments d’une liste sont accessibles à l’aide d’un
indice.
• Les listes peuvent contenir n’importe quel type d’objet : il peut s’agir de
nombres, de chaînes et même d’autres listes.
• Les listes sont modifiables (mutables) : on peut modifier une liste, ajou-
ter de nouveaux éléments et supprimer ou mettre à jour des éléments
existants.
Chapitre 3. Conteneurs 47

1.1 Création d’une liste

Il existe plusieurs façons de créer une nouvelle liste ; la plus simple consiste
à mettre les valeurs entre crochets [ ].
Exemple 1 : Une liste d’entiers

L = [1, 2, 3]

Exemple 2 : Une liste de chaînes

couleur = [’rouge’, ’vert’, ’bleu’]

Exemple 3 : Les éléments d’une liste ne sont pas nécessairement du même

type. La liste suivante contient un entier, une chaîne, un flottant, un nombre
complexe et un booléen.
L = [ 1, ’abc’, 1.23, (3+4j), True]

Remarque : Une liste contenant zéro élément est appelée une liste vide et on
peut en créer une avec une paire de crochets vide [].

1.2 Accès aux éléments d’une liste

Pour accéder à un objet quelconque de la liste, on utilise son indice. On
n’oubliera pas que le premier objet est indicé par 0.
Exemple 4 :

In [1]: couleur=[’rouge’,’bleu’,’vert’]

In [2]: type(couleur)
Out[2]: list

In [3]: couleur[1]
Out[3]: ’bleu’

In [4]: couleur[2]
Out[4]: ’vert’
48 Programmation Python

Exemple 5 : Les indices négatifs permettent de compter les objet à partir de

la fin de la liste.
In [5]: couleur[-1]
Out[5]: ’vert’

In [6]: couleur[-2]
Out[6]: ’bleu’

Exemple 6 : Pour sélectionner une partie de la liste on utilise le slicing. La

commande liste[n:m] permet d’extraire les éléments compris entre les
indices n et m-1 inclus.
In [9]: couleur[1:2]
Out[9]: [’bleu’]

In [10]: couleur[1:3]
Out[10]: [’bleu’, ’vert’]
La syntaxe pour la sélection de certains éléments d’une liste compris entre
début et fin avec un incrément incrément est :
liste[début:fin:incrément]
Les paramètres d’indexation (début,fin et incrément) sont optionnels.
Exemple 7 : Pour sélectionner tous les éléments compris entre l’indice 0 et
l’indice 2 inclus, on écrit :
In [15]: ma_liste=[’aa’,’bb’,’cc’,’dd’]

In [16]: ma_liste[0:3]
Out[16]: [’aa’, ’bb’, ’cc’]

Exemple 8 : Pour sélectionner tous les objets depuis l’indice 2 jusqu’à la fin
de la liste :
In [17]: ma_liste[2:]
Out[17]: [’cc’, ’dd’]
Chapitre 3. Conteneurs 49

Exemple 9 : Pour sélectionner tous les éléments de la liste dont l’indice varie
avec un incrément égal à 2 :
In [18]: ma_liste[::2]
Out[18]: [’aa’, ’cc’]
Les objets de la liste peuvent être modifiés, on dit que les listes sont des
objets mutables.
Exemple 10 : Pour modifier les éléments d’indices 1 et 2 de la liste ma_liste.

In [22]: ma_liste=[’aa’,’bb’,’cc’,’dd’]

In [23]: ma_liste[1:3]=’ab’,’ac’

In [24]: print(ma_liste)
[’aa’, ’ab’, ’ac’, ’dd’]

1.3 Fonctions de listes

Python possède également des fonctions internes destinées aux listes.

Fonction Description
all() Renvoie True si tous les éléments sont "vrais"
any() Renvoie True si l’un des éléments de la liste est vrai
enumerate() Prend une liste et renvoie un objet énuméré
len() Renvoie le nombre d’éléments d’une liste
list() Convertit un itérable (tuple, chaîne, set, ....) en liste
max() Renvoie le plus grand élément d’une liste
min() Renvoie le plus petit élément d’une liste
sorted() Renvoie une liste triée
sum() Somme tous les éléments d’une liste
50 Programmation Python

Exemple 11 :

In [1]: x=[0,-1,3,-5,0]

In [2]: len(x)
Out[2]: 5

In [3]: max(x)
Out[3]: 3

In [4]: min(x)
Out[4]: -5

In [5]: sorted(x)
Out[5]: [-5, -1, 0, 0, 3]

In [6]: x
Out[6]: [0, -1, 3, -5, 0]

In [7]: sum(x)
Out[7]: -3

1.4 Méthodes
Les listes possèdent des méthodes qui permettent de les manipuler.

Méthode Description
append() Ajoute un élément à la fin de la liste
insert() Insère un élément à une position donnée
extend() Étend la liste en ajoutant tous les éléments d’un "itérable"
remove() Supprime la première instance d’un élément spécifié
pop() Supprime le dernier élément d’une liste
clear() Supprime tous les éléments d’une liste
copy() Renvoie un copie de la liste
count() Renvoie le nombre d’un élément spécifié
index() Renvoie l’indice de la première position d’un élément spécifié
reverse() Inverse l’ordre des éléments de la liste
sort() Tri par ordre croissant des éléments de la liste
Chapitre 3. Conteneurs 51

Exemple 12 :

In [1]: ma_liste=[’rouge’,’bleu’]

In [2]: couleur.append(’rose’)

In [3]: couleur
Out[3]: [’rouge’,’bleu’,’rose’]

#Supprimer et afficher le dernier element

In [4]: couleur.pop()
Out[4]: ’rose’

In [5]: couleur
Out[5]: [’rouge’,’bleu’]

In [7]: couleur.extend([’rose’,’violet’])

In [8]: couleur
Out[8]: [’rouge’,’bleu’,’rose’,’violet’]

Exemple 13 : La commande dir(couleur) affiche toutes les méthodes

affiliées à la liste couleur
In [10]: dir(couleur)
Out[10]:[...
’append’,
’clear’,
’copy’,
’count’,
’extend’,
’index’,
’insert’,
...]
52 Programmation Python

1.5 Concaténation et répétition

Les listes peuvent être concaténées, grâce à l’opérateur d’addition, ou ré-
pétées, en les multipliant par un entier.
Exemple 14 :

In [11]: liste1=[’Ali’,’Mohamed’]

In [12]: liste2=[’Fatima’,’Malika’]

In [13]: liste1
Out[13]: [’Ali’, ’Mohamed’]

In [14]: liste2
Out[14]: [’Fatima’,’Malika’]

In [15]: liste1+liste2
Out[15]: [’Ali’,’Mohamed’,’Fatima’,’Malika’]

In [16]: liste1*2
Out[16]: [’Ali’,’Mohamed’,’Ali’,’Mohamed’]

2 Tuples
Les tuples sont des listes non mutables ou immuables : on ne peut pas
les modifier.
Similairement aux listes, un tuple contient donc des éléments ordonnés
et autorise la présence de valeurs en double. On peut accéder aux éléments
d’un tuple avec leur index. Par exemple, le premier élément est à l’index 0.
En revanche, contrairement aux listes, les tuples ne sont pas modifiables. Cela
signifie que l’on ne peut pas modifier, ajouter ou supprimer des éléments une
fois que le tuple a été créé.
Chapitre 3. Conteneurs 53

2.1 Créer un tuple

Les éléments d’un tuple sont écrits soit entre parenthèses () ou simple-
ment séparés par des virgules.
Exemple 15 :

In [18]: tuplexemple=125,’Omar’,1e-10

In [19]: type(tuplexemple)
Out[19]: tuple

In [20]: tuplexemple[1]
Out[20]: ’Omar’

In [21]: tuplexemple[-1]
Out[21]: 1e-10

In [22]: autrexemple=(’maison’,0.25,True)

In [23]: type(autrexemple)
Out[23]: tuple

In [24]: autrexemple[1]
Out[24]: 0.25
Pour déterminer le nombre d’éléments d’un tuple, on utilise la fonction
len() :
In [25]: fruits = ("pomme", "banane", "fraise")

In [26]: len(fruits)
Out[26]: 3
Pour créer un tuple avec un seul élément, on doit ajouter une virgule
après l’élément, sinon Python ne le reconnaîtra pas comme un tuple.
In [27]: untuple = ("pomme",) # Un tuple

In [28]: type(untuple)
Out[28]: tuple

In [29]: cefruit = ("pomme") # Non tuple

54 Programmation Python

In [30]: type(cefruit)
Out[30]: str

Exemple 16 : Les éléments d’un tuple peuvent être de n’importe quel type de
données.
tuple1 = ("pomme", "banane", "fraise")
tuple2 = (1, 5, 7, 9, 3)
tuple3 = (True, False, False)

Exemple 17 : Un même tuple peut contenir différents types de données

tuple1 = ("abc", 34, True, 40, "masculin")

Du point de vue de Python, les tuples sont définis comme des objets avec
le type ’tuple’ : <class ’tuple’>

Remarque : Il est également possible d’utiliser le constructeur tuple()

pour créer un tuple.

2.2 Accès aux éléments d’un tuple

L’indexation fonctionne ici de la même manière que pour les listes : on
peut accéder aux éléments d’un tuple en se référant au numéro d’index, entre
crochets ; l’indexation négative est possible et signifie commencer par la fin.
Enfin, il est possible de spécifier une plage d’index en spécifiant où commencer
et où terminer la plage.
Exemple 18 : Pour imprimer le deuxième élément du tuple

cesfruits = ("pomme", "banane", "fraise")

print(cesfruits[1])

Exemple 19 : Pour imprimer le dernier élément du tuple

cesfruits = ("pomme", "banane", "fraise")

print(cesfruits[-1])
Chapitre 3. Conteneurs 55

Exemple 20 : Pour renvoyer les troisième, quatrième et cinquième éléments

fruits= ("pomme","banane","fraise","orange","kiwi",
"melon","mangue")
print(fruits[2:5])

(’fraise’, ’orange’, ’kiwi’)

Exemple 21 : La plage commence au premier élément si l’on omet la valeur

de départ
fruits = ("pomme","banane","fraise","orange","kiwi",
"melon","mangue")
print(fruits[:4])

(’pomme’, ’banane’, ’fraise’, ’orange’)

3 Dictionnaires
En Python, un dictionnaire est un objet mutable qui contient les données
sous la forme de paires clé :valeur. Comme les listes, les dictionnaires sont
des objets pouvant en contenir d’autres. Cependant, au lieu d’héberger des
informations dans un ordre précis, ils associent chaque objet contenu à une
clé. Habituellement la clé est une chaîne de caractères, mais ce n’est pas une
contrainte.
Comme exemple pratique, un dictionnaire peut être utilisé comme struc-
ture de données pour stocker un carnet d’adresses. On accède à chaque contact
en précisant son nom.
Parmi les propriétés des dictionnaires on peut citer :
— Non ordonné : cela signifie que les éléments n’ont pas d’ordre défini. On
ne peut pas faire référence à un élément en utilisant un index.
— Modifiable : on peut modifier, ajouter ou supprimer des éléments une
fois le dictionnaire créé.
— Clé unique : les dictionnaires ne peuvent pas avoir deux éléments avec
la même clé. Utiliser une clé existante revient à remplacer la valeur en-
registrée.
56 Programmation Python

Exemple 22 : Initialisation d’un dictionnaire

In [1]: voiture = {
...: "marque": "Ford",
...: "modèle": "Mustang",
...: "année": 1964
...: }

Exemple 23 : Exemple de réutilisation d’une clé

In [3]: voiture = {
...: "marque": "Ford",
...: "modèle": "Mustang",
...: "année": 1964,
...: "année": 2000
...: }

In [4]: voiture
Out[4]: {’marque’: ’Ford’, ’modèle’: ’Mustang’,
’année’: 2000}

Exemple 24 : Pour déterminer le nombre d’éléments d’un dictionnaire, on

utilise la fonction len()
In [5]: len(voiture)
Out[5]: 3

3.1 Les éléments des dictionnaires

Les valeurs des éléments du dictionnaire peuvent être de n’importe quel
type de données.
Exemple 25 : Utiliser une liste comme valeur
In [6]: voiture = {
...: "marque": "Ford",
...: "modèle": "Mustang",
...: "année": 1964,
...: "année": 2000,
...: "couleurs": ["rouge", "vert", "bleu"]
...: }
Chapitre 3. Conteneurs 57

On peut accéder aux éléments d’un dictionnaire en se référant à son nom

de clé, entre crochets.
Exemple 26 : Obtenir la valeur de la clé "modèle"

In [7]: voiture["modèle"]
Out[7]: ’Ford’

On peut modifier la valeur d’un élément spécifique en se référant à son

nom de clé.
Exemple 27 : Changez l ’«année» en 2018

In [8]: voiture["année"] = 2018

In [9]: voiture
Out[9]:
{’marque’: ’Ford’,
’modèle’: ’Mustang’,
’année’: 2018,
’couleurs’: [’rouge’, ’vert’, ’bleu’]}
Pour déterminer si une clé spécifiée est présente dans un dictionnaire, on
utilise la commande in :
Exemple 28 :

In [10]: "marque" in voiture

Out[10]: True

In [11]: "moteur" in voiture

Out[11]: False
L’ajout d’un élément au dictionnaire se fait en utilisant une nouvelle clé
d’index et en lui attribuant une valeur :
Exemple 29 :

In [12]: voiture["places"] = 2

In [13]: voiture
Out[13]:
{’marque’: ’Ford’,
58 Programmation Python

’modèle’: ’Mustang’,
’année’: 2000,
’couleurs’: [’rouge’, ’vert’, ’bleu’],
’places’: 2 }

Exemple 30 : Le mot-clé del supprime l’élément avec le nom de clé spécifié.

In [14]: del voiture["modèle"]

In [15]: "modèle" in voiture

Out[15]: False

In [16]: voiture
Out[16]:
{’marque’: ’Ford’,
’année’: 2000,
’couleurs’: [’rouge’, ’vert’, ’bleu’],
’places’: 2 }

Remarque : Le mot-clé del peut également supprimer complètement le dic-

tionnaire.

3.2 Méthodes
Les dictionnaires étant des objets ils possèdent des méthodes. Nous listons
ci-dessous les méthodes les plus communément utilisées pour un aperçu des
possibilités (voir la documentation python pour plus de détails).

Méthode Description
clear() Supprime tous les éléments du dictionnaire
copy() Renvoie une copie du dictionnaire
Renvoie un dictionnaire avec les clés et la valeur
fromkeys()
spécifiées
get() Renvoie la valeur de la clé spécifiée
Renvoie une liste contenant un tuple pour chaque
items()
paire clé : valeur
keys() Renvoie une liste contenant les clés du dictionnaire
Chapitre 3. Conteneurs 59

Méthode Description
pop() Supprime l’élément avec la clé spécifiée
popitem() Supprime la dernière paire clé-valeur insérée
Renvoie la valeur de la clé spécifiée. Si la clé
setdefault()
n’existe pas : insérez la clé, avec la valeur spécifiée
Met à jour le dictionnaire avec les paires clé-valeur
update()
spécifiées
Renvoie une liste de toutes les valeurs du diction-
values()
naire

Tableau de quelques méthodes de la classe ’dict’

Exemple 31 : Obtenir la valeur d’une clé avec get()

In [17]: voiture = {
...: "marque": "Ford",
...: "modèle": "Mustang",
...: "année": 1964
...: }

In [18]: x = voiture.get("modèle")

In [19]: x
Out[19]: ’Mustang’

Exemple 32 : Obtenir une liste des clés avec keys()

In [20]: x = voiture.keys()

In [21]: x
Out[21]: dict_keys([’marque’, ’modèle’, ’année’])

Exemple 33 : Obtenir une liste des valeurs avec values()

In [22]: x = voiture.values()

In [23]: x
Out[23]: dict_values([’Ford’, ’Mustang’, 1964])
60 Programmation Python

Exemple 34 : Obtenir une liste des paires clé :valeur avec items()

In [24]: x = voiture.items()

In [25]: x
Out[25]: dict_items([
(’marque’, ’Ford’),
(’modèle’, ’Mustang’),
(’année’, 1964)
])
La méthode update() mettra à jour le dictionnaire avec les éléments de
l’argument donné. L’argument doit être un dictionnaire ou un objet itérable
avec des paires clé : valeur.
Exemple 35 : Mise-à-jour du dictionnaire en utilisant update()

In [26]: voiture.update({"année": 2020})

In [27]: voiture
Out[27]: {’marque’:’Ford’,’modèle’:’Mustang’,
’année’: 2020}

Exemple 36 : Suppression d’un élément avec pop()

In [28]: voiture.pop("modèle")
Out[28]: ’Mustang’

In [29]: voiture
Out[29]: {’marque’: ’Ford’, ’année’: 2020}

Exemple 37 : Suppression du dernier élément inséré avec popitem()

In [30]: voiture = {
"marque": "Ford",
"modèle": "Mustang",
"année": 1964
}

In [31]: voiture.popitem()
Out[31]: (’année’, 1964)
Chapitre 3. Conteneurs 61

In [32]: voiture
Out[32]: {’marque’: ’Ford’, ’modèle’: ’Mustang’}

Exemple 38 : Vider le dictionnaire avec la méthode clear()

In [33]: voiture.clear()

In [34]: voiture
Out[34]: {}

4 Set
set en Python est une structure de données équivalente aux ensembles
en mathématiques. Un set peut être composé de divers éléments non ordon-
nés et non indicés. On peut ajouter et supprimer des éléments d’un ensemble,
parcourir les éléments de l’ensemble, effectuer des opérations standard sur les
ensembles : union, intersection et différence. Il est également possible de vé-
rifier si un élément appartient à un ensemble.
La création d’un objet de type set s’obtient en mettant tous les éléments
qui le constituent entre accolades {}. L’ordre des éléments est sans importance.
Tout élément dupliqué n’est comptabilisé qu’une seule fois.
Exemple 39 : Création d’un set

In [1]: s1={1,2,3,3,3,4,4} # Créer un set

In [2]: s1
Out[2]: {1, 2, 3, 4}

Exemple 40 : Ajouter un élément

In [3]: s1.add(5)

In [4]: s1
Out[4]: {1, 2, 3, 4, 5}
62 Programmation Python

Exemple 41 : Enlever un élément

In [5]: s1.discard(5)

In [6]: s1
Out[6]: {1, 2, 3, 4}

Exemple 42 : Effacer le contenu d’un set

In [7]: s1.clear()

In [8]: s1
Out[8]: set()

Exemple 43 : Ajouter les éléments d’un autre ensemble

In [1]: s1={1,2}
In [2]: s2={1,2,3,6,7,8}
In [3]: s1.update(s2)

In [4]: s1
Out[4]: {1, 2, 3, 6, 7, 8}
Les opérations suivantes ne modifient pas les ensembles originaux mais
renvoient un nouvel ensemble qui peut être assigné à une variable.
Exemple 44 : Différence

In [1]: s1={1,2,3}
In [2]: s2={3,4,5}

In [3]: s1.difference(s2)
Out[3]: {1, 2}

In [4]: s2.difference(s1)
Out[4]: {4,5}

Exemple 45 : Union et intersection

In [5]: s1.union(s2)
Out[5]: {1, 2, 3, 4, 5}
Chapitre 3. Conteneurs 63

In [6]: s1.intersection(s2)
Out[6]: {3}
Les variables s1 et s2 sont inchangées
In [7]: s1
Out[7]: {1, 2, 3}

In [8]: s2
Out[8]: {3, 4, 5}

Exemple 46 : Application au calcul de probabilités lors d’un lancer un dé

L’évènement "le résultat sera plus petit que 5" est décrit par l’ensemble
A = {1, 2, 3, 4}. De même, l’évènement "le résultat sera pair" est représenté
par B = {2, 4, 6}.
En Python cela donne :
univers={1,2,3,4,5,6}
A={1,2,3,4}
B={2,4,6}
Événements simultanés : L’événement "A et B" se note A ∩ B, et l’opé-
ration se note en Python par une esperluette (&).
univers={1,2,3,4,5,6}
A={1,2,3,4}
B={2,4,6}
print(A & B)
Disjonction : L’événement "A ou B" se note A ∪ B, et en Python, le sym-
bole | (trait vertical).
univers={1,2,3,4,5,6}
A={1,2,3,4}
B={2,4,6}
print(A|B)
Contraire d’un événement : Pour calculer le contraire d’un événement,
on le soustrait à l’univers.
univers={1,2,3,4,5,6}
A={1,2,3,4}
B={2,4,6}
print(univers-A)
print(univers-B)
64 Programmation Python

Probabilité : La probabilité d’un événement est le quotient du nombre de

ses éléments par le nombre des éléments de l’univers. En Python , le nombre
d’éléments d’un événement est obtenu à l’aide de l’instruction len.
univers={1,2,3,4,5,6}
A={1,2,3,4}
B={2,4,6}
print(’P(A) = ’,len(A)/len(univers))
print(’P(B) = ’,len(B)/len(univers))
Chapitre 3. Conteneurs 65

Exercices

Exercice 1 :Définir la liste : liste =[17, 38, 10, 25, 72] , puis
effectuez les actions suivantes :
— triez et affichez la liste ;
— ajoutez l’élément 12 à la liste et affichez la liste ;
— renversez et affichez la liste (sans modifier l’originale) ;
— affichez l’indice de l’élément 17 ;
— enlevez l’élément 38 et affichez la liste ;
— affichez la sous-liste du 2ème au 3ème élément inclus ;
— affichez la sous-liste du début au 2ème élément inclus ;
— affichez la sous-liste du 3ème élément à la fin de la liste ;
— affichez la sous-liste complète de la liste ;
— affichez le dernier élément en utilisant un indexage négatif.

Exercice 2 :
Écrire un programme qui recherche le plus grand élément présent dans une
liste de nombres donnée.
Exercice 3 :
Étant donné la liste : maListe = [100, 200, 300, 400, 500] ; écrire un script
pour afficher cette liste dans l’ordre suivant :[500, 400, 300, 200, 100]
Exercice 4 :
Créer deux listes de votre choix et les concaténer.
Exercice 5 :
list1 = [10, 20, [300, 400, [5000, 6000], 500], 30]
Ajouter 7000 après 6000 dans la liste précédente pour obtenir :
[10, 20, [300, 400, [5000, 6000, 7000], 500], 30]
66 Programmation Python

Exercice 6 :
Ajouter la liste figures_liste au set figures_set pour obtenir un set contenant
toutes les figures d’un jeu de cartes :
figures_set={’valet’,’dame’}
figures_liste=[’roi’,’as’]
Exercice 7 :
T
Trouver l’ensemble des éléments de A B:
A = {10, 20, 30, 40, 50}
B = {30, 40, 50, 60, 70}
Exercice 8 :
S
Trouver l’ensemble des éléments appartenant à A B.
A = {10, 20, 30, 40, 50}
B = {30, 40, 50, 60, 70}
Exercice 9 :
Supprimer de A les éléments qui sont communs avec B.
A = {10, 20, 30}
B = {20, 40, 50}
Exercice 10 :
Déterminer l’ensemble des éléments qui appartiennent soit à A soit à B
mais qui ne leur sont pas communs.
A = {10, 20, 30, 40, 50}
B = {30, 40, 50, 60, 70}
Exercice 11 :
Modifier l’ensemble A en lui ajoutant les éléments de B et en supprimant
les éléments qui ne leur sont pas communs.
A = {10, 20, 30, 40, 50}
B = {30, 40, 50, 60, 70}
Exercice 12 :
Supprimer dans A tous les éléments qui ne sont pas communs à A et B.
A = {10, 20, 30, 40, 50}
B = {30, 40, 50, 60, 70}
Chapitre 3. Conteneurs 67

Corrigé des exercices

Corrigé exercice 1 :

liste = [17, 38, 10, 25, 72]

liste.sort()
print("La liste ordonnée: ", liste)

liste.append(12)
print("Avec 12: ",liste)

nouvelle_liste = liste[::-1]
print("La liste inverse: ", nouvelle_liste)

index = liste.index(17)
print("Le nombre 17 est à l’indice: ", index)

liste.remove(38)
print("Enlever le nombre 38: ", liste)

print("2e au 3e élément: ", liste[1:3])

print("Du début au 2e élément: ", liste[:2])

print("Du 2e élément à la fin: ",liste[2:])

print("La sous-liste complète :", liste[:])

print("Le dernier élément :", liste[-1])

Corrigé exercice 2 :

nombres = [32, 5, 12, 8, 3, 75, 2, 15]

nmax=max(nombres)
print(f’le plus grand élément est {nmax}.’)
68 Programmation Python

Corrigé exercice 3 :

maListe = [100, 200, 300, 400, 500]

maListe.reverse()
print(maListe)

Corrigé exercice 4 :

liste1=[0,1,2,3,4,5]
liste2=[’aa’,’bb’,’cc’]
liste3=liste1+liste2
print(’liste 1 = ’,liste1)
print(’liste 2 = ’,liste2)
print(’liste 3 = ’,liste3)

Corrigé exercice 5 :

list1 = [10, 20, [300, 400, [5000, 6000], 500], 30]

list1[2][2].append(7000)
print(list1)

Corrigé exercice 6 :

figures_set={’valet’,’dame’}
figures_liste=[’roi’,’as’]
figures_set.update(set(figures_liste))
print(figures_set)

Corrigé exercice 7 :

A = {10, 20, 30, 40, 50}

B = {30, 40, 50, 60, 70}
C =A.intersection(B)
print(C)

Corrigé exercice 8 :

A = {10, 20, 30, 40, 50}

B = {30, 40, 50, 60, 70}
C =A.union(B)
print(C)
Chapitre 3. Conteneurs 69

Corrigé exercice 9 :

A = {10, 20, 30}

B = {20, 40, 50}
A.difference_update(B)
print(A)

Corrigé exercice 10 :

A = {10, 20, 30, 40, 50}

B = {30, 40, 50, 60, 70}
C=A.symmetric_difference(B)
print(C)

Corrigé exercice 11 :

A = {10, 20, 30, 40, 50}

B = {30, 40, 50, 60, 70}
A.symmetric_difference_update(B)
print(A)

Corrigé exercice 12 :

A = {10, 20, 30, 40, 50}

B = {30, 40, 50, 60, 70}
A.intersection_update(B)
print(A)
Chapitre 4

Instructions de contrôle

Dans ce chapitre :
— if....else.....elif
— while
— for

Travaux Dirigés:
Exercices corrigés

71
72 Programmation Python

1 Tests logiques
En Python on définit les tests logiques suivants :

Egal a == b
Non égal a != b
Inférieur a<b
Inférieur ou égal a <= b
Supérieur a>b
Supérieur ou égal a >= b

Ces conditions logiques peuvent être utilisées dans différents cas, en par-
ticulier par l’instruction logique if.

2 L’instruction if
L’instruction if, obtenue à l’aide du mot clé if, permet d’exécuter une ou
plusieurs instructions uniquement si le test réalisé est vrai. Les instructions à
exécuter sont indentées. L’indentation consiste à introduire une tabulation vers
la droite de toutes les instructions à exécuter dans le test if. L’indentation est
l’approche utilisée dans le langage Python pour créer des blocs d’instructions.

Exemple 1 :

a = 33
b = 200
if b > a:
print("b est plus grand que a")

b est plus grand que a

Remarque : À partir de ce chapitre, les exemples discutés deviennent plus

complexes et seront donc présentés sous forme de scripts python.
Chapitre 4. Instructions de contrôle 73

2.1 elif
Le mot clé elif est utilisé pour traduire "si la condtion précédente n’est
pas vraie, alors tester la condition qui suit".
Exemple 2 :

a = 33
b = 33
if b > a:
print("b est plus grand que a")
elif a == b:
print("a et b sont égaux")

a et b sont égaux

2.2 else
Le mot clé else permet de réaliser une tâche lorsque aucune des condi-
tions précédentes n’est satisfaite.
a = 200
b = 33
if b > a:
print("b est plus grand que a")
elif a == b:
print("a et b sont égaux")
else:
print("a est plus grand que b")

a est plus grand que b

On peut également avoir l’instruction else sans l’instruction elif
a = 200
b = 33
if b > a:
print("b est supérieur à a")
else:
print("b n’est pas supérieur à a")

b n’est pas supérieur à a

74 Programmation Python

2.3 inline if
L’instruction if peut être écrite sur une seule ligne si une seule instruction
doit être exécutée.
a = 200
b = 33
if a > b: print("a est plus grand que b")

a est plus grand que b

De même si on a une seule commande à exécuter pour un if et une seule
commande à exécuter pour un else, on peut les écrire sur la même ligne.
a = 2
b = 330
print("A") if a > b else print("B")

B
On peut également avoir plusieurs instructions else sur la même ligne.
a = 330
b = 330

print("A") if a > b else print("a=b") \

if a == b else print("B")

a=b

2.4 Opérateurs logiques and et or

Il est possible de combiner plusieurs conditions à l’aide des opérateurs
logiques and et or.
Exemple 3 : Tester si deux conditions sont toutes les deux vraies

a = 200
b = 33
c = 500
if a > b and c > a:
print("Les deux conditions sont vraies")
Chapitre 4. Instructions de contrôle 75

Les deux conditions sont vraies

Exemple 4 : Tester si au moins une condition est vraie.

a = 200
b = 33
c = 500
if a > b or a > c:
print("Au moins une des deux conditions est vraie")

Au moins une des deux conditions est vraie

2.5 if imbriqué
Un if imbriqué est une instruction if contenue dans une autre instruction
if.
x = 15
if x > 10:
print("Supérieur à 10,")
if x > 20:
print("et aussi supérieur à 20.")
else:
print("mais non supérieur à 20.")

Supérieur à 10,
mais non supérieur à 20.

2.6 pass
Une instruction if est obligatoirement suivie par une ou plusieurs ins-
tructions à exécuter. Dans le cas où aucune instruction n’est à exécuter après
un if, pour éviter un message d’erreur on utilise l’instruction pass.
a = 33
b = 200
if b > a:
pass
76 Programmation Python

3 La boucle while
La boucle while permet d’exécuter un ensemble d’instructions tant qu’une
condition est vraie.
Exemple 5 : Imprimer i tant que i est inférieur à 6.

i = 1
while i < 6:
print(i)
i=i+1

1
2
3
4
5
Il faut donner une valeur initiale à la variable i avant la boucle while. Il
faut également incrémenter la variable i à la fin de la boucle while sinon la
boucle va s’exécuter indéfiniment.

3.1 L’instruction break

break permet de sortir immédiatement d’une boucle, indépendamment
de la condition de boucle.
Exemple 6 : Sortir de la boucle while si i=3

i = 1
while i < 6:
print(i)
if (i == 3):
break
i = i+1

1
2
3
Chapitre 4. Instructions de contrôle 77

3.2 L’instruction continue

Dans une boucle while, l’instruction continue permet d’ignorer les
instructions qui suivent et de continuer à la prochaine itération.
Exemple 7 : On ne souhaite pas afficher la valeur 3.
i = 0
while i < 6:
i =i+1
if i == 3:
continue
print(i)

1
2
4
5
6

Remarque : i a été initialisé à 0 et l’incrémentation i=i+1 est réalisée au

début de la boucle while. L’incrémentation i=i+1 peut s’écrire i+=1.

3.3 L’instruction else

L’instruction else permet d’exécuter un ensemble d’instructions une fois
que le test conditionnel de la boucle while n’est plus vérifié.
i = 1
while i < 6:
print(i)
i += 1
else:
print("i n’est plus inférieur à 6")

1
2
3
4
5
i n’est plus inférieur à 6
78 Programmation Python

4 La boucle for

4.1 for
Avec la boucle for, on peut exécuter un ensemble d’instructions pour
chaque élément d’une liste, un tuple, un ensemble ou tout autre objet itérable.
Exemple 8 : Afficher tous les éléments d’une liste.

noms = ["Mohamed", "Ali", "Fatima"]

for x in noms:
print(x)

Mohamed
Ali
Fatima

Exemple 9 : Accéder à tous les caractères d’une chaîne.

for x in "Alger":
print(x)

A
l
g
e
r

4.2 break
L’instruction break permet d’interrompre une boucle for.
noms = ["Mohamed", "Ali", "Fatima"]
for x in noms:
print(x)
if x == "Ali":
break

Mohamed
Ali
Chapitre 4. Instructions de contrôle 79

4.3 continue
L’instruction continue permet d’interrompre le processus à l’intérieur
d’une boucle for pour l’élément en cours et de passer aux éléments suivants.
noms = ["Mohamed", "Ali", "Fatima"]
for x in noms:
if x == "Ali":
continue
print(x)

Mohamed
Fatima

Remarque : Attention à l’indentation des instructions qui suivent continue.

Qu’obtient-on avec les lignes suivantes ?

noms = ["Mohamed", "Ali", "Fatima"]

for x in noms:
if x == "Ali":
continue
print(x)

4.4 range
Pour exécuter un ensemble d’instructions un certain nombre de fois, on
utilise la fonction range().
— range(n) renvoie une séquence de nombres entiers variant de 0 à n-1
inclus.
— range(n,m) donne la séquence de tous les nombres entiers compris
entre n et m-1 inclus.
— range(n,m,p) donne la séquence de tous les nombres entiers com-
pris entre n et m-1 avec un incrément égal à p.
80 Programmation Python

Exemple 10 :
for x in range(6):
print(x)

0
1
2
3
4
5

Exemple 11 :
for x in range(2,7,3):
print(x)

2
5

4.5 else dans une boucle for

L’instruction else dans une boucle for définit les instructions à exécuter
lorsque la boucle for est terminée.
for x in range(4):
print(x)
else:
print("C’est fini!")

0
1
2
3
C’est fini!

4.6 Boucles for imbriquées

Une boucle for est dite imbriquée si elle est contenue dans une autre
boucle for. La boucle intérieure est exécutée entièrement à chaque itération
de la boucle dans laquelle elle est contenue.
Chapitre 4. Instructions de contrôle 81

for x in range(1,4):
for y in range (5,7):
print(x, ’*’, y, ’=’, x*y)

1 * 5 = 5
1 * 6 = 6
2 * 5 = 10
2 * 6 = 12
3 * 5 = 15
3 * 6 = 18

4.7 Application aux listes

Les boucles for sont particulièrement utiles pour la manipulation de listes.
Quelques exemples sont présentés ci-dessous.

Compréhensions de listes

Une compréhension est un moyen compact de créer une structure de don-

nées Python à partir d’itérateurs. Avec les compréhensions, on peut combiner
des boucles et des tests conditionnels avec une syntaxe plus compacte.
Une application classique est la construction de nouvelles listes où chaque
élément est le résultat d’une opération appliquée aux éléments d’une autre sé-
quence, ou de créer une sous-séquence des éléments satisfaisant une condition
spécifique.
Exemple 12 : Carrés d’une liste de nombres

vec = [-4, -2, 0, 2, 4]

L = [x**2 for x in vec]

Listes imbriquées

Les listes imbriquées sont des objets de type liste dans lesquels les élé-
ments peuvent être eux-mêmes des listes.
Exemple 13 : Créer un tableau contenant les instants et les abscisses d’un
mobile en chute libre.
82 Programmation Python

# Créer une liste des instants

t=[0.1*x for x in range(0,10)]
print(’t = ’,t,’\n’)

# Accélération de la pesanteur
g=9.81

# Calculer l’abscisse x
x=[0.5*g*z**2 for z in t ]
print(’x = ’,x,’\n’)

# Créer le tableau [t,x]

tableau=[t,x]
print(’tableau = ’,tableau,’\n’)

Exemple 14 : Extraire les colonnes d’une liste imbriquée

# Extraire la première colonne du tableau

temps=tableau[0][:]
print(’temps =’,temps,’\n’)

#Extraire la deuxième colonne du tableau

abscisse=tableau[1][:]
print(’abscisse =’,abscisse,’\n’)
Cependant, les données tabulaires avec des lignes et des colonnes ont gé-
néralement la convention que les données sous-jacentes sont sous forme de
listes imbriquées où le premier index compte les lignes et le deuxième index
compte les colonnes. Pour avoir un tableau sur ce format, il faut le construire
sous forme de listes de paires [t, x]. Le premier index passera ensuite sur
les lignes [t, x]. Voici comment nous pouvons construire la liste imbri-
quée :
#Tableau des couples (t,x)
#Methode 1 : Avec une boucle for
tableau = []
for T, X in zip(t,x):
tableau.append([T, X])
print(’tableau = ’,tableau,’\n’)
ou bien
Chapitre 4. Instructions de contrôle 83

#Tableau des couples (t,x)

#Methode 2 : Ecriture compacte
tableau=[]
tableau = [[T, X] for T, X in zip(t, x)]
print(’tableau = ’,tableau,’\n’)

Exemple 15 : Pour lire les colonnes d’une liste imbriquée

#Lire les colonnes d’une liste imbriquée

temps=[]
position=[]
for L in table :
temps.append(L[0])
position.append(L[1])
print(’temps = ’,temps,’\n’)
print(’position = ’,position,’\n’)
84 Programmation Python

Exercices

Exercice 1 :
Déterminer si les deux ensembles suivants ont des éléments communs. Si
la réponse est oui, afficher les éléments communs.
A= {10, 20, 30, 40, 50}
B= {60, 70, 80, 90, 10}
Exercice 2 :
Écrire un programme qui détermine si une chaîne contient ou non un ca-
ractère donné.
Exercice 3 :
Écrire un programme qui recopie une chaîne (dans une nouvelle variable),
en insérant des astérisques entre les caractères.
Exercice 4 :
Écrire un programme qui détermine si une chaîne de caractères donnée est
un palindrome (c’est-à-dire une chaîne qui peut se lire indifféremment dans
les deux sens).
Exercice 5 :
A partir des deux listes suivantes, créer une nouvelle liste de même taille,
dont les éléments sont le résultat de la concaténation des chaînes se trouvant
aux mêmes indices.
list1 = ["M", "no", "e", "A"]
list2 = ["on", "m", "st", "li"]
Résultat attendu : [’Mon’, ’nom’, ’est’, ’Ali’]
Exercice 6 :
Concaténer les deux listes suivantes
list1 = ["Bonjour ", "Salut "]
list2 = ["Mon ami", "Ali"]
de manière à obtenir la liste :
[’Bonjour Mon ami’, ’Bonjour Ali’, ’Salut Mon ami’, ’Salut Ali’]
Chapitre 4. Instructions de contrôle 85

Exercice 7 :
Soient les listes suivantes :
t1 = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
t2 = [’janvier’,’février’,. . .,’décembre’].
Écrire un programme qui crée une nouvelle liste t3 qui devra contenir tous
les éléments des deux listes en les alternant, de telle manière que chaque nom
de mois soit suivi du nombre de jours correspondant.
Exercice 8 :
Écrire un programme qui affiche tous les éléments d’une liste.
Exercice 9 :
Écrire un programme qui, à partir d’une liste de nombres, génère deux
listes : une liste qui contient seulement les nombres pairs, et l’autre seulement
les nombres impairs.
Exercice 10 :
Écrire un programme qui, à partir d’une liste de noms,
— affiche chacun de ces noms avec le nombre de caractères correspondant.
— crée une liste des noms comportant moins de n caractères,
— crée une autre liste des noms comportant n caractères ou davantage.

Exercice 11 :
On dispose d’une liste de nombres entiers quelconques, certains d’entre
eux étant présents en plusieurs exemplaires. Écrire un programme qui recopie
cette liste dans une autre liste triée et sans doublons.
Exercice 12 :
Écrire un programme qui recherche le mot le plus long dans une phrase
donnée.
Exercice 13 :
Écrire un programme pour convertir en degrés Celsius une température
exprimée en degrés Fahrenheit, ou l’inverse.
86 Programmation Python

Exercice 14 :
Écrire un programme qui calcule les intérêts accumulés chaque année pen-
dant un certain nombre d’années, par capitalisation d’une somme placée en
banque à un taux fixe exprimé en pourcent.
Exercice 15 :
Ecrire un programme qui calcule la suite des n=20 premiers nombres de
Finobacci.
Exercice 16 :
Utiliser l’instruction while pour calculer et afficher les carrés et les cubes
des 12 premiers nombres entiers.
Exercice 17 :
Utiliser l’instruction for pour calculer et afficher les carrés et les cubes
des 12 premiers nombres entiers.
Exercice 18 :
Ecrire un programme pour calculer et afficher les 20 premiers termes de la
table de multiplication par 7.
Exercice 19 :
Écrire un programme qui affiche une table de conversion de sommes d’ar-
gent exprimées en euros, en dollars canadiens. La progression des sommes de
la table sera « géométrique » de raison 2. On donne 1e= 1.65$ CAN
Exercice 20 :
Écrire un programme pour afficher une suite de 12 nombres dont chaque
terme est le triple du terme qui le précède.
Exercice 21 :
Écrire un programme qui affiche les 20 premiers termes de la table de mul-
tiplication par 7, en signalant au passage (à l’aide d’une astérisque) ceux qui
sont des multiples de 3.
Exercice 22 :
Écrire un programme qui calcule les 50 premiers termes de la table de
multiplication par 13, mais n’affiche que ceux qui sont des multiples de 7.
Chapitre 4. Instructions de contrôle 87

Corrigé des exercices

Corrigé exercice 1 :

A= {10, 20, 30, 40, 50}

B= {60, 70, 80, 90, 10}
if A.isdisjoint(B) :
print("Ensembles disjoints")
else :
print("A & B =",A.intersection(B))

Corrigé exercice 2 :

chaine = input(’Entrez la chaine : ’)

caractere = input (’Caractère à rechercher : ’)
if chaine.count(caractere)==0:
print(f’{chaine} ne contient pas {caractere}’)
else :
print(f’{chaine} contient {caractere}’)

Corrigé exercice 3 :

nom = input(’Entrer une chaine : ’)

toto = ’’
for t in range(0,len(nom)):
toto=toto+nom[t]+’*’
toto=toto.rstrip(’*’)
print(toto)

Corrigé exercice 4 :

chaine_in = input(’Entrer une chaine : ’)

chaine_out = chaine_in[::-1]
if chaine_in==chaine_out :
print(chaine_in,’ est un palindrome’)
else :
print(chaine_in," n’est pas un palindrome")
88 Programmation Python

Corrigé exercice 5 :

list1 = ["M", "no", "e", "A"]

list2 = ["on", "m", "st", "li"]
list3 = []

# Méthode 1
for i in range(0,len(list1)):
list3.append(list1[i]+list2[i])
print(list3)

# Méthode 2
list3 =[i+j for i,j in zip(list1, list2)]
print(list3)

Corrigé exercice 6 :

list1 = ["Bonjour ", "Salut "]

list2 = ["Mon ami", "Ali"]

# Méthode 1
list3=[]
for i in list1 :
for j in list2 :
list3.append(i+j)
print(list3)

# Méthode 2
list3 = [i+j for i in list1 for j in list2]
print(list3)

Corrigé exercice 7 :

t1 = [31,28,31,30,31,30,31,31,30,31,30,31]
t2 = [’Janvier’,’Février’,’Mars’,’Avril’,’Mai’,\
’Juin’,’Juillet’,’Aout’,’Septembre’,’Octobre’, \
’Novembre’,’Décembre’]
t3 = []
Chapitre 4. Instructions de contrôle 89

for mois in range(0,len(t1)) :

t3.extend([t2[mois],t1[mois]])
print(t3)

Corrigé exercice 8 :

liste_mois = [’Janvier’,’Février’,’Mars’,’Avril’,’Mai’,\
’Juin’,’Juillet’,’Aout’,’Septembre’,’Octobre’,\
’Novembre’,’Décembre’]

for mois in liste_mois :

print(mois,end=’ ’)

Corrigé exercice 9 :

nombres = [32, 5, 12, 8, 3, 75, 2, 15]

pairs = [x for x in nombres if x%2==0]
impairs = [x for x in nombres if x%2!=0]

print(’nombres = ’,nombres)
print(’pairs = ’,pairs)
print(’impairs = ’, impairs)

Corrigé exercice 10 :

n = 5
noms = [’Ali’,’Mohamed’,’Omar’,’Fatima’,’Sarah’]
nomsmoinsde_n = [x for x in noms if len(x)<n]
nomsplusde_n = [x for x in noms if len(x)>=n]

for x in noms :
print(x, ’:’,len(x))

print(f’Moins de {n} lettres : {nomsmoinsde_n}’)

print(f’{n} ou plus lettres : {nomsplusde_n}’)
90 Programmation Python

Corrigé exercice 11 :

import random
n1 = 5
n2 = 2*n1
liste1 = []
for i in range(0,n1):
n = random.randint(1,n2)
m = random.randint(1,n2)
liste1.extend([n,m])
print(’liste initale : ’,liste1)

liste2=[]
for x in liste1 :
if x not in liste2 :
liste2.append(x)
liste2.sort()
print(’liste finale : ’,liste2)

Corrigé exercice 12 :

phrase = input(’Entrer votre phrase :’)

mots = phrase.split()
print(’Mots : ’, mots)

longueur=[]
for x in mots:
print(x, ’:’, len(x))
longueur.append(len(x))

indice = longueur.index(max(longueur))
print(’Le mot le plus long est :’, mots[indice])

Corrigé exercice 13 :
Formule de conversion : TF = TC × 1.8 + 32
print(’Conversion C -> F : taper 1’)
print(’Conversion F -> C : taper 2’)
choix = input(’Conversion C-> F ou F-> C ?’)
Chapitre 4. Instructions de contrôle 91

if choix == ’1’ :
TC=float(input(’Température en C = ’))
TF=TC*1.8+32
sortie=’Température en F = {:.2f} F’
print(sortie.format(TF))

elif choix== ’2’ :

TF=float(input(’Température en F = ’))
TC=(TF-32)/1.8
print(f’Température en C = {TC:.2f} C’)

else :
print(’Erreur : Taper 1 ou 2’)

Corrigé exercice 14 :

somme = float(input(’Somme = ’))

taux = float(input(’Taux en pourcent = ’))
duree = int(input("Durée en nombres d’années = "))
taux = taux/100
sommef = somme
for i in range(0,duree):
sommef = sommef*(1+taux)
interet = sommef-somme
print(f’Interet sur {duree} ans = {interet:.2f}’)

Corrigé exercice 15 :

n = 20
a,b,c = 1,1,1
print(46*’*’)
print(f’* Suite des {n} premiers nombres\
de Finobacci *’)
print(46*’*’)

while c<=20 :
print(b,end=’ ’)
a, b= b, a+b
c+=1
92 Programmation Python

Corrigé exercice 16 :
n = 0
nmax = 12
while n<nmax:
n=n+1
print(’n=’,n,’ n^2=’,n**2,’ n^3=’,n**3)

Corrigé exercice 17 :
xmax = 12
for x in range(1,xmax+1):
print(’x=’,x,’ x^2=’,x**2,’ x^3=’,x**3)

Corrigé exercice 18 :
x = 0
n = 20
m = 7
while x<n:
x+=1
y=m*x
print(f’{m}*{x}={y}’)

Corrigé exercice 19 :
x = 1
xmax = 100
while x<=xmax:
print(f’{x} euros \t= {1.65*x:.2f} $ CAN’)
x = x*2

Corrigé exercice 20 :
x = 1
y = 1
xmax=12
while x<=xmax:
print(y,end=’ ’)
z = y
y = 3*z
x = x+1
Chapitre 4. Instructions de contrôle 93

Corrigé exercice 21 :

n = 20
m = 7
r = 3
for i in range(0,n+1):
x = m*i
if x%r==0 :
print(x,’*’,end=’ ’)
else :
print(x,end=’ ’)

Corrigé exercice 22 :

n = 50
m = 13
r = 7
for i in range(0,n):
x = m*i
if x%r==0 :
print(x,end=’ ’)
Chapitre 5

Fonctions

Dans ce chapitre :
— Syntaxe
— Fonctions à un ou plusieurs paramètres
— Mot-clé pass
— Variable locale - variable globale
— Docstrings
— Arguments par étiquette
— Fonctions lambda, map et filter

Travaux Dirigés:
Exercices corrigés

95
96 Programmation Python

En Python , une fonction est un bloc de code défini avec un nom. Nous
utilisons des fonctions chaque fois que nous devons effectuer la même tâche
plusieurs fois sans avoir à réécrire le même code. Une fois définie, cette fonc-
tion peut être appelée chaque fois que cela est nécessaire. L’utilisation des
fonctions améliore l’efficacité et réduit les erreurs. Une fois qu’une fonction
est créée, nous pouvons l’appeler de n’importe où et n’importe quand. Un autre
avantage est la possibilité de réutiliser une fonction plusieurs fois .

1 Fonctionnement
Grâce à la modularité introduite par la notion de fonction, le code peut
être mieux organisé. Une fonction accepte des paramètres en entrée, les traite
et, à la fin, renvoie des valeurs en sortie. Le diagramme suivant illustre ce
fonctionnement :

def mafonction :
corps de la fonction
......
(1) Appel de la fonction
......
(2) Retour de la fonction
mafonction()
......
......

Python prend en charge deux types de fonctions :

— Fonctions intégrées : les fonctions fournies avec Python sont appe-
lées fonctions intégrées ou fonctions prédéfinies, comme par exemple :
range(), id(), type(), input(), eval(), etc...
— Fonctions définies par l’utilisateur : ce sont les fonctions qui sont créées
explicitement par le programmeur ou l’utilisateur.

2 Fonctions intégrées
Le langage Python possède un certain nombre de fonctions intégrées
(built-in). C’est à dire qu’elles sont toujours disponibles, sans avoir besoin
Chapitre 5. Fonctions 97

de les importer à partir d’un module externe. Dans les chapitres précédents,
nous avons utilisé de nombreuses fois ces fonctions.
Le tableau ci-dessous décrit les fonctions intégrées les plus courantes.

Fonction Description
[] Crée une nouvelle liste
{} Crée un nouveau dictionnaire
() Crée un nouveau tuple (liste non modifiable)
abs() Retourne la valeur absolue
all() Retourne 1 (True) si tous les éléments sont vrais
any() Retourne 1 (True) si au moins 1 élément est vrai
ascii() Retourne une chaîne imprimable de l’objet
bin() Convertit un nombre entier en binaire
bool() Retourne une valeur booléenne de l’objet
chr() Retourne la chaîne associée au code de l’argument
complex() Retourne un nombre complexe
dict() Crée un nouveau dictionnaire
dir() Retourne une liste des attributs de l’objet
eval() Évalue une expression ou des données
f-string Formate une représentation d’éléments en chaîne de caractères
filter() Filtre les éléments d’une collection suite à un test
float() Crée un nouveau nombre réel
format() Formate une représentation d’éléments en chaîne de caractères
globals() Retourne les variables globales actuelles
help() Appelle le système d’aide intégré
input() Pour saisir une chaîne de caractères
int() Crée un nouveau nombre entier
len() Retourne la longueur de l’objet
list() Crée une nouvelle liste
locals() Retourne les variables locales actuelles
map() Applique la fonction à chaque élément
max() Retourne l’objet ayant la valeur la plus élevée
min() Retourne l’objet ayant la valeur la plus basse
oct() Convertit un entier en octet
open() Ouvre un canal pour un fichier
ord() Renvoie le code unicode du caractère
98 Programmation Python

Fonction Description
pow() Retourne un nombre x élevé à une puissance y
print() Imprime sur le périphérique par défaut (écran en général)
range() Génère une suite de nombres
round() Retourne une valeur arrondie
set() Retourne un nouvel objet ensemble
sorted() Retourne une liste ordonnée
str() Crée une nouvelle chaîne de caractères
sum() Calcule la somme des éléments
tuple() Crée un nouveau tuple
type() Retourne le type de l’objet
zip() Fait une liste de tuples en fusionnant plusieurs collections

Exemple 1 :

In[3] : x = 1
In[4] : eval(’x+1’)
Out[4] : 2

Exemple 2 :
La fonction Python range() génère une séquence immuable de nombres
à partir de l’entier de début donné jusqu’à l’entier d’arrêt.
for i in range(1,10):
print(i,end=’ ’)

1 2 3 4 5 6 7 8 9

3 Fonctions définies par l’utilisateur

Pour créer une fonction en Python , on utilise les étapes suivantes :
— Définir la fonction à l’aide du mot-clé def,
— Spécifier les paramètres de la fonction,
— Terminer l’en-tête de la fonction par les deux points (caractère :),
Chapitre 5. Fonctions 99

— Définir le corps de la fonction avec un bloc de code décrivant l’action à

effectuer. En Python , le corps de la fonction est défini par l’indentation
(retrait de ligne vers la droite). Si cette indentation est omise, on obtient
un message d’erreur.
Dans l’exemple ci-dessous
def nom_fonction (parametre1, parametre2):
# Corps de la fonction
# Ecrire les actions
.
.
.
# Valeur renvoyée
return valeur

— nom_fonction : est le nom de la fonction. On peut donner n’importe quel

nom à la fonction tant que l’on respecte les règles de nommage imposées
par Python . Il faut aussi éviter un nom déjà utilisé pour une fonction
intégrée.
— parametre1, parametre2 : sont les paramètres transmis à la fonction. On
peut passer n’importe quel nombre de paramètres.
— corps de la fonction : c’est le bloc de code qui effectue une tâche. Ce
bloc de code n’est rien d’autre que l’action que l’on veut accomplir.
— valeur : est la valeur renvoyée à la sortie de la fonction.

Remarque : La définition d’une fonction doit précéder son utilisation.

3.1 Paramètres d’une fonction

Exemple 3 : Création d’une fonction simple, sans paramètres, qui imprime un

message de bienvenue.
— Définition de la fonction
def message():
print("Bienvenue à Python")
100 Programmation Python

— Appel de la fonction par son nom

message()

— Résultat
Bienvenue à Python

Exemple 4 : Création d’une fonction avec deux paramètres nom et age.

— Définition de la fonction
def vos_infos(nom, age):
print("Bonjour ",nom,". Bienvenue!")
print("Vous avez ",age," ans.")

— Appel de la fonction
vos_infos(’Ali’,5)

— On obtient le résultat suivant :

Bonjour Ali. Bienvenue!
Vous avez 5 ans.

Une fois que la fonction est définie, pour l’appeler on utilise son nom. On
peut également appeler cette fonction à partir d’une autre fonction ou d’un
autre programme en l’important. Pour appeler une fonction, on utilise le nom
de la fonction suivi de parenthèses, et si la fonction accepte des paramètres,
on passe les valeurs des paramètres entre les parenthèses. Les valeurs des pa-
ramètres que l’on passe à la fonction sont appelés les arguments.

3.2 Valeur de retour d’une fonction

En Python, pour renvoyer la valeur de la fonction, on utilise l’instruction
return.
def fonction():
instruction-1
instruction-2
...
return expression
Chapitre 5. Fonctions 101

Quelques précisions concernant de l’instruction return :

— L’instruction return termine l’exécution de la fonction.
— return doit être à l’intérieur du bloc fonctionnel.
— Elle n’est pas obligatoire.
— Si une instruction return est utilisée sans aucune expression, la valeur
None est renvoyée.
Exemple 5 : Calcul de la somme de 2 nombres
— Définition de la fonction :
def calculateur(a, b):
add = a + b
# renvoi de la somme
return add

— Appel de la fonction :
# On définit les paramètres
n1=5
n2=6
#Appel de la fonction
somme=calculateur(n1,n2)
print(n1,’+’,n2,’=’,somme)

— On obtient le résulat :
5+6=11

Exemple 6 : Ecrire une fonction pour vérifier si un nombre est pair ou impair.
— Définition de la fonction :
def pair_impair(n):
# on vérife si n est pair ou impair
if n % 2 == 0:
reponse=’nombre pair’
else:
reponse=’nombre impair’
return(reponse)
102 Programmation Python

— Appel de la fonction :
# Définition du nombre
n=118
# Appel de la fonction par son nom
print(n,’est un ’,pair_impair(n))

— On obtient le résultat :
118 est un nombre pair

Exemple 7 : Renvoi de plusieurs valeurs

On peut également renvoyer plusieurs valeurs à partir d’une fonction. Pour
cela on utilise l’instruction return en séparant chaque expression par une
virgule. L’exemple suivant montre une fonction qui renvoie quatre valeurs.
— Définition de la fonction
def arithmetique(num1, num2):
add = num1 + num2
soust = num1 - num2
multip = num1 * num2
div = num1 / num2
# return four values
return add, soust, multip, div

— Appel de la fonction
a, b, c, d = arithmetique(10, 2)
print("Addition: ", a)
print("Soustraction: ", b)
print("Multiplication: ", c)
print("Division: ", d)

— On obtient le résultat :
Addition: 12
Soustraction: 8
Multiplication: 20
Division: 5.0
Chapitre 5. Fonctions 103

Remarque : De manière plus précise, dans ce cas de figure, la fonction re-

tourne un tuple contenant les différents résultats. On assigne ensuite aux va-
riables a, b, c et d, les valeurs du tuple retourné par la fonction.

Exemple 8 : Itérer une fonction sur une liste d’arguments

— Appel de la fonction pair_impair()

nombres=[2,5,8]
#On utilise la compréhension de liste
[pair_impair(x) for x in nombres]

— Résultat
[’nombre pair’, ’nombre impair’, ’nombre pair’]

Exemple 9 : Fonction dont le paramètre est une liste.

— Définition de la fonction
def est_pair(list1):
pairs = []
for n in list1:
if n % 2 == 0:
pairs.append(n)
return pairs

— Appel de la fonction :
pairs = est_pair([2, 3, 42, 51, 62, 70, 5])
print("Nombres pairs:", pairs)

— On obtient le résultat :
Nombres pairs: [2, 42, 62, 70]

3.3 Le mot-clé pass

Il y a parfois des situations où on doit définir un bloc syntaxiquement vide.
Ce bloc peut être défini à l’aide du mot-clé pass. En Python , pass est le
104 Programmation Python

mot-clé qui ne fait rien. Cela peut s’avérer utile lorsque l’on veut structurer le
code en différentes fonctions avant de les implémenter.
Exemple 10 : Définition d’une fonction addition sans implémentation

— Définition de la fonction
def addition(num1, num2):
pass

— Appel de la fonction :
addition(10, 2)

— Aucune instruction n’est exécutée.

4 Docstrings
En Python la chaîne de documentation, également appelée docstring, est
un texte descriptif (comme un commentaire) écrit par le programmeur pour
faire savoir aux autres ce que fait le bloc de code.
Le docstring est écrit dans le code source et il doit être utilisé immédiate-
ment après la définition du module, de la classe, de la fonction ou de la mé-
thode. Il est déclaré en utilisant des guillemets simples triples (’’’) ou des
guillemets doubles triples (""").
On accède au docstring en utilisant l’attribut doc (__doc__). Ceci est va-
lable pour les fonctions définies par l’utilisateur et pour n’importe quel objet
comme les liste, tuple, dict, etc.
Exemple 11 : Docstring sur une seule ligne

— Définition de la fonction
def factorielle(x):
"""Calcul de x!"""
pass

— Accès à la docstring
print(factorielle.__doc__)
Chapitre 5. Fonctions 105

— Résultat
Calcul de x!

Lorsque vous utilisez la fonction help pour obtenir les informations de

n’importe quelle fonction, elle renvoie la docstring.
— Fonction help
# Passer le nom de la fonction à help()
print(help(factorielle))

— Résultat
Help on function factorielle in module __main__:

factorielle(x)
Calcul de x!

Exemple 12 : Docstring multi-ligne

— Définition de la fonction
def une_fonction(parametre1):
"""Description de la fonction

Arguments:
parametre1(int):Description de parametre1

Return:
valeur entière
"""
pass

— Affichage docstring
print(une_fonction.__doc__)
106 Programmation Python

— Résultat
Description de la fonction

Arguments:
parametre1(int):Description de parametre1

Production:
valeur entière

5 Arguments d’une fonction en Python

Un paramètre est la variable répertoriée entre parenthèses dans la définition
de la fonction tandis qu’un argument est la valeur qui est envoyée à la fonction
lorsqu’elle est appelée. En Python , quatre types d’arguments sont autorisés.
— Arguments de position
— Arguments de mots clés
— Arguments par défaut
— Arguments de longueur variable

5.1 Arguments de position

Les arguments positionnels sont des arguments passés à la fonction dans
le bon ordre de position. Autrement dit, le 1er argument de position doit être
le 1er lorsque la fonction est appelée. Le 2ème argument de position doit être
2ème lorsque la fonction est appelée, etc... L’exemple suivant illustre cela pour
une meilleure compréhension.
Exemple 13 :

— Définition de la fonction
def soustraction(a, b):
print(a - b)

— Appel de la fonction
soustraction(50, 10)
Chapitre 5. Fonctions 107

— On obtient le résultat
40

Si on change l’ordre des arguments

soustraction(10, 50)
on obtient un résultat différent
-40
Si on essaye de passer plus de paramètres
soustraction(105, 561, 4)
on obtient un message d’erreur :
TypeError: soustraction() takes 2 positional arguments
but 3 were given
Si on utilise des arguments positionnels, le nombre et la position des ar-
guments doivent être mis en correspondance. Si nous modifions l’ordre, le
résultat peut changer. De plus, si nous modifions le nombre d’arguments, nous
obtenons une erreur.

5.2 Arguments avec étiquettes

Contrairement à de nombreux langages, Python permet de passer les ar-
guments dans un ordre différent de celui défini par la fonction. Pour cela une
étiquette est utilisée pour spécifier pour quel paramètre la valeur en argument
doit utilisée.
Exemple 14 :

— Définition de la fonction
def message(nom, prenom):
print("Bonjour", nom, prenom)

— Appel de la fonction sans argument étiquette

message("Benmohamed","Ali")

— Résultat
Bonjour Benmohamed Ali
108 Programmation Python

— Appel de la fonction avec arguments étiquettes

message(nom="Benmohamed", prenom="Ali")

— Résultat
Bonjour Benmohamed Ali

— Autre appel de la fonction avec arguments étiquettes

message(prenom="Ali", nom="Benmohamed")

— Résultat
Bonjour Benmohamed Ali

Remarque : Dans les arguments étiquette, l’ordre des arguments n’a pas
d’importance, mais le nombre d’arguments doit correspondre. Sinon on ob-
tient un message d’erreur erreur.
Pour utiliser simultanément des arguments étiquettes et des arguments de
position, tous les arguments de position doivent être placés avant les arguments
étiquettes.
Exemple 15 :
Utilisation correcte
message("Benmohamed", prenom="Ali")
Utilisation incorrecte
message(Nom="Benmohamed", "Ali")

File "<ipython-input-26-5d1a43519d2a>", line 1

message(nom=’Benmohamed’,’Ali’)
^
SyntaxError: positional argument follows keyword argument

5.3 Arguments par défaut

Lors de la définition d’une fonction, il est possible de spécifier une valeur
par défaut à donner aux paramètres. Si nous ne passons aucun argument à la
fonction, alors l’argument par défaut sera utilisé. On parle alors d’arguments
Chapitre 5. Fonctions 109

par défaut. Nous pouvons affecter des valeurs par défaut à l’aide de l’opérateur
d’affectation = dans la définition de la fonction.
Exemple 16 :

# Fonction avec argument par défaut

def message(nom="Omar"):
print("Bonjour", nom)

# Appel avec argument

message("Ali")

# Appel sans argument

message()

Bonjour Ali
Bonjour Omar
Dans l’exemple ci-dessus, nous avons passé nom="Ali" à la fonction. C’est
cette valeur qui sera utilisée dans le corps de la fonction. Si nous ne passons
aucun argument, c’est la valeur par défaut nom="Omar" qui sera utilisée dans
le corps de la fonction.

5.4 Arguments de longueur variable

Il possible de définir une fonction Python dont le nombre d’arguments
peut varier. Ces types d’arguments sont appelés arguments de longueur va-
riable. Un argument de longueur variable est déclaré avec le symbole * (asté-
risque).
def fun(*var):
instructions
On peut passer n’importe quel nombre d’arguments à ce type de fonction
à l’intérieur de laquelle toutes ces valeurs seront représentées sous la forme
d’un tuple.
Exemple 17 :

def addition(*nombres):
total = 0
for no in nombres:
110 Programmation Python

total = total + no
print("Somme :", total)

# 0 arguments
addition()

# 5 arguments
addition(10, 5, 2, 5, 4)

# 3 arguments
addition(78, 7, 2.5)

Somme : 0
Somme : 26
Somme : 87.5
Il est aussi possible d’utiliser des arguments étiquettes (mots-clés) dont le
nombre varie en ajoutant deux astérisques (**) avant le nom du paramètre dans
la définition de la fonction. De cette façon, la fonction recevra un dictionnaire
d’arguments et pourra accéder aux éléments en conséquence.
Exemple 18 : Si le nombre d’arguments mot-clé est inconnu, ajoutez un double
** avant le nom du paramètre :
def mafonction(**enfant):
print("Son nom est : " + enfant["nom"])

mafonction(prenom = "Ali", nom = "Benmohamed")

Son nom est : Benmohamed

Remarque : On passe les paramètres depuis ou vers des conteneurs. L’opéra-

teur * convertit des arguments non nommés en tuple. L’opérateur ** convertit
des arguments nommés en dictionnaire.

6 Fonction récursive
Une fonction récursive est une fonction qui s’appelle elle-même plusieurs
fois de suite. Par exemple, en mathématiques le calcul de la factorielle d’un
Chapitre 5. Fonctions 111

nombre n, qui se note n!, est une opération récursive. Nous pouvons dans ce
cas créer une fonction récursive qui calcule la factorielle d’un nombre.
Exemple 19 :

— Définition de la fonction
def factorielle(n):
if n == 0:
return 1
else:
return n * factorielle(n - 1)

— Appel de la fonction pour calculer 5!

n=5
print(f’{n}! = {factorielle(n)}’)

— Résultat
5! = 120

Parmi les avantages d’une implémentation récursive on peut citer :

— L’amélioration de la lisibilité du code qui est plus court.
— La simplification de problèmes complexes s’ils sont de nature récursive
(tel que le calcul de la factorielle).
On peut néanmoins mentionner quelques inconvénients :
— La fonction récursive prend plus de mémoire et de temps pour l’exécu-
tion.
— Le ’débogage’ n’est pas aisé pour une fonction récursive.

7 Portée et durée de vie des variables

La portée d’une variable définit la zone dans laquelle cette variable est ac-
cessible et utilisable. Lorsque nous définissons une fonction avec des variables,
la portée de ces variables est limitée à cette fonction. On parle de portée locale :
ces variables ne sont pas visibles de l’extérieur de la fonction.
112 Programmation Python

Une variable globale est une variable qui se déclare en dehors de la fonc-
tion. La portée d’une variable globale est large. Elle est accessible dans toutes
les fonctions d’un même module.

Remarque : On appelle “module” tout fichier constitué de code Python im-

porté dans un autre fichier ou script.

Exemple 20 : Si on essaie d’accéder à la variable locale de l’extérieur de la

fonction, on obtient un message d’erreur.
def fonction1():
vlocale = 888
print("La valeur est :", vlocale)
def fonction2():
print("La valeur est :", vlocale)
fonction1()
fonction2()

La valeur est : 888

-----------------------------------
NameError Traceback (most recent call last)
<ipython-input-3-c5492a349d9c> in <module>
8
9 fonction1()
---> 10 fonction2()
<ipython-input-3-c5492a349d9c> in fonction2()
5
6 def fonction2():
----> 7 print("La valeur est :", vlocale)
8
9 fonction1()
NameError: name ’vlocale’ is not defined

Exemple 21 : Variable globale

vglobale = 999

def fonction1():
print("Valeur dans fonction1 :", vglobale)
Chapitre 5. Fonctions 113

def fonction2():
print("Valeur dans fonction2 :", vglobale)

fonction1()
fonction2()

Valeur dans fonction1 : 999

Valeur dans fonction2 : 999
Une variable globale est une variable qui se déclare en dehors de la fonction
et elle est accessible dans toutes les fonctions d’un même module.
Exemple 22 : Variable globale et variable locale

def portee_test():
vlocale = ’Python’
print(vlocale)

vglobale = ’DataScience’
print(’Impression dans la fonction’)
portee_test()
print(’Impression hors de la fonction’)
print(vglobale)
print(vlocale) #Message d’erreur!

Impression dans la fonction

Python
Impression hors de la fonction
DataScience
---------------------------------------------
NameError Traceback (most recent call last)
<ipython-input-2-01e2dd73cfba> in <module>
---> 21 print(vlocale)
NameError: name ’vlocale’ is not defined
Dans l’exemple ci-dessus, nous imprimons les valeurs des variables locales et
globales de l’extérieur de la fonction. La variable globale est accessible avec
son nom vglobale.
Mais lorsque nous essayons d’accéder à la variable locale avec son nom
vlocale, nous obtenons un message d’erreur, car la variable locale n’est pas
accessible de l’extérieur de la fonction.
114 Programmation Python

7.1 Mot-clé global

En Python , global est le mot-clé utilisé pour :
— rendre globale une variable définie localement dans une fonction.
— accéder à la variable globale à l’intérieur d’une fonction.
Examinons ce qui se passe lorsque nous n’utilisons pas de mot clé global
pour accéder à la variable globale dans la fonction.
# Variable globale
vglobale = 5

def fonction1():
print("Valeur dans fonction1 :", vglobale)

def fonction2():
vglobale = 555
print("Valeur dans fonction2 :", vglobale)

def fonction3():
print("Valeur dans fonction3 :", vglobale)

fonction1()
fonction2()
fonction3()

Valeur dans fonction1 : 5

Valeur dans fonction2 : 555
Valeur dans fonction3 : 5
Comme on peut le voir, fonction2 () a traité vglobale comme une nouvelle va-
riable (variable locale). Le mot-clé global permet de résoudre ce problème.
Nous pouvons redéfinir fonction2()
def fonction2():
global vglobale
vglobale = 555
print("Valeur dans fonction2 :", vglobale)

Valeur dans fonction1 : 5

Valeur dans fonction2 : 555
Valeur dans fonction3 : 555
Chapitre 5. Fonctions 115

7.2 Mot clé nonlocal

En Python , nonlocal est le mot-clé utilisé pour déclarer une variable
qui agit comme une variable globale pour une fonction imbriquée (c’est-à-dire
une fonction dans une autre fonction).
def fexterne():
x = 777
print("La valeur initiale de x:", x)

def finterne():
#locale -> globale
nonlocal x
x = 700
print("x dans finterne :", x)

finterne()
print("x dans fexterne :", x)

fexterne()

La valeur initiale de x: 777

Valeur de x dans la fonction interne : 700
Valeur de x dans la fonction externe : 700

8 Fonction Python Anonyme / Lambda

En Python , le mot-clé lambda est utilisé pour déclarer une fonction
anonyme, donc sans nom. Les fonctions lambda se comportent de la même
manière que les fonctions régulières.
Une fonction anonyme est déclarée à l’aide du mot clé lambda, suivant
la syntaxe :
nom_de_fonction = lambda arguments_liste : expression

Exemple 23 : Fonction pour calculer 2x + 1

— Définition de la fonction lambda

f = lambda x:2*x+1
116 Programmation Python

— Fonction régulière équivalente

def f(x) :
return 2*x+1

— Appel de la fonction dans les deux cas

x=3
print(f(3))

— Résultat
7

L’utilisation de la fonction anonyme se justifie pour une utilisation locale

qui ne nécessite pas d’écrire une fonction qui serait disponible au niveau du
module par exemple. Lorsque nous définissons une fonction à l’aide du mot-clé
lambda, le code est très concis, ce qui permet plus de lisibilité dans certains
contextes. Une fonction lambda peut avoir n’importe quel nombre d’argu-
ments mais une seule expression peut être évaluée.
Exemple 24 : Fonction lambda à 2 paramètres

— Définition de la fonction
addition=lambda x,y:x+y

— Appel de la fonction
a=1
b=2
reponse=addition(a,b)
print(’Somme : ’,reponse)

— Résultat
Somme : 3

Dans la fonction lambda, il n’est pas nécessaire d’écrire explicitement

l’instruction de retour, return, car la fonction lambda renvoie en interne
la valeur de l’expression. Les fonctions Lambda sont plus utiles lorsqu’on est
amené à utiliser des fonctions qui prennent une autre fonction comme argu-
ment telles que les fonctions intégrées map, filter, etc.
Chapitre 5. Fonctions 117

9 Fonction map()
En Python , la fonction map() est utilisée pour appliquer certaines fonc-
tionnalités à chaque élément présent dans la séquence donnée et générer une
nouvelle série avec une modification requise.
Syntaxe de la fonction map() :
map(function,sequence)

— function : argument de fonction à appliquer sur chaque élément de la

séquence
— sequence : L’argument de séquence peut être une liste, un tuple, une
chaîne, ...

Exemple 25 : Élever au cube tous les éléments d’une liste.

list1 = [2, 3, 4, 8, 9]
list2 = list(map(lambda x: x*x*x, list1))
print("Valeurs des cubes:", list2)

valeurs des cubes: [8, 27, 64, 512, 729]

10 Fonction filter()
En Python , la fonction filter() est utilisée pour renvoyer la valeur
filtrée. Nous utilisons cette fonction pour filtrer les valeurs en fonction de cer-
taines conditions.
Syntaxe de la fonction filter() :
filter(fonction, sequence)

— fonction : L’argument de fonction chargée de la vérification des condi-

tions.
— sequence : L’argument de séquence peut être une liste, un tuple, une
chaîne, ...
118 Programmation Python

Exemple 26 : Filtrer les nombres positifs d’une liste

liste = [-10, 5, 12, -78, 6, -1, -7, 9]

positifs = list(filter(lambda x: x > 0, liste))
print("Nombres positifs: ", positifs)

Nombres positifs: [5, 12, 6, 9]

Chapitre 5. Fonctions 119

Exercices

Exercice 1 :
Définissez une fonction renvoie_ncar(n, ca) qui renvoie une chaîne
de n caractères ca.
Exercice 2 :
Écrire une fonction table de multiplication avec quatre paramètres : base,
debut, fin et inc. Cette fonction doit afficher la table de multiplication
par base, de debut à fin, de inc en inc. Tester la fonction par un appel
dans le programme principal.
Exercice 3 :
Définissez une fonction surfCercle(r). Cette fonction doit renvoyer
la surface (l’aire) d’un cercle dont on a fourni le rayon r en argument.
Exercice 4 :
Écrivez un programme qui prend un rayon de cercle r comme entrée de
l’utilisateur, puis calculez la circonférence C et la surface S du cercle. Implé-
menter les calculs de C et S comme deux fonctions distinctes qui prennent
chacune r comme paramètre d’entrée. Imprimez C et A sur l’écran avec un
texte approprié. Exécutez le programme avec r = 1 et confirmez que vous
obtenez la bonne réponse.
Exercice 5 :
Écrire une fonction cube qui retourne le cube de son argument. Écrire
une fonction volumeSphere qui calcule le volume d’une sphère de rayon r
fourni en argument et qui utilise la fonction cube. Le volume v d’une sphère
de rayon r est donné par : v = 43 πr3 .
Tester la fonction volumeSphere par un appel dans le programme prin-
cipal.
Exercice 6 :
Définissez une fonction volBoite(x1,x2,x3) qui renvoie le volume
d’une boîte parallélépipédique dont on fournit les trois dimensions x1, x2,
x3 en arguments.
120 Programmation Python

Exercice 7 :
Définissez une fonction maximum(n1,n2,n3) qui renvoie le plus grand
de 3 nombres n1, n2, n3 fournis en arguments. Par exemple, l’exécution
de l’instruction : print(maximum(2,5,4)) doit donner le résultat : 5.
Exercice 8 :
Ecrire une fonction pour résoudre une équation du premier degré : a*x+b=0
Exercice 9 :
Écrire un programme qui estime la valeur de la constante mathématique e
en utilisant la formule :
i=n
X 1
e'
i=0
i!
Pour cela, définissez la fonction factorielle et, dans votre programme prin-
cipal, saisissez l’ordre n et affichez l’approximation correspondante de e.
Exercice 10 :
— Écrire une fonction maFonction qui retourne f (x) = 2x3 + x − 5.
— Écrire une procédure tabuler avec quatre paramètres : fonction,
borneInf, borneSup et nbPas. Cette procédure affiche les va-
leurs de maFonction, de borneInf jusqu’à borneSup, tous les
nbPas. Elle doit respecter borneInf < borneSup.
— Tester cette procédure par un appel dans le programme principal après
avoir saisi les deux bornes et le nombre de pas.
Exercice 11 :
Définissez une fonction compteCar(ca,ch) qui renvoie le nombre de
fois que l’on rencontre le caractère ca dans la chaîne de caractères ch.
Exercice 12 :
Définissez une fonction indexMax(liste) qui renvoie l’index de l’élé-
ment ayant la valeur la plus élevée dans la liste transmise en argument.
Exercice 13 :
Définissez une fonction nomMois(n) qui renvoie le nom du énième mois
de l’année.
Chapitre 5. Fonctions 121

Exercice 14 :
Définissez une fonction inverse(ch) qui permette d’inverser l’ordre
des caractères d’une chaîne quelconque. La chaîne inversée sera renvoyée au
programme appelant.
Exercice 15 :
Définissez une fonction compteMots(ph) qui renvoie le nombre de
mots contenus dans la phrase ph. On considère comme mots les ensembles
de caractères inclus entre des espaces.
Exercice 16 :
Écrire une fonction pythagorus1 pour calculer l’hypoténuse d’un tri-
angle rectangle dont les cotés de l’angle droit sont donnés. Utiliser une fonc-
tion avec des paramètres étiquettes. Tester des appels différents pour cette fonc-
tion.
Exercice 17 :
Écrire une fonction pythagorus2 pour calculer l’hypoténuse d’un tri-
angle rectangle dont les cotés de l’angle droit sont donnés. Utiliser une fonc-
tion avec des paramètres avec valeurs par défaut. Tester des appels différents
pour cette fonction.
Exercice 18 :
Modifier la fonction volBoite(x1,x2,x3) de l’exercice 6, pour qu’elle
puisse être appelée avec trois, deux, un seul, ou même aucun argument. Utili-
sez pour ceux-ci des valeurs par défaut égales à 10.
Exercice 19 :
Modifiez la fonction volBoite(x1,x2,x3) de l’exercice précédent de
manière à ce qu’elle puisse être appelée avec un, deux, ou trois arguments. Si
un seul est utilisé, la boîte est considérée comme cubique (l’argument étant
l’arête de ce cube). Si deux sont utilisés, la boîte est considérée comme un
prisme à base carrée (auquel cas le premier argument est le côté du carré, et
le second la hauteur du prisme). Si trois arguments sont utilisés, la boîte est
considérée comme un parallélépipède. Si le nombre d’arguments est nul ou
supérieur à 3, la fonction doit renvoyer la valeur -1 avec un message d’erreur.
122 Programmation Python

Exercice 20 :
Définissez une fonction eleMax(liste,debut,fin) qui renvoie l’élé-
ment ayant la plus grande valeur dans la liste transmise. Les deux argu-
ments debut et fin indiqueront les indices entre lesquels doit s’exercer la
recherche, et chacun d’eux pourra être omis (comme dans l’exercice précé-
dent).
Exercice 21 :
Écrire une fonction somme avec un argument tuple de longueur variable
qui calcule la somme des nombres contenus dans le tuple. Tester cette fonction
par des appels avec différents tuples d’entiers ou de flottants.
Exercice 22 :
Écrire une autre fonction somme avec trois arguments, et qui renvoie leur
somme. Dans le programme principal, définir un tuple de trois nombres, puis
utilisez la syntaxe d’appel à la fonction qui décompresse le tuple. Affichez le
résultat.
Exercice 23 :
Écrire une fonction unDictionnaire avec un argument dictionnaire
de longueur variable , et qui affiche son argument. Dans le programme prin-
cipal, définir un dictionnaire, puis utilisez la syntaxe d’appel à la fonction qui
décompresse le dictionnaire. Affichez le résultat.
Chapitre 5. Fonctions 123

Corrigé des exercices

Corrigé exercice 1 :

def renvoie_ncar(n,car):
return(car*n)
# -------------------------------------
car=’a’
n=10
print(renvoie_ncar(n,car))

Corrigé exercice 2 :

def multiplication(base,debut,fin,inc):
print(’Table de multiplication par ’,base)
for x in range(debut,fin,inc):
print(f’{base}*{x} ={base*x}’)

# -----------------------------------------------
base=7
debut=1
fin=10
inc=1
multiplication(base,debut,fin,inc)

Corrigé exercice 3 :

def surfCercle(r) :
pi=3.14
return(pi*r**2)
# ------------------------------
r=1
print(f’Aire = {surfCercle(r)}’)

Corrigé exercice 4 :

def circonference(r):
pi=3.14
return(2*pi*r)
124 Programmation Python

def surface(r):
pi=3.14
return(pi*r**2)

# -----------------------------------
r=float(input(’Rayon = ’))
texte=’Circonférence’
print(texte.center(20,’*’))
print(’C = ’,circonference(r))
texte=’Surface’
print(texte.center(20,’*’))
print(’S = ’,surface(r))

Corrigé exercice 5 :

def cube(x):
return x**3

def volumeSphere(r):
pi=3.14
return 4*pi*cube(r)/3

# ------------------------------
r=float(input(’Rayon = ’))
texte=’Volume’
print(texte.center(20,’*’))
print(’S ={:3.2f} ’.format(volumeSphere(r)))

Corrigé exercice 6 :

def volBoite(x1,x2,x3):
return x1*x2*x3

# --------------------------------
a=5.2
b=7.7
c=3.3
print(f’{volBoite(a,b,c):.3f}’)
Chapitre 5. Fonctions 125

Corrigé exercice 7 :
def maximum(n1,n2,n3):
max=n1
if n2>max :
max=n2
if n3>max :
max=n3
return max

# --------------------------------
print(maximum(2,5,4))

Corrigé exercice 8 :
def equa1deg(a,b):
if a==0 :
print("Pas de solution")
elif a==0 and b==0 :
print("Forme indéterminée")
else :
return -b/a
# ----------------------------------
a=float(input(’Valeur de a :’))
b=float(input(’valeur de b :’))
print(’Solution’.center(20,’*’))
print(’x = ’,equa1deg(a,b))

Corrigé exercice 9 :
def fact(n):
if n==0:
return 1
else :
return n*fact(n-1)
# programme principal -----------------------------
n = int(input("n = "))
exp = 0.0
for i in range(n):
exp = exp + 1.0/fact(i)
print("Approximation de ’e’ : {:.3f}".format(exp))
126 Programmation Python

Corrigé exercice 10 :

def maFonction(x):
return 2*x**3 + x - 5

def tabuler(fonction, borneInf, borneSup, nbPas):

h = (borneSup - borneInf) / float(nbPas)
x = borneInf
while x <= borneSup:
y = fonction(x)
print(f"f({x:.2f}) = {y:.3f}")
x += h

# programme principal -----------------------------

a = float(input("Borne inferieure :"))
b = float(input("Borne superieure :"))
n = int(input("Nombre de pas :"))
tabuler(maFonction, a, b, n)

Corrigé exercice 11 :

def compteCar(ca,ch):
return(ch.count(ca))

# -------------------------------------------------
print(compteCar(’e’, ’Cette phrase est un exemple’))

Corrigé exercice 12 :

def indexMax(liste):
return(liste.index(max(liste)))

# -----------------------------------
serie = [5, 8, 2, 1, 9, 3, 6, 7]
print(indexMax(serie))
Chapitre 5. Fonctions 127

Corrigé exercice 13 :

def nomMois(n):
mois=[’janvier’,’février’,’mars’,’avril’,
’mai’,’juin’,’juillet’,’septembre’,
’octobre’,’novembre’,’décembre’]
return mois[n-1]

# --------------------------
print(nomMois(4))

Corrigé exercice 14 :

def inverse(ch):
return(ch[::-1])

#--------------------------------------------
print(inverse(’abcdefg’))

Corrigé exercice 15 :

def compteMots(ph):
tempcount = 0
count = 1
for character in ph:
if character == " ":
tempcount +=1
if tempcount ==1:
count +=1
else:
tempcount +=1
else:
tempcount=0
return count

#---------------------------------------
maphrase = "Je vais à l’école"
print(compteMots(maphrase))
128 Programmation Python

Corrigé exercice 16 :

def pythagorus1(x,y):
’’’ calcule l’hypoténuse d’un triangle ’’’
r = pow(x**2+y**2,0.5)
return x,y,r

#--------------------------------------
#Différents appels de la fonction
#appel 1
x,y,r=pythagorus1(3,4)
print(’-’*20)
print(f’x={x}, y={y}, r={r}’)

# appel 2
x,y,r=pythagorus1(x=3,y=4)
print(’-’*20)
print(f’x={x}, y={y}, r={r}’)

#appel 3
x,y,r=pythagorus1(y=4,x=3)
print(’-’*20)
print(f’x={x}, y={y}, r={r}’)
print(’-’*20)

Corrigé exercice 17 :

#Arguments avec valeur par défaut

# Valeurs par défaut
def pythagorus2(x=1,y=1):
""" calcule l’hypoténuse d’un triangle """
r = pow(x**2+y**2,0.5)
return x,y,r

#Différents appels de la fonction

#appel 1
x,y,r=pythagorus2(3,4)
print(’-’*20)
print(f’x={x}, y={y}, r={r}’)
Chapitre 5. Fonctions 129

# appel 2
x,y,r=pythagorus2(x=3,y=4)
print(’-’*20)
print(f’x={x}, y={y}, r={r}’)

#appel 3
x,y,r=pythagorus2(y=4,x=3)
print(’-’*20)
print(f’x={x}, y={y}, r={r}’)
#appel 4
x,y,r=pythagorus2()
print(’-’*20)
print(f’x={x}, y={y}, r={r}’)
print(’-’*20)

Corrigé exercice 18 :

def volBoite(x1=10,x2=10,x3=10):
return x1*x2*x3
# ----------------------------------
print(volBoite())
print(volBoite(5.2))
print(volBoite(5.2,3))

Corrigé exercice 19 :

def volBoite(*x):
’’’Volume d’une boite’’’
message=’’
if len(x)==0 or len(x)>3:
vol=-1
message=’erreur’
elif len(x)==1:
vol=x[0]**3
message=’Cube’
elif len(x)==2:
vol=x[0]**2*x[1]
message=’Base carrée’
else :
vol=x[0]*x[1]*x[2]
130 Programmation Python

message=’Parallélépipède’
return vol,message

# --------------Appel de la fonction --------------

volume,message=volBoite(5.2,3)
print(message.center(20,’-’))
print(f’Volume = {volume}’)

Corrigé exercice 20 :

def eleMax(liste,debut=0,fin=-1):
if fin==-1:
fin=len(liste)
maxi=liste[debut]
for i in range(debut,fin):
if maxi<liste[i]:
maxi=liste[i]
return maxi

# ---------------------------------------
serie=[9,3,6,1,7,5,4,8,2]
print(eleMax(serie,fin=9,debut=1))

Corrigé exercice 21 :

def somme(*args):
resultat = 0
for nombre in args:
resultat += nombre
return resultat

# programme principal --------------------

print("-"*40)
print(somme(23))
print("\n", "-"*40)
print(somme(-10, 13))
print("\n", "-"*40)
print(somme(23, 42, 13))
print("\n", "-"*40)
print(somme(-10.0, 12))
Chapitre 5. Fonctions 131

Corrigé exercice 22 :

def somme(a, b, c):

return a+b+c
# programme principal -----------------------------
sequence = (2, 4, 6)
print(somme(*sequence))

Corrigé exercice 23 :

def unDictionnaire(**kargs):
return kargs

# programme principal --------------------

print("Avec des paramètres nommés ")
print(unDictionnaire(a=23, b=42))
print("Avec un dictionnaire décompressé")
mots = {’d’:85, ’e’:14, ’f’:9}
print(unDictionnaire(**mots))
Chapitre 6

Fonctions et Modules

Dans ce chapitre :
Définition et utilisation des modules standard :
— math
— cmath
— random
— ...
Construction de modules personnels

Travaux Dirigés:
Exercices corrigés

133
134 Programmation Python

Dans le chapitre précédent nous avons considéré uniquement les fonctions

intégrées de Python et les fonctions écrites par l’utilisateur. De très nom-
breuses bibliothèques spécialisées existent en Python ; elles contiennent un
grand nombre de fonctions mises à la disposition des utilisateurs. De même
un programmeur peut développer ses propres bibliothèques. En Python ces
bibliothèques sont appelées modules. Dans ce chapitre nous allons préciser la
procédure d’importation de ces fonctions.
Un package (paquet) permet de réunir plusieurs modules sous un seul nom.
C’est un ensemble de modules physiquement rassemblés dans un répertoire ou
une arborescence.
Chaque distribution Python est livrée avec un nombre considérable de
modules qui augmentent la portée du langage. Pour de plus amples détails, la
documentation de référence se trouve à l’adresse :
https://docs.python.org/fr/3/library/index.html
Le tableau ci-dessous contient les principaux modules et packages utilisés
dans ce livre.

Module Contenu
math fournit un ensemble de fonctions permettant de réaliser des
calculs mathématiques
cmath fournit un ensemble de fonctions permettant de réaliser des
calculs mathématiques sur les nombres complexes
random fonctions permettant de travailler avec des valeurs aléatoires
statistics Ce module fournit des fonctions de calcul de statistiques ma-
thématiques de données numériques (valeurs réelles)
os fournit une manière portable d’utiliser les fonctionnalités
dépendantes du système d’exploitation
sys fournit une manière portable d’utiliser les fonctionnalités
dépendantes du système d’exploitation
glob Le module glob trouve tous les chemins correspondant à un
modèle spécifié selon les règles utilisées par le shell Unix
numpy NumPy enrichit le langage de programmation Python avec
de puissantes structures de données, implémentant des ta-
bleaux et des matrices multidimensionnels. Ces structures
de données garantissent des calculs efficaces avec des ma-
trices et des tableaux
matplotlib bibliothèque de tracés graphiques pour NumPy
Chapitre 6. Fonctions et Modules 135

Module Contenu
scipy bibliothèque open source utilisée pour résoudre des pro-
blèmes mathématiques, scientifiques, d’ingénierie et tech-
niques.
sympy bibliothèque open source pour le calcul symbolique en ma-
thématiques

1 Import
Pour utiliser des fonctions faisant partie d’un module, il faut avant tout les
importer. On utilise pour cela l’instruction import pour importer un module
entier.
— import module1, module2... : toutes les fonctions de(s) mo-
dule(s) spécifié(s) seront accessibles, mais seulement en les préfixant du
nom du module
— import module as nomLocal : toutes les fonctions du module
sont accessible en les préfixant du nomLocal que l’on s’est défini.
Il est possible d’utiliser l’instruction from ... import qui permet de
spécifier la liste des fonctions à importer après le import.
— from module import * : on obtient l’accès direct à l’ensemble
des fonctions du module indiqué sans devoir les préfixer par le nom du
module
— from module import fct1, fct2... : on ne souhaite l’accès
qu’aux fonctions fct1, fct2... spécifiées

Remarque : Il est recommandé d’éviter from module import * car

cela présente un risque de conflit si les différents modules chargés et/ou votre
programme implémentent des objets ou des fonctions de noms identiques.

Remarque : from module import * rend le code moins lisible puisque

on ne voit pas l’origine des fonctions utilisées.
136 Programmation Python

Exemple 1 : Utiliser pi et tan définis dans le module math

import math

alpha=math.pi/3
print(’Tangente de pi/3 = ’,math.tan(alpha))

Exemple 2 : Génération d’un nombre aléatoire avec la fonction randint du

module random
# importer la fonction randint
from random import randint

# Appeler la fonction randint

print(randint(10, 20))

16

Exemple 3 : Utilisation des fonctions sqrt (racine carrée) et sin (sinus) et

du nombre π faisant partie du module math :
from math import sqrt,sin,pi

print(’Racine de 2 = ’,sqrt(2))
print(’Sinus de pi/4 = ’,sin(pi/4))

Exemple 4 : Bien que déconseillé, on peut importer toutes les fonctions défi-
nies dans un module
from math import *

print(’cos(pi/3) = ’,cos(pi/3))
print(’logarithme népérien de 2 = ’,log(2))
Chapitre 6. Fonctions et Modules 137

Exemple 5 : Utiliser un acronyme à la place du nom du module

import math as mt

print(mt.exp(1))
print(mt.log(1) )
print(mt.log10(10))

Remarque : Il est conseillé d’importer dans l’ordre :

— les modules de la bibliothèque standard ;
— les modules des bibliothèques tierces ;
— Les modules personnels.

2 Aide
Il existe une fonction intégrée pour lister tous les noms de fonctions (ou
noms de variables) dans un module : la fonction dir().
Exemple 6 : Répertorier toutes les noms définis appartenant au module
platform
import platform
dir(platform)
Pour obtenir de l’aide, une autre possibilité consiste utiliser la fonction
help() dans une console pour avoir la liste des fonctions et modules dis-
ponibles. Par exemple pour accéder au fichier d’aide du module random, on
écrira :
help(random)

3 Le module math
math contient une riche bibliothèque de fonctions prédéfinies. Pour les
utiliser on doit connaître leur nom. L’aide en ligne ou l’utilisation d’un mo-
teur de recherche sur Internet, permettent de se documenter sur une fonction
donnée.
138 Programmation Python

Deux constantes sont définies dans le module math

• math.pi : La constante mathématique π, en tant que flottant.
• math.e : La constante mathématique e, en tant que flottant.
Les fonctions les plus courantes du module math sont résumées dans les
tableaux ci-dessous .

Fonctions trigo- Description

nométriques
sin(x) sinus
cos(x) cosinus
tan(x) tangente
asin(x) arc sinus
acos(x) arc cosinus
atan(x) −π/2 ≤ atan(x) ≤ π/2
atan2(x,y) −π ≤ atan2(x,y) ≤ π
sinh(x) sinus hyperbolique
cosh(x) cosinus hyperbolique
tanh(x) tangente hyperbolique
asinh(x) argument sinus hyperbolique
acosh(x) argument cosinus hyperbolique
atanh(x) argument tangente hyperbolique

Autres fonctions Description

abs(x) Valeur absolue de x
sqrt(x) Racine carrée de x
round(x) arrondi entier de x
fix(x) arrondi par défaut de x
floor(x) arrondi au voisinage de −∞ de x
ceil(x) arrondi au voisinage de +∞ de x
rem(x,y) Le reste de la division x/y
exp(x) exponentielle de base e
log(x) Log (de base e)
log10(x) log (de base 10)
Chapitre 6. Fonctions et Modules 139

Exemple 7 : Écrire un programme contenant la fonction mathématique :

y(x) = [e−x /(x2 + 1) + sin2 (x)]2 + 0.2

import math
#--------------------------
def mafun(x):
’’’y(x)=[e^{-x}/(x^2+1)+sin^2(x)]^2+0.2’’’
u=math.exp(-x)/(x**2+1)
v=math.sin(x)**2
w=u+v
y=w**2+0.2
return y
# --------------------------
x=float(input("x = "))
print(f’y({x}) = {mafun(x)}’)

4 Le module cmath
Le module cmath contient des fonctions pour les nombres complexes.
import cmath
#Pour avoir la liste des fonctions de cmath
print(dir(cmath))

[....,
’acos’,
’acosh’,
’asin’,
’asinh’,
’atan’,
’atanh’,
’cos’,
’cosh’,
’e’,
’exp’,
...]
140 Programmation Python

Exemple 8 : Utilisation de cmath

import cmath
x,y=1,2
z=complex(x,y)
print(’z=’,z)

#conversion(x,y)-->(rho,theta)
cmath.polar(z)
r,theta=cmath.polar(z)
print(’Module=’,r)
print(’Argument=’,theta)

#conversion (rho,theta)-->(x,y)
rho,phi=1,cmath.pi/4
z=cmath.rect(rho,phi)
print(’z=’,z)

z= (1+2j)
Module= 2.23606797749979
Argument= 1.1071487177940904
z= (0.7071067811865476+0.7071067811865475j)

5 Le module random
On utilise le module random pour la génération de valeurs aléatoires.

Fonction Rôle
seed(n) réinitialise le générateur de nombres aléatoires en uti-
lisant l’entier n.
seed() réinitialise le générateur de nombres aléatoires mais
en utilisant l’horloge du système.
randrange(a,b,h) un entier aléatoire de [a, b[, avec le pas h (par défaut
h = 1).
randrange(b) un entier aléatoire de [0, b[.
randint(a,b) un entier aléatoire de [a, b], donc synonyme de ran-
drange(a,b,1)
Chapitre 6. Fonctions et Modules 141

Fonction Rôle
choice(seq) un élément au hasard dans la séquence (non vide) seq
shuffle(seq) “rebat” aléatoirement la séquence (non vide) seq
(opère sur place)
sample(pop,k) liste de k éléments distincts de pop (ensemble ou sé-
quence)
random() le prochain réel pseudo-aléatoire dans [0, 1[
uniform(a,b) un réel pseudo-aléatoire dans [a, b]
gauss(m,σ) réel pseudo-aléatoire, distribution gaussienne,
moyenne m, écart-type σ

Exemple 9 : randint(entier1,entier2) renvoie un nombre compris

entre entier1 et entier2.
from random import randint
print(randint(10, 20))

17

Exemple 10 : Pour générer un nombre réel aléatoire compris entre 0 et 1

from random import random

print(random())

0.09034475663047392

Exemple 11 : uniform(a,b) renvoie un nombre réel compris entre a et b

from random import uniform

uniform(1.5,6.7)

5.037284479304411
142 Programmation Python

Exemple 12 : Pour générer un nombre aléatoire inférieur à une limite

from random import randrange

print(randrange(10))

Exemple 13 : Pour extraire d’une liste une liste aléatoire de k éléments

from random import sample

k=10
print(sample(range(100),10))

[40, 91, 97, 7, 86, 78, 96, 61, 10, 0]

Exemple 14 : Pour extraire une liste aléatoire contenant un nombre aléatoire

d’éléments
k=10
print(sample(range(100),randrange(k)))

[94, 73, 21, 11, 53, 43]

Exemple 15 : choice(L) renvoie au hasard un élément de la liste L.

from random import choice

L=[1,2,3,10,12]
choice(L)

10

prenoms=[’ali’,’omar’,’fatima’]
choice(prenoms)

’omar’
Chapitre 6. Fonctions et Modules 143

Exemple 16 : Mélange de liste

# on forme la liste [0, 1,..., 9]

t = list(range(0,10))
print(’Avant :’, t)
# on rebat cette liste aléatoirement (sur place)
shuffle(t)
print(’Après :’, t)

Avant : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Après : [2, 0, 4, 9, 6, 7, 1, 5, 3, 8]

6 Le module statistics
Ce module fournit des fonctions pour calculer les statistiques de données
telles que les moyennes, la variance et l’écart type.

Fonction Description
mean Moyenne arithmétique (moyenne) des données.
fmean Moyenne arithmétique rapide à virgule flottante.
geometric_mean Moyenne géométrique des données.
harmonic_mean Moyenne harmonique des données.
median Médiane (valeur moyenne) des données.
median_low Faible médiane des données.
median_high Médiane élevée des données.
median_grouped Médiane, ou 50e centile, des données regroupées.
mode Mode (valeur la plus courante) des données.
multimode Liste des modes (valeurs de données les plus cou-
rantes).
quantiles Divise les données en intervalles avec une probabilité
égale.
pvariance Variance de la population des données.
variance Échantillon de variance des données.
pstdev Écart-type de population des données.
stdev Échantillon d’écart type des données.
144 Programmation Python

Exemple 17 : Pour calculer la moyenne arithmétique de données

import statistics
statistics.mean([-1.0, 2.5, 3.25, 5.75])

2.625

Exemple 18 : Pour calculer la valeur médiane standard d’un ensemble discret

de valeurs.
statistics.median([2, 3, 4, 5])

3.5

Exemple 19 : fmean(données), plus rapide que mean convertit les don-

nées en flottants et calcule la moyenne arithmétique.
statistics.fmean([3.5, 4.0, 5.25])

4.25

Exemple 20 : geometric_mean(data) convertit les data en flottants et

calcule la moyenne géométrique.
round(statistics.geometric_mean([54, 24, 36]), 9)

36.0

Exemple 21 : Calcul de la variance

data = [2.75, 1.75, 1.25, 0.25, 0.5, 1.25, 3.5]

statistics.variance(data)

1.3720238095238095

Exemple 22 : Pour calculer l’écart type

statistics.stdev([1.5, 2.5, 2.5, 2.75, 3.25, 4.75])

1.0810874155219827
Chapitre 6. Fonctions et Modules 145

7 Le module os
Le module os de Python fournit des fonctions pour interagir avec le sys-
tème d’exploitation. Le module os permet de gérer l’arborescence des fichiers
Exemple 23 : getcwd() renvoie une chaîne unicode représentant le réper-
toire de travail actuel.
import os
print(os.getcwd())

/home/utilisateur/programmesJupyter

Exemple 24 : mkdir() crée un nouveau répertoire

#Pour créer un dossier dans le répertoire racine

os.mkdir("c:/mondossier")

Exemple 25 : rmdir() pour supprimer un répertoire

os.rmdir("c:/mondossier")

Exemple 26 : getlogin() pour obtenir le nom de l’utilisateur

print(os.getlogin())

user

8 Le module glob
Le module glob recherche tous les chemins correspondant à un motif
particulier selon les règles utilisées par le shell Unix.
Exemple 27 :

import glob
print(glob.glob(’*’))
146 Programmation Python

9 Importer un module depuis un package

Une librairie (package) regroupe plusieurs modules dans différents sous-
répertoires. Le chargement spécifique d’un des modules se fait en précisant le
chemin.
Exemple 28 : Pour importer le module pyplot du package matplotlib
avec l’acronyme plt
import matplotlib.pyplot as plt

10 Comment écrire un module

Un module contient plusieurs fonctions et commandes qui sont regroupées
dans un fichier d’extension .py. Insérer un fichier vide de nom _init_.py
dans chaque dossier et sous-dossier contenant un module à importer. Un mo-
dule est appelé par la commande import. Un module est considéré comme
un script s’il contient des commandes. Lors de l’import d’un script, les com-
mandes sont exécutées tandis que les fonctions sont seulement chargées.
Exemple 29 : Pour créer un module intitulé testM

1. Commencer par créer un fichier texte contenant les commandes sui-

vantes
def DitBonjour():
print("Bonjour")
def DivBy2(x):
return x/2

2. Enregistrer le fichier avec pour nom testM.py dans le répertoire cou-

rant.
3. Pour importer les fonctions de ce module, il est possible :
— d’importer le module avec import
import testM
testM.DitBonjour()
print(testM.DivBy2(10))
Chapitre 6. Fonctions et Modules 147

— d’importer toutes les fonctions du module

from testM import *
DitBonjour()
print(DivBy2(10))

— ou d’importer seulement celles qui seront utilisées

from testM import DitBonjour
DitBonjour()

Lors de son premier appel, un module est pré-compilé dans un fichier

.pyc qui est utilisé pour les appels suivants. Attention, en mode interactif,
si le fichier a été modifié ou corrigé, il a besoin d’être rechargé par la com-
mande reload(name).
148 Programmation Python

Exercices

Exercice 1 :
Utiliser le module math pour écrire une fonction permettant de passer des
coordonnées cartésiennes (x, y) aux coordonnées polaires (ρ, θ).
Exercice 2 :
Proposer une fonction trinome_r pour trouver les racines réelles d’une
équation du second degré du type ax2 + bc + c = 0. Utiliser le module math.
Exercice 3 :
Utiliser le module cmath pour écrire une fonction qui permet de trouver
les racines d’une équation du second degré du type ax2 + bc + c = 0.
Exercice 4 :
Soit les nombres complexes : z1 = 1 + i, z2 = −2 + i et z3 = −i. Évaluer
les expressions suivantes :
(a) z1 + z2 − z3 , (b) z1z3z2 , (c) ln(z1 ), (d) sin(z3 ).
Exercice 5 :
√
Écrire un programme pour définir la fonction f 1(x) = 3 x + 2.
Exercice 6 :
Écrire un programme de simulation de lancer de dé.
Exercice 7 :
Écrire un programme réalisant une permutation aléatoire de 0, 1,..., 9
Exercice 8 :
Écrire un programme qui simule 6 tirages successifs, sans remise, d’une
boule dans une urne contenant 49 boules numérotées de 1 à 49. Le résultat des
tirages sera mémorisé dans une liste.
Exercice 9 :
Un pays a mis en place la politique nataliste suivante : Les couples font
des enfants jusqu’à ce qu’ils obtiennent un garçon. Cette politique a-t-elle une
influence sur la proportion de filles et de garçons dans ce pays ? On veut simu-
ler les naissances d’enfants de 10000 couples après la mise en place de cette
politique et déterminer les fréquences de filles et de garçons.
Chapitre 6. Fonctions et Modules 149

Corrigé des exercices

Corrigé exercice 1 :

import math
# ----------------------
def polaire(x,y):
r=math.sqrt(x**2+y**2)
q=math.atan2(x,y)
return r,q
# ----------------------
x=float(input("x = "))
y=float(input("y = "))
rho,theta=polaire(x,y)
print("rho = ",rho)
print("theta = ",theta*180/math.pi,"degrés")

Corrigé exercice 2 :

from math import sqrt

def trinome_r(a,b,c) :
Delta=b**2-4*a*c
print("Delta=",Delta)
if Delta<0:
print("Pas de racines")
elif Delta==0:
x1=-b/(2*a)
print("Delta=0")
print("Une seule racine : ",x1)
else:
x1=(-b-sqrt(Delta))/(2*a)
x2=(-b+sqrt(Delta))/(2*a)
print("Delta>0")
print("Deux racines :")
print("x1=",x1,", x2=", x2)

# -----------------------------------------
print("Racines éventuelles de ax^2+bx+c")
a=float(input("Saisir la valeur de a\n"))
150 Programmation Python

b=float(input("Saisir la valeur de b\n"))

c=float(input("Saisir la valeur de c\n"))
trinome_r(a,b,c)

Corrigé exercice 3 :

from cmath import sqrt

# ----------------------------------------
def trinome_c(a,b,c):
Delta=b**2-4*a*c
print("Delta=",Delta)
if Delta!=0:
x1=(-b-sqrt(Delta))/(2*a)
x2=(-b+sqrt(Delta))/(2*a)
if isinstance(x1, complex):
nombre=’complexes’
else :
nombre=’réelles’
print("Delta!=0")
print("Deux racines :",nombre)
print("x1=",x1,", x2=", x2)
else :
x1=-b/(2*a)
print("Delta=0")
print("Une seule racine : ",x1)
# ---------------------------------------
print("Racines de ax^2+bx+c")
a=float(input("Saisir la valeur de a\n"))
b=float(input("Saisir la valeur de b\n"))
c=float(input("Saisir la valeur de c\n"))
trinome_c(a,b,c)

Corrigé exercice 4 :

from math import sqrt

# --------------------------------
#Création de la fonction f1
def f1(x):
if x<0:
return False
Chapitre 6. Fonctions et Modules 151

else:
return 3*sqrt(x)+2
# --------------------------------
#Structure principale du programme
x=float(input("Quelle est la valeur de x?\n"))
print("f1(",x,")=",f1(x))

Corrigé exercice 5 :

# on importe le module random

import random as rd
# on simule 10 lancers de dé
#Comprehension de liste
liste = [rd.randint(1,6) for k in range(10)]
print(liste)

Corrigé exercice 6 :

# on importe le module random

import random as rd
rd.sample(range(0,10),10)

Corrigé exercice 7 :

#Importation des fonctions du module random

from random import choice
u=list(range(1,50))
#Affectation de [1,2,..,49] à la liste U
L=[] #Affectation de la liste vide à L
j=1
while j<=6:
tirage=choice(u)
u.remove(tirage)
L.append(tirage)
j=j+1
print(L)
152 Programmation Python

Corrigé exercice 8 :

from random import *

k=1 # k: numéro du couple ( entre 1 et 10000)
N_f=0 # N_f: nombre de filles nées
N_g=0 # N_g : nombre de garcons nés
while k<=10000:
sexe=-1
# la variable sexe est initialisée à -1
# 0 : la naissance d’une fille
# 1 : la naissance d’un garcon
while sexe!=1:
# tant que ce n’est pas un garcon
sexe=randint(0,1)
if sexe==0: # Si c’est une fille
N_f=N_f+1
else:
N_g=N_g+1
k=k+1
f_F=N_f/(N_f+N_g)
f_G=N_g/(N_f+N_g)
print("la fréquence de filles est égale à",f_F)
print("la fréquence de garcons est égale à",f_G )
Chapitre 7

Calcul Scientifique

Dans ce chapitre :
Apprendre les éléments de base des packages de calcul scien-
tifique
— numpy
— scipy

Travaux Dirigés:
Exerices corrigés

153
154 Programmation Python

1 Principaux packages
Les principaux paquets de calcul scientifique utilisés dans ce livre sont :
— numpy
numpy est le package fondamental pour le calcul scientifique en Py-
thon. Il s’agit d’une bibliothèque qui définit le type de données array
ainsi que les fonctions de calcul qui y sont associées. numpy fournit di-
vers objets dérivés (tels que des tableaux et des matrices) et un assorti-
ment de routines pour des opérations rapides sur les tableaux, y compris
mathématiques, logiques, manipulation de forme, tri, sélection, entrées-
sorties, transformées de Fourier discrètes, algèbre linéaire de base, opé-
rations statistiques de base, simulation aléatoire et bien plus encore.
— scipy
Cette librairie est un ensemble très complet de modules d’algèbre li-
néaire, statistiques et autres algorithmes numériques. Le site de la do-
cumentation en fournit la liste.
— matplotlib
Il s’agit de la librairie principale pour tracer et visualiser des données
sous formes de graphiques sous Python .
— sympy
Sympy est la librairie Python utilisée pour le calcul symbolique. Elle
est présentée plus en détail dans le dernier chapitre.

2 Numpy
numpy est un package Python spécialisé dans la manipulation des ta-
bleaux (array) (i.e les vecteurs et les matrices). Par exemple, une matrice
est un tableau (array) à 2 dimensions. Les tableaux numpy ne gèrent que
des objets de même type. Le package numpy propose un grand nombre de
routines pour un accès rapide aux données (ex. recherche, extraction), pour
les manipulations diverses (ex. tri) et pour les calculs (ex. calcul statistique).
Les tableaux numpy sont plus performants que les collections usuelles de
Python . Les tableaux numpy sont sous-jacents à de nombreux packages
dédiés au calcul scientifique sous Python.
Chapitre 7. Calcul Scientifique 155

Dans la syntaxe la plus courante, on importe la totalité du module numpy

et on lui donne un alias (acronyme) pour alléger l’écriture de l’appel des fonc-
tions. L’alias qui est le plus couramment utilisé est np.

2.1 Type ndarray

numpy définit un type de base pour les données : le type ndarray. Les
éléments de type ndarray sont créés en utilisant la fonction array ()
de numpy. Sous Python , c’est de loin la structure de données la plus uti-
lisée pour le calcul scientifique . Elle décrit des tableaux ou matrices multi-
indices de dimension n = 1, 2, 3, . . . , 40. Tous les éléments d’un objet de type
ndarray sont de même type (booléen, entier, réel ou complexe).
Un moyen pratique de créer un tableau consiste à utiliser la fonction array.
Cette fonction nécessite une liste ou un tuple comme entrée.
Exemple 1 : array avec des entiers
x = np.array([0, 1, 2])
print(x)

[0 1 2]

Exemple 2 : array avec des floats

x = np.array([0., 1., 2.])
print(x)

[0. 1. 2.]

type(x)

numpy.ndarray

Exemple 3 : array avec des complexes

import numpy as np
x=np.array([2,5+2j,3,1j])
print(’x = ’,x)
print(type(x))

x = [2.+0.j 5.+2.j 3.+0.j 0.+1.j]

<class ’numpy.ndarray’>
156 Programmation Python

2.2 Création de tableaux

Création de tableaux 0-D, 1-D et 2-D

Les tableaux 0-D, ou scalaires, sont les éléments d’un tableau.

Exemple 4 : Création d’un scalaire

scalaire=np.array(42)
print(scalaire)
type(scalaire)

42
numpy.ndarray
Un tableau qui a des tableaux 0-D comme éléments est appelé tableau uni-
dimensionnel ou 1-D. Les tableaux 1-D sont souvent utilisés pour représenter
des vecteurs.
Exemple 5 : Création à partir d’une liste

tableau=np.array([1,2,3,4,5])
print(tableau)
type(tableau)

[1 2 3 4 5]
numpy.ndarray

Exemple 6 : Création à partir d’une liste définie par range

tableau=np.array(range(0,20,2))
print(tableau)
type(tableau)

[ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

numpy.ndarray

Exemple 7 : Création d’un tableau à partir d’un tuple

tableau=np.array((1,2,3,4,5))
print(tableau)
type(tableau)
Chapitre 7. Calcul Scientifique 157

[1 2 3 4 5]
numpy.ndarray
Un tableau qui a des tableaux 1-D comme éléments est appelé un tableau
2-D. Les tableaux 2-D sont souvent utilisés pour représenter des matrices ou
des tenseurs du second ordre.
Exemple 8 : Création d’un tableau 2-D

tableau2D=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(tableau2D)

[[1 2 3]
[4 5 6]
[7 8 9]]

Création d’un tableau avec arange

numpy.arange() permet d’obtenir un tableau 1D allant d’une valeur

de départ à une valeur de fin avec un incrément donné. La valeur fin est omise
dans le tableau créé.
Exemple 9 :

x=np.arange(0,2,0.4)
print(x)

[0. 0.4 0.8 1.2 1.6]

Création d’un tableau avec linspace

numpy.linspace() permet d’obtenir un tableau 1D allant d’une va-

leur de départ à une valeur de fin avec un nombre donné d’éléments.
Exemple 10 :

x=np.linspace(0,2,5)
print(x)

[0. 0.5 1. 1.5 2. ]

158 Programmation Python

2.3 Tableaux particuliers

Tableaux de 0 - numpy.zeros()

Exemple 11 : Créer un tableau de dimension donnée rempli de zéros.

a=np.zeros(4)
print(a)
type(a)

[0. 0. 0. 0.]
numpy.ndarray

b=np.zeros([2,2])
print(’b = ’, b)

b = [[0. 0.]
[0. 0.]]

Tableaux de 1 - numpy.ones()

Exemple 12 : Créer un tableau de dimension donnée rempli de 1

c=np.ones(4)
print(’c = ’,c)

c = [1. 1. 1. 1.]

d=np.ones([2,2])
print(d)

[ [1. 1.]
[1. 1.]]

Tableau identité - numpy.eye()

Exemple 13 : Créer un tableau de zéros avec éléments diagonaux égaux à 1.

unite=np.eye(3)
print(unite)
Chapitre 7. Calcul Scientifique 159

[[ 1., 0., 0.],

[0., 1., 0.],
[0., 0., 1.]]

2.4 Vérification du type de données d’un tableau

L’objet array de NumPy a une propriété appelée dtype qui renvoie le
type de données du tableau.
Exemple 14 :

import numpy as np
table=np.array([0.2,0.5,np.pi])
print(’type de table: ’,table.dtype)
tablentiers=np.array([0,2,-2])
print(’type de tablentiers: ’,tablentiers.dtype)

type de table: float64

type de tablentiers: int64

2.5 Dimension d’un tableau

La méthode ndim permet d’obtenir la dimension d’un tableau.
Exemple 15 :

tableau=np.array([1,2,3,4])
tableau2D=np.array([[1,2],[3,4]])
print(’Dim tableau : ’,tableau.ndim)
print(’Dim tableau2D : ’,tableau2D.ndim)

Dim tableau : 1
Dim tableau2D : 2

2.6 Obtenir la forme d’un tableau

Exemple 16 :
Les tableaux numpy ont un attribut appelé shape qui renvoie un tuple
dont chaque élément donne le nombre d’éléments dans une dimension.
160 Programmation Python

x=np.array([[1,2,3],[4,5,6]])
print(’Dim : ’,x.ndim)
print(’Shape : ’,x.shape)
print(’nombre de lignes = ’,x.shape[0])
print(’nombre de colonnes = ’,x.shape[1])

Dim : 2
Shape : (2, 3)
nombre de lignes = 2
nombre de colonnes = 3

2.7 Accès aux éléments d’un tableau

Exemple 17 : Les indices de l’élément recherché sont entre crochets et le pre-

mier indice est 0.
tableau=np.array([1,2,3,4])
tableau2D=np.array([[1,2],[3,4]])
print(tableau[1])
print(tableau2D[0,1])

2
2

Exemple 18 : Les indices négatifs permettent de rechercher les éléments à

partir de la fin.
tableau=np.array([[1,2,3,4],[6,7,8,9]])
message=’Dernier élément de la seconde ligne :’
print(message,tableau[1,-1])

Dernier élément de la seconde ligne : 9

2.8 Extraction d’une partie du tableau

Le découpage en Python consiste à extraire des éléments d’un index
donné à un autre index donné comme par exemple : [début: fin]. Cela
peut également être écrit comme ceci : [début: fin: pas].
Chapitre 7. Calcul Scientifique 161

— Si nous ne donnons pas la valeur début, elle est considérée comme égale
à 0.
— Si nous ne ne donnons pas la valeur fin, elle est considérée comme égale
à la longueur du tableau.
— Si pas n’est pas fourni, il est considéré comme égal à 1.

Exemple 19 :

tableau=np.array([1,2,3,4,5,6,7])
tableau[1:5]

array([2, 3, 4, 5])

tableau[:3]

array([1, 2, 3])

tableau[3:]

array([4, 5, 6, 7])

tableau[3::2]

array([4, 6])

Remarque : Le premier indice est pris en compte mais le dernier indice est
exclu.

Exemple 20 : Extraction-découpage à partir de la fin du tableau

print(tableau[-3:-1])

[5 6]
162 Programmation Python

2.9 Remodelage des tableaux

Remodeler signifie changer la forme d’un tableau. La forme d’un tableau
correspond au nombre d’éléments dans chaque dimension. En remodelant, on
peut ajouter ou supprimer des dimensions ou encore changer le nombre d’élé-
ments dans chaque dimension.
Exemple 21 : Convertir un tableau 1-D en un tableau 2-D.

y=np.array([0,1,2,3,4,5])
print(y.shape)

(6,)

y2=y.reshape(2,3)
print(y2)

[[0 1 2]
[3 4 5]]

y3=y.reshape(3,2)
print(y3)

[[0 1]
[2 3]
[4 5]]

2.10 Action d’une fonction mathématique sur un tableau

NumPy dispose d’un grand nombre de fonctions mathématiques qui peuvent
être appliquées directement à un tableau. Dans ce cas, la fonction est appliquée
à chacun des éléments du tableau.
Exemple 22 : Opérations élémentaires

a=np.array([[1,2],[3,4]])
print(a**2)

[[ 1 4]
[ 9 16]]
Chapitre 7. Calcul Scientifique 163

print(a*3)

[[ 3 6]
[ 9 12]]

Exemple 23 : Calcul de sinus

x=np.pi/np.array([2,3,4,6])
y=np.sin(x)
print(y)

[1. 0.8660254 0.70710678 0.5]

2.11 Polynômes
numpy fournit un ensemble fonctions spécifiques aux polynômes. Les va-
leurs des coefficients du polynôme de degré n sont rangés dans un tableau p
de taille n+1. Un polynôme est donc décrit par :
p[0]xn + p[1]x(n−1) + ... + p[n − 1]x + p[n].
Exemple 24 : Pour construire un polynôme

p = np.poly1d([1, 2, 3])
print(np.poly1d(p))

2
1 x + 2 x + 3

Exemple 25 : Valeur du polynôme pour x = 0.5

p(0.5)

4.25

Exemple 26 : numpy.roots(p) pour trouver les racines d’un polynôme

np.roots(p)

array([-1.+1.41421356j, -1.-1.41421356j])
164 Programmation Python

Fonction Rôle
poly1d() Classe de polynômes à une variable
polyval() Évaluation de polynômes pour des valeurs spécifiques
de la variable
poly() Estime les coefficients d’un polynôme définie par sa
séquence de racines.
roots(p) Renvoie les racines du polynôme défini par les coeffi-
cients p
polyfit() Lissage par un polynôme.
polyder() Calcul des coefficients de la dérivée d’un polynôme
polyint() Calcul des coefficients de l’intégrale d’un polynôme
polyadd() Calcul des coefficients de la somme de deux poly-
nômes
polydiv() Calcul de la division de deux polynômes
polymul(a1, a2) Calcul des coefficients du produit de deux polynômes
polysub(a1, a2) Calcul des coefficients de la différence de deux poly-
nômes.
Quelques fonctions spécialisées pour les polynômes

2.12 Opérations avec les tableaux et les matrices

Exemple 27 : Opérations de calcul terme à terme

a=np.array([[1,2],[3,4]])
b=np.array([[5,6],[7,8]])
print(a+b)

[[ 6 8]
[10 12]]

print(a*b)

[[ 5 12]
[21 32]]

print(b/a)
Chapitre 7. Calcul Scientifique 165

[[5. 3. ]
[2.33333333 2. ]]

Remarque : Pour les opération terme à terme impliquant 2 tableaux, il faut

que les deux tableaux aient la même taille.

Exemple 28 : Produit matriciel - numpy.dot()

a=np.array([0,1,2,3,4,5])
print(a)

[0, 1, 2, 3, 4, 5]

b=a.reshape(2,3)
print(b)

[[0, 1, 2],
[3, 4, 5]]

c=a.reshape(3,2)
print(c)

[[0, 1],
[2, 3],
[4, 5]]

print(b.dot(c))

[[10, 13],
[28, 40]]

print(c.dot(b))

[[ 3, 4, 5],
[ 9, 14, 19],
[15, 24, 33]]

Exemple 29 : Calculer la transposée d’une matrice

a = b.T
print(a)
166 Programmation Python

[[0, 3],
[1, 4],
[2, 5]]

a = c.T
print(a)

[[0, 2, 4],
[1, 3, 5]]

Exemple 30 : Calculer la matrice complexe conjuguée d’une matrice

z=np.array([[1+0.1j,1-1j],[1j,-3]])
print(z)

[[ 1.+0.1j, 1.-1.j ],
[ 0.+1.j , -3.+0.j ]]

k = np.conj(z)
print(k)

[[ 1.-0.1j, 1.+1.j ],
[ 0.-1.j , -3.-0.j ]]

Exemple 31 : Calculer la transposée de la matrice conjuguée d’une matrice

complexe
k = np.conj(z).T
print(k)

[[ 1.-0.1j, 0.-1.j ],
[ 1.+1.j , -3.-0.j ]]

2.13 Algèbre linéaire

Exemple 32 : Calcul de déterminant avec numpy.linalg.det()

from numpy.linalg import det

a = np.array([[1, 2],[3, 4]])
print(det(a))
Chapitre 7. Calcul Scientifique 167

-2

Exemple 33 : Calcul de l’inverse d’une matrice avec numpy.linalg.inv()

from numpy.linalg import inv

a = np.array([[1, 3, 3],
[1, 4, 3],
[1, 3, 4]])
print(inv(a))

[[ 7., -3., -3.],

[-1., 1., 0.],
[-1., 0., 1.]]

Exemple 34 : Résolution d’un système d’équations linéaires avec la fonction

numpy.linalg.solve().
Pour résoudre le système d’équations linéaires :

3x + y = 9
x + 2y = 8

a = np.array([[3,1], [1,2]])
b = np.array([9,8])
x = np.linalg.solve(a, b)
print(’x = ’,x[0])
print(’y = ’,x[1])

x = 2.0
y = 3.0

Exemple 35 : Valeurs propres et vecteurs propres avec numpy.linalg.eig().

from numpy.linalg import eig

A = np.array([[1,1,-2], [-1,2,1], [0,1,-1]])
D, V = eig(A)
print(’Valeurs propres’.center(30,’*’))
print(D)
print(’Vecteurs propres’.center(30,’*’))
print(V)
168 Programmation Python

*******Valeurs propres********
[ 2. 1. -1.]
*******Vecteurs propres*******
[[ 3.01511345e-01 -8.01783726e-01 7.07106781e-01]
[ 9.04534034e-01 -5.34522484e-01 8.03160908e-17]
[ 3.01511345e-01 -2.67261242e-01 7.07106781e-01]]

3 Scipy
Le package scipy contient diverses boîtes à outils dédiées aux problèmes
courants de l’informatique scientifique. Ses différents sous-modules corres-
pondent à différentes applications, telles que l’interpolation, l’intégration, l’op-
timisation, le traitement d’images, les statistiques, les fonctions spéciales, etc.
scipy peut être comparé à d’autres bibliothèques de calcul scientifique
standard, telles que GSL (GNU Scientific Library pour C et C ++), ou les tool-
box de Matlab. scipy est le package de base pour les routines scientifiques
en Python ; il est destiné à fonctionner efficacement sur des tableaux numpy.
Avant d’implémenter une fonction personnelle, il convient de vérifier si le
traitement de données souhaité n’est pas déjà implémenté dans scipy car les
fonctions de scipy sont optimisées et testées, et doivent donc être utilisées
préférentiellement lorsque cela est possible.
scipy contient principalement des fonctions qui sont vraiment des fonc-
tions numpy (par exemple scipy.cos n’est rien d’autre que np.cos). Il
n’y a donc aucune raison d’utiliser d’importer scipy dans sa totalité.
Pour importer numpy et le module scipy.optimize il suffit d’écrire :
import numpy as np
from scipy import optimize

Le paquet scipy contient un grand nombre de sous-packages spéciali-

sés pour le calcul scientifique. Décrire toutes les fonctions disponibles dans
scipy sort du cadre de ce livre. A titre d’initiation nous proposons des exemples
utilisant les sous packages : special, integrate et optimize. Le lec-
teur pourra tester chacune des solutions proposées dans les exercices et appro-
fondir chaque exemple en consultant la très riche documentation disponible
sur Internet :
https ://docs.scipy.org/doc/scipy/reference/tutorial/index.html#user-guide
Chapitre 7. Calcul Scientifique 169

3.1 Fonctions spéciales avec scipy.special

La principale caractéristique du package scipy.special est la défi-
nition de nombreuses fonctions spéciales de la physique mathématique. Les
fonctions disponibles incluent les fonctions d’Airy, elliptiques, Bessel, Gamma,
Beta, hypergéométriques, cylindriques paraboliques, Mathieu, harmoniques
sphériques, Struve et Kelvin. La plupart de ces fonctions acceptent des ta-
bleaux et renvoient des résultats sous forme de tableaux compatibles avec
numpy. Certaines fonctions acceptent également des nombres complexes en
entrée.
Pour l’utiliser il faudra d’abords faire l’importation, avec from scipy
import special. Il est possible d’utiliser help(special) pour obte-
nir la liste complète des fonctions disponibles avec une description. Chaque
fonction dispose également de sa propre documentation accessible via l’aide
en ligne sur internet.
Exemple 36 : J0 (x) : fonction de Bessel de première espèce d’ordre zéro.
Valeurs de J0 (0) et J0 (π)
import numpy as np
from scipy.special import j0
x=[0,np.pi]
y=j0(x)
print(’x = ’,x)
print(’J0(x) = ’,y)

x = [0, 3.141592653589793]
J0(x) = [ 1. -0.30424218]

Exemple 37 : Fonction d’Airy Ai (x) et fonction d’Airy de deuxième espèce

Bi (x).
# Valeurs de la fonction d’Airy pour x=-5 et 5.
from scipy import special
x = [-5,5]
ai, aip, bi, bip = special.airy(x)
print(’x = ’,x)
# Fonction d’Airy
print(’Ai = ’,ai)
# Fonction d’Airy de 2nde espèce
print(’Bi = ’,bi)
170 Programmation Python

x = [-5, 5]
Ai = [3.50761009e-01 1.08344428e-04]
Bi = [-1.38369135e-01 6.57792044e+02]

3.2 scipy.integrate
Le sous-package scipy.integrate fournit plusieurs techniques d’in-
tégration, y compris un intégrateur d’équation différentielle ordinaire. Un aperçu
du module est fourni par la commande help. Le tableau ci-dessous présente
quelques méthodes de calcul d’intégrales disponibles dans ce module.

Calcul d’intégrales

Fonction Algorithme utilisé

quad Intégration à usage général
quad_vec Intégration à usage général de fonctions à valeurs vectorielles
dblquad Double intégration à usage général
tplquad Triple intégration à usage général
fixed_quad Intégration par quadrature de Gauss d’ordre n
romberg Intégration à l’aide de la méthode de Romberg

La démarche à utiliser pour calculer une intégrale avec integrate.quad,

par exemple, consiste en différentes étapes successives :
1. importation de numpy pour avoir la fonction sinus et le nombre π,
2. importation du sous-paquet integrate de scipy
3. appel de la fonction quad qui s’écrit selon la syntaxe
quad(fonction, borne inférieure, borne supérieure)
où
— fonction est l’intégrande qui peut être une fonction simple, une
fonction définie par def ou une fonction anonyme,
— borne inférieure est la borne inférieure de l’intégrale,
— borne supérieure est la borne supérieure de l’intégrale.
4. le résultat se présente sous la forme d’un tuple dont le premier élément
est le résultat du calcul numérique de l’intégrale.
Chapitre 7. Calcul Scientifique 171

Z π/2
Exemple 38 : Calculer sin(x) dx
0

import numpy as np
from scipy import integrate
resultat=integrate.quad(np.sin,0,np.pi/2)
type(resultat)
print(f’integrale ={resultat[0]:4.2f} ’)
Z 1
1
Exemple 39 : Calculer dx
0 1 + x2

#--- Définition de la fonction ---

def f1(x):
return 1/1+x**2
# ------------------------------
integrale=integrate.quad(f1,0,1)
print(integrale[0])

1.3333333333333333
Z 4.5
Exemple 40 : Calculer I = J2.5 (x) dx en utilisant une fonction lambda.
0

import scipy.integrate as integrate

import scipy.special as special
result = integrate.quad(lambda x:special.jv(2.5,x),0,4.5)
print(result[0])

1.1178179380783253

Equations différentielles ordinaires

SciPy fournit la fonction odeint pour la résolution des équations dif-

férentielles ordinaires (EDO). Pour l’importer :
from scipy.integrate import odeint
172 Programmation Python

Exemple 41 : Résolution numérique de l’équation différentielle du premier

ordre
dy
+ y = x avec y(0) = 1
dx
La démarche à utiliser est simple :
dy
1. définir une fonction dy_dx contenant l’expression de ,
dx
2. définir un vecteur contenant les valeurs de la variable indépendante pour
lesquels on souhaite résoudre l’équation différentielle,
3. définir un vecteur contenant les conditions initiales
4. appeler scipy.integrate.ode.int(dy_dx,y0,xs)
5. faire appel à la méthode .flatten() pour extraire les résultats sous
forme de vecteur.
import numpy as np
from scipy.integrate import odeint
# Definir une fonction qui calcule la dérivée
def dy_dx(y, x):
return x - y
xs = np.linspace(0,5,100)
y0 = 1.0 # la condition initiale
ys = odeint(dy_dx, y0, xs)
ys = np.array(ys).flatten()
print(’ x = ’,xs)
print(’y(x) = ’,ys)

3.3 Optimisation
scipy.optimize fournit des fonctions pour minimiser (ou maximiser)
des fonctions objectifs, éventuellement soumises à des contraintes. Il com-
prend des solveurs pour les problèmes non linéaires (avec prise en charge des
algorithmes d’optimisation locaux et globaux), la programmation linéaire, les
moindres carrés contraints et non linéaires, la recherche de racines et l’ajuste-
ment de courbe.
Exemple 42 : Utiliser la fonction optimize.mnimize() pour rechercher
les minima de la fonction f (x) = x2 − x − 4 au voisinage de x0 = 1.
Chapitre 7. Calcul Scientifique 173

from scipy import optimize

f=lambda x : x**2-x-4
x0=[1]
xopt=optimize.minimize(f,x0).x
print(f’minimum en x ={xopt[0]:4.2f}’)

minimum en x =0.50
La syntaxe de cette fonction est optimize.minimize(f,x0).x où
— f est la fonction dont on recherche le minimum,
— x0 la valeur du point de départ de cette recherche,
— .x est l’attribut qui contient le résultat de cette recherche,
— le résultat se présente sous la forme d’un tuple dont le premier élément
est la valeur de la variable qui minimise la fonction.
174 Programmation Python

Exercices

Exercice 1 :

1. Définir la variable x = π4 et calculer y1 = sin(x) et y2 = cos(x), puis

z = tan(x) à partir de y1 et y2 .
2. Définir la variable x = π6 , π4 , π3 et calculer y1 = sin(x) et y2 = cos(x),
 

puis z = tan(x) en utilisant exclusivement les vecteurs y1 et y2 précé-

dents.

Exercice 2 :
Construire :
1. une suite partant de -8 et allant à -5 par pas de 0.25.
2. une suite décroissante d’entiers de 15 à 3.
3. une suite de longueur 100 de −π à π.

Exercice 3 :
Définir le vecteur V = [0, 1, 2, 3 . . . 49, 50].
1. Quelle est la taille de ce vecteur ?
2. Définir le vecteur W contenant les cinq premiers éléments de V ,
3. Définir le vecteur X contenant les cinq premiers et les cinq derniers
éléments de V .
4. Définir le vecteur Z = [0, 2, 4 · · · 48, 50] à partir de V .

Exercice 4 :
Créer un vecteur qui possède les éléments : 32, 4, 81, e2.5 , 63, cos(π/3) et
14.12.
Exercice 5 :
Créer un vecteur qui possède les éléments : 55, 14, ln(51), 987, 0 et 5 sin(2.5π).
Exercice 6 :
Créer un vecteur dans lequel le premier élément est 1, le dernier élément
33 avec un incrément de 2 entre les éléments :(1, 3, 5,......,33).
Chapitre 7. Calcul Scientifique 175

Exercice 7 :
Créer un vecteur dans lequel le premier élément est 15 ; les éléments dé-
croissent avec un incrément de -5, et le dernier élément est -25.
Exercice 8 :
Créer un vecteur nommé afirst qui possède 16 éléments dans lequel
le premier est 4, l’incrément est 3 et le dernier élément est 49. Puis, en utilisant
le symbole : , créer un nouveau vecteur nommé asecond qui possède 8
éléments. Les 4 premiers éléments de ce vecteur sont les 4 premiers éléments
du vecteur afirst et les 4 derniers éléments sont les 4 derniers éléments
du vecteur afirst .
Exercice 9 :

1. Créer un vecteur de 11 coordonnées contenant les nombres -5,-4,...,4,5.

2. Créer un vecteur de 1001 coordonnées contenant les nombres -500,-
499,-498...,499,500
3. Créer un vecteur u contenant 10 valeurs entre 0 et π séparées par un
incrément constant.
4. Créer un vecteur v tel que v2i = cos (u2i ) et v2i+1 = sin (u2i+1 )

Exercice 10 :
Créer les matrices suivantes A :
   
1 2 3 −1 −2 −3
A =  0 0 1 , B =  0 0 −1  ,
1 0 0 −1 0 0

et calculer :
1. A + B,
2. A ∗ B,
3. A.B,

Exercice 11 :
 
1 2 3 4 5 6 7 8 9 10
Définir la matrice M =  11 12 13 14 15 16 17 18 19 20 
21 22 23 24 25 26 27 28 29 30
176 Programmation Python

 
1 2
1. Extraire de cette matrice la matrice N =  11 12 
21 22
 
8 9 10
2. Extraire de M la matrice P =  18 19 20 
28 29 30
 
3 7
3. Extraire de M la matrice Q = .
23 27
4. Extraire de la matrice M la matrice R obtenue en prenant dans la matrice
M une colonne sur 2.

Exercice 12 :
Utiliser la matrice représentée ci-dessous en utilisant la notation vecto-
rielle pour créer des vecteurs avec un incrément constant et/ou la commande
linspace pour remplir les lignes.
 
1 4 7 10 13 16 19 22 25
A =  72 66 60 54 48 42 36 30 24 
0 0.125 0.250 0.375 0.500 0.625 0.750 0.875 1.000

Exercice 13 :
Créer la matrice suivante A :
 
6 43 2 11 87
A =  12 6 34 0 5 
34 18 7 41 9

Utiliser la matrice A pour :

1. Créer un vecteur colonne de 5 lignes nommé va qui contient les élé-
ments de la seconde ligne de A.
2. Créer un vecteur colonne de trois éléments nommé vb qui contient les
éléments de la quatrième colonne de A.
3. Créer un vecteur colonne de 10 éléments nommé vc qui contient les
éléments de la première et de la seconde ligne de A.
4. Créer un vecteur colonne de 6 éléments nommé vd qui contient les élé-
ments de la première et de la cinquième colonne de A.
Chapitre 7. Calcul Scientifique 177

Exercice 14 :
Définir une matrice  
1 2 3
a= 4 5 6 
7 8 9
Écrire les commandes Python permettant de :
1. Supprimer la première colonne de a
2. Supprimer la première ligne de a
3. Extraire la sous-matrice obtenue par suppression de la seconde ligne et
de la seconde colonne de a.
4. Calculer la matrice transposée de a
5. Extraire les éléments de la diagonale de a.

Exercice 15 :
Définir une matrice a (3 × 3) contenant des nombres aléatoires. Écrire les
instructions Python qui permettent de réaliser les opérations suivantes :
1. Intervertir les colonnes 2 et 3 ;
2. Ajouter une quatrième colonne de zéros ;
3. Insérer, entre la seconde ligne et la troisième ligne, une ligne contenant
la valeur 1 ;
4. Supprimer la seconde colonne.

Exercice 16 :
~ les vecteurs suivants ~u = (1, −1, 2)T ,
On note ~u, ~v et w
~v = (10, −1, 3)T , w~ = (5, −1, 4)T
1. Calculer
• 3~u
• ||~u||2
• 2~u − ~v + 5w
~
• ||2~u − ~v + 5w||
~
• ||w
~ − 4~v ||
178 Programmation Python

2. Déterminer l’angle formé par les vecteurs ~u et w.

~

Exercice 17 :
Créer les matrices suivantes :
     
1 2 −1 1 2 3 2 1 1
A= 0 1 0  , B =  1 1 2  , C =  0 1 −1  ,
3 −1 2 0 1 2 4 2 2

et calculer :
1. A + 4 B · C,
2. l’inverse de chaque matrice si elle existe,
3. A3 ,
4. le déterminant de C,
5. les valeurs propres et les vecteurs propres de B.

Exercice 18 :
Résolution matricielle de systèmes linéaires. Résoudre matriciellement les
systèmes suivants. Si Python affiche un message d’erreur, dire pourquoi.

 6x + y − 5z = 10
1. 2x + 2y + 3z = 11
4x − 9y + 7z = 12


 6x + y − 5z = 10
2. 2x + 2y + 3z = 2
8x + 3y − 2z = 12



 x + 2y + 3z + 4t = 1
2x + 3y + 4z + t = −2

3.

 −2x + 4y − 5z + 2t = 0
8x + y − z + 3t = 1


Exercice 19 :
Z 4
1. Calculer w = x2 dx et comparer avec le résultat analytique.
Z 0∞
2. Calculer y = e−x dx.
0
Chapitre 7. Calcul Scientifique 179

Z 2 Z 1
3. Calculer z = xy 2 dxdy.
0 0

Exercice 20 :
Z π
1. Utiliser la commande romberg pour calculer esin x dx
0
Z 1 √
2. Utiliser la commande quad pour calculer x3 + 1 dx
0

Exercice 21 :
Utiliser la commande optimize.minimize() pour rechercher les mi-
nima des fonctions :
1. f1 (x) = x2 − 1
2
2. f2 (x, y) = 100 (x2 − x21 ) + (1 − x1 )2
180 Programmation Python

Corrigé des exercices

Corrigé exercice 1 :

import numpy as np
x=np.pi/4
y1=np.sin(x)
y2=np.cos(x)
z=y1/y2
print(f’x={x:4.2f},sin(x)={y1},cos(x)={y2},tan(x)={z}’)
print(’-’*40)
x=np.array([np.pi/6,np.pi/4,np.pi/3])
y1=np.sin(x)
y2=np.cos(x)
z=y1/y2
print(’x:\t’,x,’\n’)
print(’sin(x):\t’,y1,’\n’)
print(’cos(x):\t’,y2,’\n’)
print(’tan(x):\t’,z)

Corrigé exercice 2 :

import numpy as np
A=np.arange(-8,-4.75,0.25)
print(A)
B=np.array(range(15,2,-1))
print(B)
# ou bien
B=np.arange(15,2,-1,dtype=int)
print(B)
C=np.linspace(-np.pi,np.pi,100)
print(C)

Corrigé exercice 3 :

import numpy as np
V=np.arange(0,51,dtype=int)
print(’V=’,V)
print(’taille de V :’,np.size(V))
W=V[:5]
Chapitre 7. Calcul Scientifique 181

print(’W=’,W)
X=np.concatenate((V[:5],V[-5:]))
print(’X=’,X)
Z=V[0::2]
print(’Z=’,Z)

Corrigé exercice 4 :

import numpy as np
A=np.array([32,4,81,np.e**2.5,63,np.cos(np.pi/3),14.12])
print(A)

Corrigé exercice 5 :

import numpy as np
B=np.array([55,14,np.log(51),987,5*np.sin(2.5*np.pi)])
print(B)

Corrigé exercice 6 :

import numpy as np
C=np.arange(1,35,2,dtype=int)
print(C)

Corrigé exercice 7 :

import numpy as np
D=np.arange(15,-30,-5)
print(D)

Corrigé exercice 8 :

import numpy as np
debut=4
pas=3
fin=49
afirst=np.arange(debut,fin+pas,pas)
print(afirst)
np.size(afirst)
asecond=np.concatenate((afirst[:4],afirst[-4:]))
print(asecond)
182 Programmation Python

Corrigé exercice 9 :

import numpy as np
V1=np.linspace(-5,5,11,dtype=int)
print(V1)
V2=np.linspace(-500,500,1001,dtype=int)
print(V2)
u=np.linspace(0,np.pi,10)
print(u)
v=np.zeros(np.size(u))
print(v)
for i in range(np.size(v)):
if i%2==True :
v[i]=np.cos(u[i])
else :
v[i]=np.sin(u[i])
print(v)

Corrigé exercice 10 :

import numpy as np
A=np.array([[1,2,3],[0,0,1],[1,0,0]])
print(’A = ’,A)
B=np.array([[-1,-2,-3],[0,0,-1],[-1,0,0]])
print(’B = ’,B)
print(’A+B = ’,A+B)
print(’A*B = ’,A*B)
print(’A.B = ’,np.dot(A,B))

Corrigé exercice 11 :

import numpy as np
M =np.array([range(1,11),range(11,21),range(21,31)])
print(’M = ’,M)
N=M[:3,:2]
print(’N = ’,N)
P=M[:3,-3:]
print(’P = ’,P)
Q=M[0:3:2,2:7:4]
print(’Q = ’,Q)
Chapitre 7. Calcul Scientifique 183

R=M[:,0::2]
print(’R = ’,R)

Corrigé exercice 12 :

import numpy as np
A1=np.arange(1,26,3)
A2=np.arange(72,18,-6)
A3=np.linspace(0,1,9)
A=np.vstack((A1,A2,A3))
print(’A = ’,A)

Corrigé exercice 13 :

import numpy as np
A=np.array([
[6,43,2,11,87],
[12,6,34,0,5],
[34,18,7,41,9]])
print(’A = ’,A)
va=A[1,:].reshape(-1,1)
print(’va = ’,va)
vb=A[:,3].reshape(-1,1)
print(’vb = ’,vb)
vc=np.concatenate((A[0,:],A[1,:])).reshape(-1,1)
print(’vc = ’,vc)
vd=np.concatenate((A[:,0],A[:,4])).reshape(-1,1)
print(’vd = ’,vd)

Corrigé exercice 14 :

import numpy as np
a=np.array([[1,2,3],[4,5,6],[7,8,9]])
print(’a = ’,a)
b=np.delete(a,0,1)
print(’b = ’,b)
c=np.delete(a,0,0)
print(’c = ’,c)
d=np.delete(np.delete(a,1,0),1,1)
print(’d = ’,d)
184 Programmation Python

e=a.T
print(’e = ’,e)
diag=a.diagonal()
print(’diag = ’,diag)

Corrigé exercice 15 :

import numpy as np
a=np.random.rand(3,3)
print(’a = ’,a)
a[:,[1,2]]=a[:,[2,1]]
print(’a= ’,a)
c=np.append(a,np.zeros(shape=(3,1)),1)
print(’c = ’,c)
d=np.insert(a,2,np.ones(shape=(1,3)),0)
print(’d = ’,d)
e=np.delete(a,1,1)
print(’ e = ’,e)

Corrigé exercice 16 :

import numpy as np
u=np.array([1,-1,2])
v=np.array([10,-1,3])
w=np.array([5,-1,4])
print(’u = ’,u)
print(’v = ’,v)
print(’w = ’,w)
print(’3u = ’,3*u)
print(’u^2 = ’,np.dot(u,u))
print(’2u-v+5w = ’,2*u-v+5*w)
print(’||2u-v+5w|| = ’, np.linalg.norm(2*u-v+5*w))
cos_theta=np.dot(u,w)/np.sqrt(np.dot(u,u)*np.dot(w,w))
theta=np.arccos(cos_theta)
print(’angle(u,w) = {:5.2f} rad’.format(theta))
Chapitre 7. Calcul Scientifique 185

Corrigé exercice 17 :

import numpy as np

def invmat(x):
’’’Inversion de matrice avec code erreur’’’
try :
return np.linalg.inv(x)
except np.linalg.LinAlgError:
print(’Erreur : Matrice singulière’)

#----------Programme principal ------------

A=np.array([[1,2,-1], [0,1,0], [3,-1,2]])
print(’A = ’,A)

B=np.array([[1,2,3],[1,1,2], [0,1,2]])
print(’B = ’,B)

C=np.array([[2,1,1], [0,1,-1],[4,2,2]])
print(’C = ’,C)

D=A+4*np.dot(B, C)
print(’A+4*B.C = ’,D)

print(’invA = ’,invmat(A))
print(’invB = ’,invmat(B))
print(’invC = ’,invmat(C))

# Elément par élement

print(’A^3 =’,A**3)

#Puissance matricielle
A0=A
print(A)
for n in range(2):
A0=np.dot(A0,A)
print(’A mat ^3 =’,A0)

print(’Det(C) = ’,np.linalg.det(C))
186 Programmation Python

valp,vecp=np.linalg.eig(B)
print(’Valeurs propres : \n’,valp)
print(’Vecteurs propres : \n’,vecp)

Corrigé exercice 18 :

import numpy as np
a=np.array([[6,1,-5],[2,2,3],[4,-9,7]])
b=np.array([10,11,12])

try :
sol=np.linalg.solve(a,b)
print(’x=’,sol[0])
print(’y=’,sol[1])
print(’z=’,sol[2])
except np.linalg.LinAlgError:
print(’Erreur Matrice singulière’)

a=np.array([[6,1,-5],[2,2,3],[8,3,-2]])
b=np.array([10,2,12])
try :
sol=np.linalg.solve(a,b)
print(’x=’,sol[0])
print(’y=’,sol[1])
print(’z=’,sol[2])
except np.linalg.LinAlgError:
print(’Erreur Matrice singulière’)

a=np.array([[1,2,3,4],[2,3,4,1],[-2,4,-5,2],[8,1,-1,3]])
b=np.array([1,-2,0,1])
try :
sol=np.linalg.solve(a,b)
print(’x=’,sol[0])
print(’y=’,sol[1])
print(’z=’,sol[2])
print(’t=’,sol[3])
except np.linalg.LinAlgError:
print(’Erreur Matrice singulière’)
Chapitre 7. Calcul Scientifique 187

Corrigé exercice 19 :

import numpy as np
from scipy import integrate

x2 = lambda x: x**2
integrale,precision=integrate.quad(x2, 0, 4)
print(’w= ’,integrale)
print(’Résultat analytique : ’,4**3 / 3.)

invexp = lambda x: np.exp(-x)

y,precision=integrate.quad(invexp, 0, np.inf)
print(’y = ’,y)
print(’Précision = ’,precision)

f = lambda x,y: x*y**2

integrale=integrate.dblquad(f, 0, 2,
lambda x: 0,
lambda x: 1)
print(’z = ’,integrale[0])

Corrigé exercice 20 :

import numpy as np
from scipy import integrate
f1=lambda x :np.exp(np.sin(x))
binf=0
bsup=np.pi
result = integrate.romberg(f1, binf, bsup)
print(’Résultat = ’,result)

f2=lambda x : np.sqrt(x**3+1)
binf=0
bsup=1
result = integrate.quad(f2, binf, bsup)
print(’Résultat = ’,result[0])
188 Programmation Python

Corrigé exercice 21 :

import numpy as np
from scipy import optimize
f1=lambda x : x**2-1
x0=[1]
xopt=optimize.minimize(f1,x0).x
print(f’minimum en x ={xopt[0]:4.2f}’)

print(’-’*40)

f2=lambda x : 100.0*(x[1]-x[0]**2.0)**2.0 +(1-x[0])**2.0

x0 = [0,0]
xopt= optimize.minimize(f2, x0).x
print(f’minimum en (x={xopt[0]:4.2f},y={xopt[1]:4.2f})’)
Chapitre 8

Graphisme

Dans ce chapitre : Introduction à matplotlib pour tracer des

courbes :
— en deux dimensions
— en trois dimensions.

Travaux Dirigés:
Exercices corrigés

189
190 Programmation Python

Les résultats d’expérimentations ou de calculs se présentent sous la forme

de données numériques ou d’expressions mathématiques qui sont le plus sou-
vent difficiles à analyser sous leur forme brute. Une représentation graphique
de ces données en permet une meilleure analyse. La représentation "à la main"
de ces données peut être une tâche ardue et souvent imprécise. Le package
matplolib est une bibliothèque de Python destinée à tracer et visualiser
des données sous formes de graphiques. Elle peut être combinée avec les bi-
bliothèques python de calcul scientifique numpy et scipy.

1 Graphes à deux-dimensions

1.1 Tracé de fonction

La représentation graphique d’une fonction nécessite les trois étapes sui-
vantes :
1. Spécifier l’intervalle des valeurs de la variable : xmin ≤ x ≤ xmax ,
2. Définir la fonction à représenter : y = f (x),
3. Appeler la fonction plot(x,y) de Python pour faire le tracé.
4. Afficher la fenêtre de résultat du tracé avec show()

Remarque : L’appel de la fonction show n’est pas toujours nécessaire. Par

exemple avec Spyder, les tracés apparaissent automatiquement dans l’onglet
plot de l’interface graphique.

Exemple 1 : Tracer la fonction f (x) = x log(x + 1) sur l’intervalle [0, 4].

Pour cela, il faut :
1. Spécifier l’intervalle des valeurs de la variable 0 ≤ x ≤ 4 en définissant
le vecteur x par la commande : x=[xmin:incrément:xmax].
2. Définir la fonction à représenter y = f (x) : y=x.*log(x+1). Atten-
tion à ne pas oublier le ’.’ avant l’asterisque ’*’ !
3. Appeler la fonction Python : plot(x,y). Cette instruction graphique
ouvre une fenêtre dans laquelle sera affiché le résultat de cette com-
mande.
Le code Python ci-dessous permet d’obtenir le résultat de la figure (Fig.8.1).
Chapitre 8. Graphisme 191

import numpy as np
import matplotlib.pyplot as plt
#-------------xlogx+1-----------------------
x=np.arange(0,4,0.1)
y=x*np.log(1+x)
plt.plot(x,y)
plt.show()

0
0 1 2 3 4

Figure 8.1 – Graphe de y = x log(x + 1).

Remarque : La variable x contient le vecteur des valeurs pour lesquelles la

fonction est évaluée.

Remarque : Le choix d’un petit incrément permet d’obtenir une courbe plus
"lisse". Néanmoins pour un bon rendu il n’est pas nécessaire de choisir un
incrément très petit.

Exemple 2 : Amélioration de la lisibilité de la figure en ajoutant

— un quadrillage avec : grid(True)

— un titre :
title(’Représentation de la fonction y=xlog(x+1)’)
— des légendes sur les axes : xlabel(’x’);ylabel(’y’)
192 Programmation Python

import numpy as np
import matplotlib.pyplot as plt
plt.clf()
#-------------xlogx+1-----------------------
x=np.arange(0,4,0.1)
y=x*np.log(1+x)
plt.plot(x,y)
plt.grid(True)
plt.xlabel(’x’)
plt.ylabel(’y’)
plt.title(’Représentation de y=x*log(x+1)’)
plt.show()

Représentation de y=x*log(x+1)

4
y

0
0 1 2 3 4
x

Figure 8.2 – Graphe de y = x log(x + 1) avec quadrillage et

légendes.
On peut aussi choisir le style et la police des caractères. Python attribue
par défaut une couleur et un style de ligne aux courbes. Le changement se fait
par :
plt.plot(x,y,’:k’)
Le signe ’:’ indique que la courbe est représentée par une ligne discontinue,
tandis que 0 k 0 signifie que la ligne est de couleur noire (black).
Chapitre 8. Graphisme 193

Les styles de ligne, couleur et marqueur sont donnés dans les tableaux ci-
dessous.
Symbole Couleur
r rouge Symbole Marqueur
g vert + signe +
b bleu o cercle
c cyan * étoile
m magenta . point
y jaune x marque ×
k noir s carré
w white d losange
Styles de couleur ^ triangle(haut)
v triangle(bas)
Symbole Ligne
> triangle(droit)
− trait plein
< triangle (gauche)
−− pointillé long
p pentagone
: pointillé court
h hexagone
−. pointillé mixte
Styles de marqueur
Styles de ligne

1.2 Superposition de plusieurs fonctions

On peut également tracer plusieurs fonctions sur le même graphe.
Exemple 3 : Tracer les fonction y = x ∗ log (x + 1) et y = 5e−0.2x cos2 x.

import numpy as np
import matplotlib.pyplot as plt
plt.clf()
#---------------------------------
x1=np.arange(0,4,0.1)
y1=x1*np.log(x1+1)
#---------------------------------
x2=np.arange(0,10,0.1)
y2=5*np.exp(-0.2*x2)*np.cos(2*x2)**2
#---------------------------------
plt.plot(x1,y1,’b-’,x2,y2,’r-’)
plt.grid(True)
plt.xlabel(’x’)
194 Programmation Python

plt.ylabel(’y’)
plt.show()

4
y

0
0 2 4 6 8 10
x

Figure 8.3 – Représentation de deux fonctions sur un même

graphe.

Exemple 4 : Utiliser la commande legend([’chaine1’, ’chaine2)]

pour afficher sous forme d’étiquette les définitions des fonctions.
import numpy as np
import matplotlib.pyplot as plt
plt.clf()
#---------------------------------
x1=np.arange(0,4*np.pi,0.1)
y1=np.sin(x1)
#---------------------------------
x2=np.arange(0,4*np.pi,0.1)
y2=np.cos(x2)
#---------------------------------
plt.plot(x1,y1,x2,y2,)
plt.grid(True)
plt.xlabel(’x’)
plt.ylabel(’y’)
plt.legend([’sin(x)’, ’cos(x)’])
plt.show()
Chapitre 8. Graphisme 195

0.5

0
y

−0.5
sin(x)
cos(x)
−1
0 2 4 6 8 10 12
x

Figure 8.4 – Graphe de y1 = sin x et y2 = cos x.

La commande Python axis([xmin xmax ymin ymax]) permet d’af-
ficher la portion de courbe désirée. Par exemple si on veut représenter la courbe
précédente dans le cadre défini par 0 ≤ x ≤ 2π et −1 ≤ y ≤ 1, il suffit
d’écrire :
plt.axis([0,2*np.pi,-1,1])

0.5

0
y

−0.5
sin(x)
cos(x)
−1
0 1 2 3 4 5 6
x

Figure 8.5 – Résultat la commande axis()

196 Programmation Python

2 Autres types de graphes

La commande plot permet aussi de représenter graphiquement :

— des fonctions paramétrées,

— des courbes en coordonnées polaires,
— des courbes en échelle semi-logarithmique ou log-log,
— des histogrammes,
— ...

2.1 Courbes paramétrées

Exemple 5 : Deux variables x et y, dépendant d’une variable θ

On définit x = cos(θ), y = sin(θ). On souhaite faire la représentation

graphique de y en fonction de x pour 0 ≤ θ ≤ π. Les commandes suivantes
permettent d’obtenir le résultat de la figure (Fig.8.6).

import numpy as np
import matplotlib.pyplot as plt
#---------------------------------------------
plt.clf()
theta=np.arange(0,np.pi,0.01)
x=np.cos(theta)
y=np.sin(theta)
plt.plot(x,y)
plt.grid(True)
plt.axis(’equal’)
plt.axis([-1,1,0,1])
plt.xlabel(r’x=cos($\theta$)’)
plt.ylabel(r’y=sin($\theta$)’)
plt.title(’Courbe paramétrée’)
plt.show()
Chapitre 8. Graphisme 197

Courbe paramétrée
1.2
1.0
0.8
y=sin(θ)

0.6
0.4
0.2
0.0
-0.2
−1 −0.5 0 0.5 1
x=cos(θ)

Figure 8.6 – Courbe paramétrée : x = cos θ, y = sin θ, 0 ≤ θ ≤

π.

2.2 Tracé en coordonnées polaires

Les tracés en coordonnées polaires (r, θ) sont obtenus à l’aide de la com-

mande polar().

Exemple 6 : Tracer la spirale d’Archimède définie par r = aθ où a = 2.

import numpy as np
import matplotlib.pyplot as plt
#---------------------------------------------
plt.clf()
a=2
theta =np.arange(0,2*np.pi,np.pi/90)
rho = a*theta
plt.polar(theta,rho)
plt.title(r"Spirale d’Archimède : $\rho=2~ \theta$")
plt.show()
198 Programmation Python

Figure 8.7 – Graphe de la spirale d’Archimède en coordonnées

polaires.

2.3 Tracé en échelle semi-logarithmique ou log-log

Exemple 7 : Pour tracer en échelle semi-logarithmique la fonction

g(ω) = r 1 , on utilise le programme suivant :
2
1+ ω2
ω0

import numpy as np
import matplotlib.pyplot as plt
#--------------------------------------------
plt.clf()
#--------------------------------------------
w0=1
w=np.arange(0,100,0.1)
g=1/np.sqrt(1+(w/w0)**2)
plt.semilogx(w,g)
plt.grid(True)
plt.xlabel(r’$\omega/\omega_0$’)
plt.ylabel(r’g($\omega$)’)
plt.show()
Chapitre 8. Graphisme 199

1.0

0.8

g(ω) 0.6

0.4

0.2

0.0
10−1 100 101 102
ω/ω0

Figure 8.8 – Représentation en échelle semi-logarithmique.

Parfois on souhaite une représentation en échelle log-log ; la commande

loglog() permet d’obtenir ce type de représentation.

Exemple 8 : Représentation en échelle log-log

import numpy as np
import matplotlib.pyplot as plt
#--------------------------------------------
plt.clf()
#--------------------------------------------
w0=1;
w=np.arange(0,100,0.1) #[0:0.1:100];
g=1/np.sqrt(1+(w/w0)**2);
plt.loglog(w,g)
plt.grid(True)
plt.xlabel(r’$\omega/\omega_0$’),
plt.ylabel(r’g($\omega$)’)
plt.show()
200 Programmation Python

100

g(ω)
10−1

10−2
10−1 100 101 102
ω/ω0

Figure 8.9 – Représentation de g(ω) en échelle logarithmique.

2.4 Remplissage
Pour colorier une surface fermée, on peut utiliser la commande :
fill_between.
Cette instruction peut être utilisée, par exemple, pour mettre en évidence
certaines parties d’une courbe comme illustré dans l’exemple ci-dessous.
Exemple 9 : Colorier l’espace correspondant aux valeurs sin(x) > 0.5

import matplotlib.pyplot as plt

import numpy as np
#-----------------------------------
plt.clf()
#-----------------------------------
x = np.arange(0,4*np.pi,0.01)
y = np.sin(x)
niveau = 0.5
y2=niveau*np.ones(np.size(x))
plt.plot(x,y,x,y2,’:’)
plt.grid(True)
plt.fill_between(x,y,y2,where=y>=niveau)
plt.show()
Chapitre 8. Graphisme 201

0.5

−0.5

−1
0 2 4 6 8 10 12

Figure 8.10 – Exemple d’utilisation de la commande

fill_between

2.5 Cas des données discrètes

Souvent les graphes à tracer correspondent à des résultats expérimentaux
ou des calculs numériques se présentant sous la formes de deux listes de va-
leurs numériques discrètes. Ces valeurs doivent être rangées dans deux vec-
teurs x et y de même dimension. La commande plot(x,y) permet d’obtenir
un graphe de y en fonction de x.
Exemple 10 :
Considérons le vecteur x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] auquel correspond le
vecteur y = [0, 3, 8, 15, 24, 35, 48, 63, 80, 99]. Le programme suivant permet
d’obtenir un graphe de y en fonction de x. L’option ’-+’ permet d’obtenir
des ’+’ reliés par un trait continu (Fig. 2.5).
import numpy as np
import matplotlib.pyplot as plt
plt.clf()
x=[1,2,3,4,5,6,7,8,9,10]
y=[0,3,8,15,24,35,48,63,80,99];
plt.plot(x,y,’-+’)
plt.xlabel(’x’)
plt.ylabel(’y’)
202 Programmation Python

plt.grid(True)
plt.show()

100

80

60
y

40

20

0
2 4 6 8 10
x

Exemple 11 : Variation de y en fonction de x avec la commande bar()

plt.bar(x,y)

100

80

60
y

40

20

0
2 4 6 8 10
x
Chapitre 8. Graphisme 203

Exemple 12 : Variation de y en fonction de x avec la commande stem()

plt.stem(x,y,use_line_collection=True)

100

80

60
y

40

20

0
2 4 6 8 10
x

2.6 La commande subplot

L’instruction subplot(n1 , n2 , n) permet d’obtenir plusieurs graphes sur
une seule figure qui se présente comme un tableau contenant n1 graphes sur la
ligne et n2 graphes sur la colonne.Le nombre n indique le numéro du graphe ;
les graphes sont numérotés de la gauche vers la droite et du haut vers le bas.
Exemple 13 : Tracer 4 graphes sur 2 lignes et 2 colonnes (Fig.8.11).

import numpy as np
import matplotlib.pyplot as plt
#-----------------------------------
plt.clf()
#-----------------------------------
x=np.arange(0,5,0.1)
y=x**2
plt.subplot(221)
plt.plot(x,y)
plt.xlabel(’x’)
plt.ylabel(r’$y=x^2$’)
204 Programmation Python

#------------------------------------
x=np.arange(0,5*np.pi,np.pi/10)#0:pi/10:5 * pi;
y=np.cos(x)
plt.subplot(222)
plt.plot(x,y)
plt.xlabel(’x’)
plt.ylabel(’y=cos(x)’)
plt.axis([0, 5*np.pi, -1, 1])
#-----------------------------------
x=np.arange(0,4*np.pi,np.pi/10)#0:pi/10:4 * pi;
y=np.sin(x)
plt.subplot(223)
plt.plot(x,y)
plt.xlabel(’x’)
plt.ylabel(’y=sin(x)’)
plt.axis([0, 4*np.pi, -1, 1])
#------------------------------------
x=np.arange(0,10,0.1)#0:0.1:10;
y=np.sqrt(1+x**2)
plt.subplot(224)
plt.plot(x,y)
plt.xlabel(’x’)
plt.ylabel(’y’)
plt.ylabel(r’y=$\sqrt{1+x^2}$’)
plt.axis([0, 10, 1, 10])
plt.show()

Figure 8.11 – Plusieurs graphes avec subplot()

Chapitre 8. Graphisme 205

3 Graphes 3D

Python peut générer des graphes plus sophistiqués :

— graphes de contour,
— graphes en 3D sous formes de surfaces,
— etc...

3.1 Courbes paramétrées

La fonction Axes3D avec plot permet la représentation en trois dimen-

sions de trois fonctions dépendant d’un paramètre unique.

Exemple 14 : Tracer une fonction hélicoïdale circulaire définie par


 x = cos(ωt)
y = sin(ωt)
z = αt

On peut utiliser le programme suivant pour obtenir le résultat de la Figure .8.12 :

from mpl_toolkits.mplot3d import Axes3D

import numpy as np
import matplotlib.pyplot as plt

fig = plt.figure()
ax = fig.gca(projection=’3d’)
theta = np.linspace(-2 * np.pi, 2 * np.pi, 1000)
x = np.cos(2*theta)
y = np.sin(2*theta)
z=0.5*theta
ax.plot(x, y, z, label=’3D Courbe paramétrique’)
ax.legend()
plt.xticks(np.arange(-1,1.5,0.5))
plt.yticks(np.arange(-1,1.5,0.5))
plt.show()
206 Programmation Python

Figure 8.12 – Tracé d’une hélice

3.2 Contour
Le type contour représente les lignes de contour (ou de niveau) d’une fonc-
tion de deux variables. Par exemple, soit z une fonction de deux variables x
et y définie par z = f (x, y). La première étape consiste à générer le maillage
du plan (x, y) dans un domaine donné, avec un incrément donné. La seconde
étape consiste à définir la fonction z = f (x, y).Il faut ensuite appeler la com-
mande contour(X,Y,Z).
Exemple 15 :
Supposons que nous désirions représenter une fonction quelconque z =
f (x, y) dans le domaine −5 ≤ x ≤ 5 et −3 ≤ y ≤ 3 avec le même incrément
égal à 0.1. Le maillage du plan (x, y) est réalisé à l’aide de la commande de
numpy meshgrid().
import numpy as np
import matplotlib.pyplot as plt
plt.clf()

def f(x,y) :
return x*np.exp(-x**2-y**2)
Chapitre 8. Graphisme 207

x=np.arange(-2,2,0.01)
y=np.arange(-2,2,0.01)
X,Y=np.meshgrid(x,y)
Z=f(X,Y)
cplot=plt.contour(X,Y,Z)
plt.clabel(cplot, inline=1, fontsize=10)
plt.show()

0.000
1
50
.1
-0
-0.30

0.150
0
0

0
30
0.
−1

−2
−2 −1 0 1
2 −y 2
Figure 8.13 – Tracé de contour de z = xe−x

3.3 Surfaces
Une fonction z = f (x, y) peut également être représentée sous forme de
surface. Par exemple la commande Axes3D permet d’obtenir une surface de
z maillée aux nœuds [x, y].
Exemple 16 :

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
fig=plt.figure()
ax=Axes3D(fig)
x=np.arange(-2,2,0.2)
208 Programmation Python

y=np.arange(-2,2,0.2)
X, Y=np.meshgrid(x,y)
Z=X*np.exp(-X**2-Y**2)
ax.plot_surface(X,Y,Z,rstride=1,cstride=1,cmap=’hot’)
plt.show()

Figure 8.14 – Figures avec Axes3D

4 Gestion des fenêtres graphiques

4.1 Ouverture-fermeture
Une instruction graphique ouvre une fenêtre dans laquelle est affiché le ré-
sultat de cette commande. Par défaut, une nouvelle instruction graphique sera
affichée dans la même fenêtre et écrasera la figure précédente. On peut ouvrir
une nouvelle fenêtre graphique par la commande figure. Chaque fenêtre se
voit affecter un numéro n. Ce numéro est visible dans le bandeau de la fenêtre
sous forme d’un titre. Le résultat d’une instruction graphique est par défaut
Chapitre 8. Graphisme 209

affiché dans la dernière fenêtre graphique ouverte qui est la fenêtre graphique
active. On rend active une fenêtre graphique précédemment ouverte en exé-
cutant la commande figure(n), où n désigne le numéro de la figure. La
commande clf(n) permet de fermer la fenêtre graphique de numéro n où n
désigne le numéro de la figure. Il est également possible de fermer toutes les
fenêtres graphiques en tapant clf( ).

4.2 Sauvegarde
Pour sauvegarder une figure en mode GUI, il faut cliquer sur l’icône repré-
sentant une disquette puis choisir le nom du fichier et le format de sauvegarde.
Cette sauvegarde peut être exécutée directement à partir d’un terminal. La
syntaxe est plt.savefig(’nomfichier.format’) où format repré-
sente le format d’impression et nomfichier le nom du fichier de sauvegarde,
par exemple :
— plt.savefig(’dessin.png’) : enregistre le graphique en .png
dans un fichier dessin.png qui peut être visualisé en utilisant un vision-
neur d’image
— plt.savefig(’dessin.ps’) : enregistre le graphique dans un
fichier dessin.ps
— plt.savefig(’dessin.pdf’) : enregistre le graphique dans le
fichier dessin.pdf
— plt.savefig(’dessin.svi’) : enregistre le graphique dans le
fichier dessin.svi
Ces fichiers pourront par la suite être soit imprimés soit inclus dans un docu-
ment de traitement de texte, mais ils ne pourront pas être modifiés à partir de
Python .

4.3 Sauvegarde et modificationd’une figure

Pour modifier une figure à partir de Python , il faut utiliser le module
pickle. Dans l’exemple ci-dessous, le programme sauvegarde une figure
avec le module pickle avant de la charger à nouveau et l’afficher.
210 Programmation Python

Exemple 17 :

import matplotlib.pyplot as plt

import numpy as np
import pickle

# Tracé graphique
fig_object = plt.figure()
x = np.linspace(0,3*np.pi)
y = np.sin(x)
plt.plot(x,y)
Pour la sauvegarde dans un fichier :
pickle.dump(fig_object,open(’sinus.pickle’,’wb’))
Pour ouvrir ce fichier et afficher le graphe :
ax = pickle.load(open(’sinus.pickle’,’rb’))
plt.show()
Chapitre 8. Graphisme 211

Exercices

Exercice 1 :
Tracer le graphe des fonctions suivantes sur des figures différentes :
1. y = 3x3 + 2x2 − 5 pour −4 ≤ x ≤ 4
2
2. y = e−x pour −5 ≤ x ≤ 5
3. y = x ln (x2 + 1) pour x ∈ [0, 10]

Exercice 2 :
Tracer le graphe des fonctions suivantes sous la forme de 4 graphes sur la
même figure.
x
1. f (x) = pour x ∈ [−2, 2],
1 + x2
2. y = x3 + 3x2 − 3x − 1 pour x ∈ [−3, 4],
3. y = cos (x2 ) − sin (ex ) pour x ∈ [0.5, 2.5],
4. f (x) = ex − x3 − 1 pour x ∈ [−1.5, 5].

Exercice 3 :
Soit f et g les fonctions définies sur l’intervalle [0, 10] par
x
f (x) = e−x/25 et g(x) = cos
10
Tracer ces deux fonctions :
— d’abord dans une même fenêtre mais sur des graphes différents,
— puis dans une même fenêtre et sur le même graphe.

Exercice 4 :
Tracer les courbes suivantes sous la forme de 4 graphes sur une seule figure
(quand 2 courbes sont indiquées, les superposer sur le même graphe)
√ 1
1. y = x2 − x et y = x − pour x ∈ [1, 3]
x
2. y = sin (sin (x)) pour x ∈ [0, 2π]
3. y = J0 (x) et y = J1 (x) (J0 et J1 sont les fonctions de Bessel de première
espèce) pour x ∈ [0, 10π]
212 Programmation Python

π


sin x + 4
hπ i
4. y = J0 (x) et y = √ pour x ∈ , 10π
x 4
Exercice 5 :
Pour x ∈ [−2, 2], tracer la courbe de la fonction suivante :

 1 + x x ∈ [−1, 0]
y= 1 − x x ∈ [0, 1]
0

ailleurs

Exercice 6 :
Tracer la courbe paramétrée définie dans le plan xOy par :

x = t2 − 3t
pour − 4 ≤ t ≤ 4
y = t3 − 9t

Exercice 7 :
Tracer sur la même figure mais sur trois graphes différents les fonctions
suivantes définies en coordonnées polaires par :
1. r = 1 + e cos θ
1
2. r =
1 + e cos θ
3. r = sin (2θ) cos (2θ)
On prendra e = 0.5
Exercice 8 :
Afficher la surface définie par la fonction suivante :

 −3 ≤ x ≤ 3
z = 4x2 ey − 2x4 − e−4y pour et
−1 ≤ y ≤ 1


Exercice 9 :
Afficher la surface définie par :

z = sin(x) cos(y) pour x ∈ [0, 1] et y ∈ [2, 5]

Chapitre 8. Graphisme 213

Exercice 10 :

1. Utiliser la commande randn() pour tirer 100 couples de points (x, y)

aléatoirement dans le carré [0, 1] × [0, 1].
2. Représenter le nuage de points obtenus dans une fenêtre graphique.
3. Calculer le centre de gravité G du nuage de points et l’ajouter, en rouge,
sur la figure.
214 Programmation Python

Corrigé des exercices

Corrigé exercice 1 :

import numpy as np
import matplotlib.pyplot as plt
#-----------------------------------------
plt.clf()
#-----------------------------------------

def f1(x):
return 3*x**3+2*x**2-5

def f2(x):
return np.exp(-x**2)

def f3(x):
return x*np.log(x**2+1)
#1.---------------------------------------
fig1=plt.figure(1)
x=np.arange(-4,4,0.01)
plt.plot(x,f1(x))
plt.xlim([-4,4])
plt.grid(True)
plt.xlabel(’x’)
plt.ylabel(r’$y=3x^3+2x^2-5$’)
plt.show()
#2.----------------------------
fig2=plt.figure(2)
x=np.arange(-5,5,0.01)
plt.plot(x,f2(x))
plt.xlim([-5,5])
plt.grid(True)
plt.xlabel(’x’)
plt.ylabel(r’$y=e^{-x^2}$’)
plt.show()
#3.--------------------------
fig3=plt.figure(3)
x=np.arange(0,10,0.01)
Chapitre 8. Graphisme 215

plt.plot(x,f3(x))
plt.xlim([0,10])
plt.grid(True)
plt.xlabel(’x’)
plt.ylabel(r’$y=x~\ln(x^2+1)$’)
plt.show()

Corrigé exercice 2 :

import numpy as np
import matplotlib.pyplot as plt
#-----------------------------------------
plt.close()
#-----------------------------------------

def f1(x):
return x/(1+x**2)

def f2(x):
return x**3+3*x**2-3*x-1

def f3(x):
return np.cos(x**2)-np.sin(np.exp(x))

def f4(x):
return np.exp(x)-x**3-1
#1.---------------------------------------
x=np.arange(-2,2,0.01)
plt.subplot(221)
plt.plot(x,f1(x),’k’)
plt.xlim([-2,2])
plt.grid(True)
plt.xlabel(’x’)
plt.ylabel(r’$y=x/(1+x^2)$’)
#2.----------------------------
x=np.arange(-3,4,0.01)
plt.subplot(222)
plt.plot(x,f2(x),’b’)
plt.xlim([-3,4])
plt.grid(True)
216 Programmation Python

plt.xlabel(’x’)
plt.ylabel(r’$y=x^3+3x^2-3x-1$’)
#3.--------------------------
x=np.arange(-0.5,2.5,0.01)
plt.subplot(223)
plt.plot(x,f3(x),’r’)
plt.xlim([-0.5,2.5])
plt.grid(True)
plt.xlabel(’x’)
plt.ylabel(r’$y=\cos(x^2)-\sin(e^x)$’)
#4. -----------------------------
x=np.arange(-1.5,5,0.01)
plt.subplot(224)
plt.plot(x,f4(x),’c’)
plt.xlim([-1.5,5])
plt.grid(True)
plt.xlabel(’x’)
plt.ylabel(r’$y=e^x-x^3-1$’)

plt.show()

Corrigé exercice 3 :

import numpy as np
import matplotlib.pyplot as plt
#--------------------------------
plt.close()
#--------------------------------

def f(x):
return np.exp(-x/25)

def g(x):
return np.cos(x/10)

#-----------------------------
x=np.arange(0,10,0.01)
#------------f----------------
fig1=plt.figure(1)
plt.subplot(121)
Chapitre 8. Graphisme 217

plt.plot(x,f(x))
plt.xlim([0,10])
plt.grid(True)
plt.xlabel(’x’)
plt.ylabel(’f(x)’)
plt.title(r’$f(x)=e^{-x/25}$’)
#------------g--------------
plt.subplot(122)
plt.plot(x,g(x))
plt.xlim([0,10])
plt.grid(True)
plt.xlabel(’x’)
plt.ylabel(’g(x)’)
plt.title(r’$g(x)=\cos(x/10)$’)
#------------f et g--------------
fig2=plt.figure(2)
plt.plot(x,f(x),x,g(x))
plt.xlim([0,10])
plt.grid(True)
plt.xlabel(’x’)
plt.ylabel(r’$f(x),~g(x)$’)
plt.legend([r’$f(x)=e^{-x/25}$’,r’$g(x)=\cos(x/10)$’])
#---------------------------------

plt.show()

Corrigé exercice 4 :

import numpy as np
import matplotlib.pyplot as plt

plt.close()
#1. ----------------------------------
x=np.linspace(1,3,100)
f1=lambda x : np.sqrt(x**2-x)
f2= lambda x : x-1/x
plt.subplot(221)
plt.plot(x,f1(x),x,f2(x))
plt.legend([’$\sqrt{x^2-x}$’,’$x-1/x$’])
#2.------------------------------------
218 Programmation Python

x=np.linspace(0,2*np.pi,100)
g=lambda x : np.sin(np.sin(x))
plt.subplot(222)
plt.plot(x,g(x))
plt.legend([’$\sin(\sin(x))$’])
#3.------------------------------------
from scipy import special as sp
x=np.linspace(1,10*np.pi,100)
h1=lambda x : sp.j0(x)
h2= lambda x : sp.j1(x)
plt.subplot(223)
plt.plot(x,h1(x),x,h2(x))
plt.legend([’$J_0(x)$’,’$J_1(x)$’])
#4--------------------------------------
from scipy import special as sp
x=np.linspace(np.pi/4,10*np.pi,100)
h1=lambda x : sp.j0(x)
h3= lambda x : np.sin(x+np.pi/4)/np.sqrt(x)
plt.subplot(224)
plt.plot(x,h1(x),x,h3(x))
plt.legend([’$J_0(x)$’,r’$\frac{\sin(x+\pi/4)}
{\sqrt{x}}$’])

plt.show()

Corrigé exercice 5 :

#---------Corrigé exo 5 graphiques ----------

import numpy as np
from matplotlib import pyplot as plt
#------------------------------------------
plt.close()
#------------------------------------------
def f(x):
if (x >=-1) & (x<=0) :
return 1-x
elif (x<=1) & (x>=0) :
return 1+x
else :
return 0
Chapitre 8. Graphisme 219

#-------------------------------------------
x=np.linspace(-2,2,100)

y = []
for i in range(len(x)):
y.append(f(x[i]))
#------------------------------------------
plt.plot(x,y)
plt.xlim([-2,2])
plt.ylim([0,2])
plt.xlabel(’x’)
plt.ylabel(’f(x)’)
plt.show()

Corrigé exercice 6 :

import numpy as np
from matplotlib import pyplot as plt

plt.close()

t=np.linspace(-4,4,1000)
plt.plot(t**2-3*t,t**3-9*t)
plt.xlabel(’$x=t^2-3t$’)
plt.ylabel(’$y=t^3-9t$’)
plt.title(r"Courbe paramétrique x(t),y(t)
pour $-4< t< 4$")
plt.show()

Corrigé exercice 7 :

from numpy import sin,cos,pi,linspace,abs

import matplotlib.pyplot as plt

plt.close()

f1=lambda x,e=0.5 : 1+e*cos(x)

f2=lambda x,e=0.5 :1/f1(x,e)
f3=lambda x : sin(2*x)*cos(2*x)
220 Programmation Python

theta=linspace(0,2*pi,1000)
ax=plt.subplot(131,projection=’polar’)
ax.plot(theta,f1(theta))
ax.set_xlabel(r’$r=1+cos\theta$’)
ax.set_rticks([0,0.5,1,1.5,2])
#--------------------------------------
ax=plt.subplot(132,projection=’polar’)
ax.plot(theta,f2(theta))
ax.set_xlabel(r’$r=1/(1+cos\theta)$’)
ax.set_rticks([0,0.5,1,1.5,2])
#-------------------------------------
ax=plt.subplot(133,projection=’polar’)
ax.plot(theta,abs(f3(theta)))
ax.set_xlabel(r’$r=|sin(2\theta)cos(2\theta)|$’)
ax.set_rticks([0,0.25,0.5])

plt.show()

Corrigé exercice 8 :

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

fig=plt.figure()
ax=Axes3D(fig)
x=np.arange(-3,3,0.1)
y=np.arange(-1,2,0.1)
X, Y=np.meshgrid(x,y)
Z=4*X**2*np.exp(Y)-2*X**4-np.exp(-4*Y)
ax.plot_surface(X,Y,Z,rstride=1,cstride=1,cmap=’hot’)
ax.set_xlabel(’x’)
ax.set_ylabel(’y’)
ax.set_title(r’$z=4x^2~e^y-2x^4-e^{-4y}$’)
plt.show()
Chapitre 8. Graphisme 221

Corrigé exercice 9 :

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

fig=plt.figure()
ax=Axes3D(fig)
x=np.arange(0,1,0.1)
y=np.arange(2,5,0.1)
X, Y=np.meshgrid(x,y)
Z=np.sin(X)*np.cos(Y)
ax.plot_surface(X,Y,Z,rstride=1,cstride=1,cmap=’hot’)
ax.set_xlabel(’x’)
ax.set_ylabel(’y’)
ax.set_title(r’$z=\sin(x)\cos(y)$’)
plt.show()

Corrigé exercice 10 :

import numpy as np
import matplotlib.pyplot as plt
xy=np.random.uniform(0, 0.2, size=(2,100))
x=xy[0,:]
y=xy[1,:]
plt.plot(x,y,’.k’)
xg=x.mean()
yg=y.mean()
plt.plot(xg,yg,’or’)
s=’G’
plt.text(xg,1.05*yg,’G’,fontsize=12,c=’red’,
horizontalalignment=’center’)
plt.xlabel(’x’)
plt.ylabel(’y’)
plt.show()
Chapitre 9

Calcul symbolique

Dans ce chapitre :
— Calcul symbolique
— Dérivation
— Integration
— Résolution d’équations
— Transformations intégrales
— Graphes

Travaux Dirigés:
Exercices corrigés

223
224 Programmation Python

Certains logiciels offrent des outils destinés à manipuler les expressions

mathématiques en tant que telles, pour faire des opérations mathématiques
analytiques comme la dérivation, l’intégration ou autres. Bien qu’il ne soit
pas dédiés à cette tâche, comme Maple par exemple, Python possède un outil
puissant pour le calcul symbolique qui est Sympy.

1 Introduction
Sympy incorpore le calcul symbolique dans l’environnement numérique
de Python . Ce module contient plus de 100 fonctions qui donnent accès au
calcul symbolique en utilisant une syntaxe et un style qui sont des extensions
naturelles du langage Python . La boîte à outils Sympy fournit les facilités
numériques et graphiques de Python avec plusieurs autres types de calcul
mathématiques.
Le paquet de calcul symbolique définit un nouveau type de variable Python
appelé objet symbolique. Un objet symbolique est une structure de données qui
enregistre une représentation du symbole sous la forme d’une chaîne.
La boîte à outils utilise des objets symboliques pour représenter

— des variables symboliques,

— des expressions symboliques,
— des matrices symboliques.

2 Les bases du calcul symbolique

Pour ce chapitre, la démonstration des différentes commandes se fait dans
l’environnement ipython qui permet de voir de façon instantanée les résul-
tats, comme lors des premiers chapitres de ce livre. Commençons par importer
les modules dont nous avons besoin :
In [1]: import math

In [2]: import sympy

Chapitre 9. Calcul symbolique 225

2.1 Objets symboliques

L’exemple suivant illustre la différence entre des types de variable standard
de Python et l’objet symbolique correspondant.
La commande Python :
In [3]: math.sqrt(2)
renvoie le nombre suivant en virgule flottante :
Out[3]: 1.4142135623730951
Si on utilise la commande :
In [4]: sympy.sqrt(2)
le résultat est
Out[4]: sqrt(2)
Le résultat sqrt(2) signifie 21/2 , en utilisant la notation de calcul sym-
bolique pour la racine carrée, sans calculer sa valeur numérique.
Exemple 1 : Valeur d’un objet symbolique
On peut obtenir la valeur numérique d’un objet à l’aide de la commande
sympy.N.
In [5]: sympy.N(sympy.sqrt(2))
Out[5]: 1.41421356237310

Exemple 2 : Créer une fraction utilisant sympy.Rational(,)

In [13]: sympy.Rational(6,5)
Out[13]: 6/5

Exemple 3 : Calculs sur les objets symboliques

Python ne fait pas les calculs de la même manière sur les variables de
type float et les objets symboliques.

Variables float
In [15]: 2/5+1/3
Out[15]: 0.7333333333333334
Objets symboliques
In [16]: sympy.Rational(2,5)+sympy.Rational(1,3)
Out[16]: 11/15
226 Programmation Python

2.2 Expressions symboliques

Toute variable ou expression mathématique impliquée dans un calcul sym-
bolique doit être déclarée au préalable par l’instruction symbols. Pour faire
des opérations de calcul symbolique (différentiation, intégration, substitution,
...) sur des expressions symboliques, on doit explicitement créer les variables
symboliques.
Exemple 4 : Créer la fonction quadratique f = ax2 + bx + c
Il faut créer tous les objets symboliques qui la constituent
In [3]: a,b,c,x=sympy.symbols(’a b c x’)

In [4]: f=a*x**2+b*x+c
Ensuite on peut manipuler cette expression symbolique
In [5]: f1=x**3*f

In [6]: f1
Out[6]: x**3*(a*x**2 + b*x + c)

In [7]: f2=sympy.expand(f1)

In [8]: f2
Out[8]: a*x**5 + b*x**4 + c*x**3

In [9]: f3=sympy.factor(f2)

In [10]: f3
Out[10]: x**3*(a*x**2 + b*x + c)

3 Calcul symbolique

3.1 Simplification d’expressions

La fonction simplify permet de simplifier une expression symbolique.
Chapitre 9. Calcul symbolique 227

√
Exemple 5 : Simplifier φ2 − φ − 1 avec φ = (1 + 5)/2

In [11]: phi=(1+sympy.sqrt(5))/2

In [12]: f=phi**2-phi-1

In [13]: f
Out[13]: -3/2 - sqrt(5)/2 + (1/2 + sqrt(5)/2)**2

In [14]: sympy.simplify(f)
Out[14]: 0

x2 + 5x + 6
Exemple 6 : Simplifier :
x+2

In [15]: sympy.simplify((x**2+5*x+6)/(x+2))
Out[15]: x + 3

Exemple 7 : Simplifier sin x sin 2x + cos x cos 2x :

In [16]: sympy.simplify(sympy.sin(x)*sympy.sin(2*x)+
...:sympy.cos(x)*sympy.cos(2*x))
Out[16]: cos(x)

i e(−ix) i e(ix)
Exemple 8 : Simplifier −
2 2

In [17]: sympy.simplify((sympy.exp(-x*sympy.I)
...:sympy.I)/2-(sympy.exp(x*sympy.I)*sympy.I)/2)
Out[17]: sin(x)

√
Exemple 9 : Simplifier 16 :

In [19]: sympy.simplify(sympy.sqrt(16))
Out[19]: 4
228 Programmation Python

3.2 Développement d’expressions

expand permet de développer une expression symbolique
Exemple 10 : Développement de expression polynomiale :
f = (x2 − 1)(x4 + x3 + x2 + x + 1)(x4 − x3 + x2 − x + 1)
x=sympy.symbols(’x’)

In [21]: f = (x**2-1)*(x**4+x**3+x**2+x+1)* \
...:(x**4-x**3+x**2-x+1)

In [22]: sympy.expand(f)
Out[22]: x**10 - 1

Exemple 11 : Développement d’une expression trigonométrique :

cos(x + y)
In [26]: sympy.expand\_trig(sympy.cos(x+y))
Out[26]: -sin(x)*sin(y) + cos(x)*cos(y)

Exemple 12 : Développement d’une expression exponentielle :

2
e(a+b)
In [27]: a,b=sympy.symbols(’a b’)

In [28]: sympy.expand(sympy.exp((a+b)**2))
Out[28]: exp(a**2)*exp(b**2)*exp(2*a*b)
factor donne la forme factorisée d’un polynôme
Exemple 13 : Factoriser x3 + 6x2 + 11x + 6 :

In [29]: x=sympy.symbols(’x’)

In [30]: g=x**3+6*x**2+11*x+6

In [31]: sympy.factor(g)
Out[31]: (x + 1)*(x + 2)*(x + 3)
Chapitre 9. Calcul symbolique 229

3.3 Factorisation d’expressions

factor permet la mise en facteur d’une expression dépendant de plu-
sieurs variables.
Exemple 14 : Factoriser x3 − y 3

In [33]: x,y=sympy.symbols(’x y’)

In [34]: sympy.factor(x**3-y**3)
Out[34]: (x - y)*(x**2 + x*y + y**2)

Exemple 15 : Factorisation d’une liste : [a2 − b2 , a3 + b3 ]

In [35]: a,b=sympy.symbols(’a b’)

In [36]: sympy.factor([a**2-b**2,a**3+b**3])
Out[36]: [(a-b)*(a+b),(a+b)*(a**2-a*b+b**2)]

3.4 Substitution dans des expressions symboliques

La méthode subs() remplace une variable dans une expression symbo-
lique par une valeur.
Exemple 16 :

In [2]: x=sympy.symbols(’x’)

In [3]: f=2*x**2-3*x+1

In [4]: f.subs(x,1/3)
Out[4]: 0.222222222222222
√
Exemple 17 : subs pour une fonction de plusieurs variables, f = x2 +5x y :

In [5]: x,y=sympy.symbols(’x y’)

In [6]: f=x**2*y+5*x*sympy.sqrt(y)

In [7]: f.subs(x,3)
230 Programmation Python

Out[7]: 15*sqrt(y) + 9*y

In [8]: f.subs(y,1)
Out[8]: x**2 + 5*x

In [9]: f.subs(([x,3],[y,1]))
Out[10]: 24

Il est également possible de remplacer une variable par une autre. Dans
l’exemple ci-dessous on remplace y par x
In [11]: f.subs(y,x)
Out[11]: 5*x**(3/2) + x**3

3.5 Affichage
La commandes sympy.init_printing() permet un affichage plus
esthétique.
Exemple 18 :

In [1]: import sympy

In [2]: sympy.init_printing()

In [3]: x,a,b,y=sympy.symbols(’x a b y’)

In [4]: f=sympy.exp(a*x)/(1+sympy.cos(b*x)**3)

In [5]: f
Out[5]:
ea.x
cos3 (b.x) + 1

In [6]: f.subs(([a,1],[b,3],[x,y]))
Out[6]:
ey
cos3 (3.y) + 1
Chapitre 9. Calcul symbolique 231

3.6 Dérivation
Avec la commande diff du package de calcul symbolique, il est possible
de calculer :
— les dérivées de fonctions d’une variable,
— les dérivées partielles de fonctions de plusieurs variables.
Comme dans les exemples précédents il faut importer le sympy
In [1]: import sympy as sym
On peut ensuite définir l’expression symbolique f
In [2]: x,y =sym.symbols(’x y’)

In [3]: f=sym.sin(x*y)
diff(f) calcule la dérivée de f par rapport à x
In [5]: sym.diff(f,x)
Out[5]: y*cos(x*y)
Pour calculer la dérivée par rapport à y, on écrit
In [6]: sym.diff(f,y)
Out[6]: x*cos(x*y)
Pour calculer la dérivée seconde par rapport à x
In [7]: sym.diff(f,x,2)
Out[7]: -y**2*sin(x*y)
La dérivée seconde par rapport à y s’obtient avec
In [8]: sym.diff(f,y,2)
Out[8]: -x**2*sin(x*y)

Exemple 19 : Calcul de la dérivée de la fonction de Bessel Jν (z)

In [9]: nu, z=sym.symbols(’nu z’)

In [10]: b=sym.besselj(nu,z)

In [11]: db=sym.diff(b,z)

In [12]: db
Out[12]: besselj(nu - 1, z)/2 - besselj(nu + 1, z)/2
232 Programmation Python

La commande sym.init_printing() affiche le résultat sous une forme

ressemblant à l’écriture des équations mathématiques.
Exemple 20 :

In [13]: sym.init_printing()

In [14]: db
Out[14]:
besselj(ν − 1, z) besselj(ν + 1, z)
−
2 2

3.7 Limites
Le module de calcul symbolique permet de calculer les limites d’une fonc-
tion.
cos(x + h) − cos x
Exemple 21 : limh→0
h

In [28]: x,h=sym.symbols(’x h’)

In [29]: sym.limit((sym.cos(x+h)-sym.cos(x))/h,h,0)
Out[29]: -sin(x)
 x n
Exemple 22 : limn→∞ 1+
n

In [30]: x,n=sym.symbols(’x n’)

In [33]: sym.limit((1+x/n)**n,n,sym.oo)
Out[33]:
$e^x$

3.8 Integration
La commande integrate permet de calculer l’intégrale indéfinie, pri-
mitive, ou l’intégrale définie d’une fonction définie par une expression sym-
bolique
Chapitre 9. Calcul symbolique 233

Exemple 23 : Calcul de l’intégrale indéfinie d’une fonction à une variable :

−2x
Z
dx
(1 + x2 )2

In [1]: import sympy as sym

In [2]: x=sym.symbols(’x’)

In [3]: sym.integrate((-2*x)/(1+x**2)**2,x)
Out[3]: 2/(2*x**2 + 2)
Ce résultat peut être simplifié avec :
In [4]: sym.simplify(Out[3])
Out[4]: 1/(x**2 + 1)

Exemple 24 : Calcul de l’intégrale indéfinie d’une fonction de deux variables :

x
1 + z2

In [7]: x,z=sym.symbols(’x z’)

In [8]: sym.integrate(x/(1+z**2),x)
Out[8]: x**2/(2*z**2 + 2)

In [9]: sym.integrate(x/(1+z**2),z)
Out[9]: x*atan(z)

Exemple 25 : Calcul de l’intégrale définie d’une expression entre 0 et 1 :

Z 1
x(ln x + 1)dx
0

In [11]: sym.integrate(x*(sym.log(x)+1),[x,0,1])
Out[11]: 1/4

Exemple 26 : Calcul de l’intégrale définie d’une expression entre sin(t) et 1 :

In [13]: sym.integrate(2*x,[x,sym.sin(t),1])
Out[13]: 1 - sin(t)**2
234 Programmation Python

3.9 Sommation symbolique

On peut calculer des sommes symboliques quand elles existent en utilisant
la commande summation.

Exemple 27 : Calculer ∞ 1 π2
P
k=1 k2 = 6

In [19]: sym.summation(1/k**2,[k,1,sym.oo])
Out[19]: pi**2/6

P∞ 1
Exemple 28 : Calculer k=0 xk = 1−x

In [20]: sym.summation(x**k,[k,0,sym.oo])
Out[20]: Piecewise((1/(1-x),Abs(x)<1),
(Sum(x**k,(k, 0, oo)),True))

3.10 Produit symbolique

La commande sym.product calcule le produit des éléments d’une série.

Exemple 29 : Calculer k1 k
Q

In [29]: sym.product(k,[k,1,k])
Out[29]: factorial(k)

Q 2k − 1
Exemple 30 : Calculer k1
k2

In [30]: sym.product((2*k-1)/k**2,[k,1,k])
Out[30]: 2**k*RisingFactorial(1/2, k)/factorial(k)**2
Chapitre 9. Calcul symbolique 235

3.11 Séries de Taylor

La commande series permet de calculer le développement en série de
Taylo d’une fonction.
Exemple 31 : Pour obtenir la somme de tous les termes d’ordre inférieur à 6,
1
du développement en série de Taylor de f (x) =
5 + 4 cos x

In [37]: sym.series(1/(5+4*sym.cos(x)),x)
Out[37]: 1/9 + 2*x**2/81 + 5*x**4/1458 + O(x**6)

3.12 Transformations intégrales

La transformée de Fourier d’une fonction se calcule à l’aide de la com-
mande fourier_transform()
2
Exemple 32 : Calcul de la transformée de Fourier de e−x

In [39]: sym.fourier_transform(sym.exp(-x**2), x, k)
Out[39]: sqrt(pi)*exp(-pi**2*k**2)

Exemple 33 : Calcul de la transformée de Fourier de la fonction densité de

1
Cauchy : f (x) =
π(1 + x2 )

In [40]: sym.fourier_transform(1/(sym.pi*(1+x**2)),x,k)
Out[40]: exp(-2*pi*k)
La commande inverse_fourier_transform() permet de calcu-
ler la transformée de Fourier inverse. Les commandes laplace_transform()
et iinverse_laplace_transform() permettent de calculer les trans-
formées de Laplace, directe et inverse réciproquement.

3.13 Résolution d’équations

La commande solve permet de résoudre symboliquement des équations
et des systèmes d’équations.
236 Programmation Python

Exemple 34 : Résoudre x2 − 1 = 0

In [1]: import sympy as sym

In [2]: x=sym.symbols(’x’)

In [3]: sym.solve(x**2-1)
Out[3]: [-1, 1]
Lorsque le second membre de l’équation est nul, on écrit uniquement le
premier membre de l’équation. Par contre si le second membre n’est pas nul
on doit utiliser la fonction Eq.
Exemple 35 : Résoudre x2 + 4x = −1

In [6]: sym.solve(sym.Eq(x**2+4*x,-1))
Out[6]: [-2 - sqrt(3), -2 + sqrt(3)]

Exemple 36 : Résoudre le système d’équation suivant

n
x + 5y − 2 = 0 − 3x + 6y − 15 = 0

In [1]: import sympy as sym

In [2]: x,y=sym.symbols(’x y’)

In [3]: sym.solve([x+5*y-2,-3*x+6*y-15],[x, y])

Out[3]: {x: -3, y: 1}
Chapitre 9. Calcul symbolique 237

4 Graphes
Plusieurs commandes Python permettent d’obtenir des graphes de fonc-
tions symboliques.

Exemple 37 :

In [1]: import sympy as sym

In [2]: import sympy.plotting as plot

In [3]: x,y=sym.symbols(’x y’)

In [4]: y=sym.exp(-0.2*x)*sym.sin(3*x)

In [5]: sym.plot(y,(x,0,5*sym.pi))
Out[5]: <sympy.plotting.plot.Plot at 0x7f66ad21fb90>
238 Programmation Python

Exercices

Exercice 1 :

1. Développer (x + y)6 .
sin(x)
2. Simplifier l’expression trigonométrique .
cos(x)
Exercice 2 :
sin x
1. Calculer limx→0
x
2. Calculer la dérivée de ln x par rapport à x.

Exercice 3 :

1. Définir les fonctions f (x) = x2 , g(x) = x1/2 et h(x) = x + sin(x).

2. Calculer f (2), g(4) et h(a − b2 ).

Exercice 4 :
Calculer les dérivées des fonctions suivantes
1. f (x) = x2 sin(x3 )e2x
2. g(x) = x6 log(cos(x2 )x)
4
3. h(x) = x3 ex
ax + b
4. F (x) =
cx + d
5. G(x) = arctan(x2 + 1)

Exercice 5 :
Calculer les primitives des expressions suivantes :
1. x7
2. 1/x
3. x log(x)
Chapitre 9. Calcul symbolique 239

Exercice 6 :
Calculer symboliquement les expressions suivantes :
R1 7
1. 0
x dx
R2 1
2. 1
dx
x
R1√
3. 0
x log(x)dx
R ∞ −x2
4. 0
e dx

Exercice 7 :
Calculer la solution exacte et la solution approchée de sin(x) = cos(x).
Exercice 8 :
Résoudre symboliquement l’équation x4 + 1 = 2x2 − 1
Exercice 9 :
Simplifier les expressions suivantes :
1. 1/2m − 1/3m + 1/4m + 1/5m + 1/6m
2. 1/2 − 1/3 + 1/4 + 1/5 + 1/6
240 Programmation Python

Corrigé des exercices

Corrigé exercice 1 :

import sympy as sym

x,y=sym.symbols(’x y’)
# 1
print(sym.expand((x+y)**6))

# 2
print(sym.simplify(sym.sin(x)/sym.cos(x)))

Corrigé exercice 2 :

# 1
print(sym.limit(sym.sin(x)/x,x,0))

# 2
print(sym.diff(sym.log(x),x))

Corrigé exercice 3 :

import sympy as sym

# 1
a,b,x=sym.symbols(’a b x’)
f=x**2
g=sym.sqrt(x)
h=x*sym.sin(x)

# 2
f.subs(x,2)
g.subs(x,4)
h.subs(x,a-b**2)
Chapitre 9. Calcul symbolique 241

Corrigé exercice 4 :

import sympy as sym

# 1
x,a,b,c,d=sym.symbols(’x a b c d’)
f=x**2*sym.sin(x**3)*sym.exp(2*x)
df=sym.diff(f,x)
sym.simplify(df)

# 2
g=x**6*sym.log(x*sym.cos(x**2))
dg=sym.diff(g,x)
sym.simplify(dg)

# 3
h=x**3*sym.exp(x**4)
dh=sym.diff(h,x)
sym.simplify(dh)

# 4
F=(a*x+b)/(c*x+d)
sym.diff(F,x)

# 5
G=sym.atan(x**2+1)
sym.diff(G,x)

Corrigé exercice 5 :

# 1
sym.integrate(x**7)

# 2
sym.integrate(1/x)

# 3
sym.integrate(x*sym.log(x))
242 Programmation Python

Corrigé exercice 6 :

# 1
sym.integrate(x**7,[x,0,1])

# 2
sym.integrate(1/x,[x,0,1])

# 3
sym.integrate(sym.sqrt(x)*sym.log(x),[x,0,1])

# 4
sym.integrate(sym.exp(-x**2),[x,0,sym.oo])

Corrigé exercice 7 :

# Solution exacte
sym.solve(sym.Eq(sym.sin(x),sym.cos(x)))

# Solution approchée
sym.nsolve(sym.Eq(sym.sin(x),sym.cos(x)),1)

Corrigé exercice 8 :

solutions=sym.solve(sym.Eq(x**4+1,2*x**2-1))
print(solutions)

# Evaluation numérique des solutions :

for i in range(len(solutions)):
print(solutions[i].evalf())

Corrigé exercice 9 :

# 1
m=sym.symbols(’m’)
s=sym.simplify(1/(2*m)-1/(3*m)+1/(4*m)+1/(5*m)+ 1/(6*m))

# 2
s.subs(m,1)
Annexe A

Format

Dans cette annexe, nous verrons comment formater les chaînes Python .
L’écriture formatée est un mécanisme permettant d’afficher des variables avec
un certain format, par exemple justifiées à gauche ou à droite, ou encore avec
un certain nombre de décimales pour les floats. Le formatage de chaîne
est le processus consistant à insérer des éléments dans une chaîne de manière
dynamique et à afficher cette chaîne. Il existe différentes manières d’effectuer
le formatage des chaînes :
— Formatage avec f-strings.
— Formatage avec l’opérateur %.
— Formatage avec la méthode de chaîne format().
Depuis la version 3.6, Python a introduit les f-strings pour mettre en place
l’écriture formatée. f-string est le diminutif de formatted string literals. Il est
conseillé d’utiliser des f-strings car la méthode de chaîne format( ), intro-
duite depuis la version Python 2.7, présente l’inconvénient, tout comme avec
l’opérateur %, de devoir mettre la liste des variables tout à la fin, alourdissant
ainsi la syntaxe.

243
244 Programmation Python

1 Formatage avec f-strings

1.1 Prise en main

Exemple 1 : On souhaite afficher nom a age ans où nom est une chaine et age
un entier.
nom=’Omar’
age=30
print(f’{nom} a {age} ans’)

Omar a 30 ans
Il suffit de passer un nom de variable au sein de chaque couple d’accolades
et Python les remplace par leur contenu. Il ne faut pas omettre le f avant le
premier guillemet !

1.2 Spécification de format

Les f-strings permettent de remplacer des variables au sein d’une chaîne
de caractères. On peut également spécifier le format de leur affichage.
Exemple 2 : Calculer et afficher le volume d’une sphère de rayon r à l’aide de
la formule V = 34 πr3 .
pi=3.14
r=1.5
v=4/3*pi*r**3
print(f’Volume de la sphère de rayon {r} : {v}’)

Volume de la sphère de rayon 1.5 : 14.129999999999999

Le résultat obtenu présente trop de décimales. Pour écrire le résultat plus lisi-
blement, on peut spécifier dans les accolades le format souhaité.
Chapitre A. Format 245

Par exemple pour formater un float afin de l’afficher avec deux déci-
males :
print(f’Volume de la sphère de rayon {r} : {v:.2f}’)

Volume de la sphère de rayon 1.5 : 14.13

Dans l’accolade ({v:.2f}) on a d’abord le nom de la variable à formater,
v, puis les deux-points : qui indiquent le format dans lequel on veut imprimer
la variable v. À droite des deux-points on trouve .2f qui indiquent la précision
voulue, soit ici deux chiffres après la virgule. Le formatage avec .2f renvoie
un résultat arrondi.
On peut formater des entiers avec la lettre d (d signifie decimal integer).
nom=’Omar’
age=30
print(f’{nom} a {age:d} ans’)
Enfin, il est possible de préciser sur combien de caractères on souhaite
qu’un résultat soit écrit et comment se fait l’alignement (à gauche, à droite ou
centré).
• > spécifie un alignement à droite,
• < spécifie un alignement à gauche,
• ˆ spécifie un alignement centré.
Il est également possible d’indiquer le caractère qui servira de remplissage lors
des alignements (l’espace est le caractère par défaut).
Exemple 3 :

print(10)
print(1000)

10
1000
246 Programmation Python

Alignement à droite
print(f"{10:>6d}")
print(f"{1000:>6d}")

10
1000
Alignement à gauche :
print(f"{10:<6d}")
print(f"{1000:<6d}")

10
1000
Alignement au centre
print(f"{10:^6d}")
print(f"{1000:^6d}")

10
1000
Remplissage avec un caractère - exemple avec ∗
print(f"{10:*^6d}")
print(f"{1000:*^6d}")

**10**
*1000*
Écriture scientifique Pour les nombres très grands ou très petits, l’écriture
formatée permet d’afficher un nombre en notation scientifique (sous forme de
puissance de 10) avec la lettre e :
print(f"{1000000000:e}")

1.000000e+09

print(f"{0.000000001:e}")

1.000000e-09
Il est également possible de définir le nombre de chiffres après la virgule.
Dans l’exemple ci-dessous, on affiche un nombre avec 0, 3 et 6 chiffres après
la virgule :
Chapitre A. Format 247

avogadro_number = 6.02214076e23
print(f"{avogadro_number:.0e}")

6e+23

print(f"{avogadro_number:.3e}")

6.022e+23

print(f"{avogadro_number:.6e}")

6.022141e+23

2 Formatage de chaîne avec l’opérateur %

C’est la plus ancienne méthode de formatage de chaîne en Python . Elle
fait appel à l’opérateur modulo % qui est également appelé « opérateur de
formatage de chaîne ». Cette manière de formater une chaine avec l’opérateur
% est néanmoins déconseillée pour les versions de Python les plus récentes
(version 3.0 et plus).
Exemple 4 : Formatage d’une chaîne à l’aide de l’opérateur %s

print(’Les %s sont nombreux’%’étudiants’)

Les étudiants sont nombreux

Exemple 5 : Formatage de plusieurs chaînes avec l’opérateur %s

print(’les %s sont nombreux mais %s’%

(’étudiants’,’disciplinés’))

les étudiants sont nombreux mais disciplinés

Exemple 6 : Formatage avec %d et %s

print(’Il y a %d élèves dans la %s’ % (4,’classe’))

Il y a 4 élèves dans la classe

248 Programmation Python

Exemple 7 : Formatage avec %f Les nombres à virgule flottante utilisent le for-

mat %a.bf. Ici, a serait le nombre minimum de chiffres devant être présents
dans la chaîne ; ceux-ci peuvent être remplis d’espaces blancs si le nombre
dans sa totalité n’a pas autant de chiffres. bf représente le nombre de chiffres
à afficher après la virgule.
x=2
y=3
z=2/3
print(’%d / %d vaut %2.2f’%(x,y,z))

2 / 3 vaut 0.67
En conclusion, le symbole % apparait 2 fois :
• Le symbole % est d’abord appelé dans la chaîne de caractères pour :
— Désigner l’endroit où sera placée la variable dans la chaîne de ca-
ractères.
— Préciser le type de variable à formater, d pour un entier ou f pour
un float.
— Éventuellement pour indiquer le format voulu.
• Le signe % est rappelé une seconde fois pour indiquer la ou les variables
à formater.

3 Formatage avec la méthode .format

Depuis la version 2.7 de Python, la méthode .format() permet une nette
amélioration pour mettre en place l’écriture formatée. Celle-ci fonctionne de
la manière suivante :
• Dans la chaîne de caractères, les accolades vides précisent l’endroit où
le contenu de la variable doit être inséré.
• Juste après la chaîne de caractères, l’instruction .format(par1,par2)
fournit la liste des variables à insérer, d’abord la variable par1 puis la
variable par2.
• On peut éventuellement préciser le formatage en mettant un caractère
deux-points :
Chapitre A. Format 249

Exemple 8 :

nom=’Omar’
age=30
sortie=’{} a {} ans’.format(nom,age)
print(sortie)

Omar a 30 ans

Exemple 9 :

x=2
y=3
z=x/y
print(’{:d}/{:d} vaut {:2.3f}’.format(x,y,z))

2/3 vaut 0.667

Le formatage avec la méthode .format() se rapproche de la syntaxe des
f-strings (accolades, deux-points).

4 Choix de la méthode de formatage

Si on travaille avec la version Python 3.6 ou plus, il est fortement conseillé
d’utiliser les f-strings.
Annexe B

Fichiers

La gestion des fichiers est une partie importante de toute application. Python
a plusieurs fonctions pour créer, lire, mettre à jour et supprimer des fichiers.

1 La gestion des fichiers

En Python , la fonction de base pour travailler avec des fichiers est la

fonction open().
L’appel open(data.txt) effectue implicitement les actions suivantes :

1. S’assure que data.txt existe.

2. Crée un objet correspondant à ce fichier.

3. Définit la position du curseur (pos) au début du fichier, pos = 0.

L’appel à open() ne lit en mémoire aucune partie du fichier, n’écrit rien au

fichier ni ne ferme le fichier. Toutes ces actions doivent être effectuées séparé-
ment et explicitement et sont accomplies grâce à l’utilisation de méthodes de
traitement de fichiers.

251
252 Programmation Python

Méthode Description
f.read(n) Lit n octets du fichier. Si n n’est pas pré-
sent ou vaut -1, tout le reste du fichier est
lu.
f.readline() Lit la ligne complète suivante du fichier et
renvoie une chaîne qui inclut le caractère
de nouvelle ligne \n.
f.readlines() Lit le reste du fichier et renvoie une liste de
chaînes qui se terminent par des retours à
la ligne\n.
f.seek(pos) Déplace le curseur de fichier à la position
spécifiée.
f.tell() Renvoie la position actuelle du curseur
dans le fichier.
f.write(s) Insère la chaîne s à la position actuelle
dans le fichier.
f.flush() Exécute toutes les opérations d’écriture en
attente, en s’assurant qu’elles sont bien sur
le disque.
f.close() Ferme le fichier. Plus aucune opération de
lecture ou d’écriture ne peut avoir lieu.
Méthodes associées à un objet f de type fichier
La fonction open() prend deux paramètres : nom de fichier et mode. Il
existe quatre méthodes (modes) différentes pour ouvrir un fichier :
• "r" - Lecture - Valeur par défaut. Ouvre un fichier en lecture. Renvoie
un message d’erreur si le fichier n’existe pas.
• "a" - Ajouter - Ouvre un fichier en mode ajout. Crée le fichier s’il
n’existe pas
• "w" - Écrire - Ouvre un fichier pour l’écriture. Crée le fichier s’il n’existe
pas
• "x" - Créer - Crée le fichier spécifié. Renvoie une erreur si le fichier
existe
On peut spécifier si le fichier doit être traité en mode texte ou binaire :
• "t" - Texte - Valeur par défaut. Mode texte
• "b" - Binaire - Mode binaire.
Chapitre B. Fichiers 253

2 Syntaxe
Pour ouvrir un fichier en lecture, il suffit de spécifier le nom du fichier :
f = open ("demofile.txt")
Le code ci-dessus est le même que :
f = open ("demofile.txt", "rt")

Remarque : Comme "r" pour lecture et "t" pour texte sont les valeurs
par défaut, il n’est pas nécessaire de les spécifier. Si le fichier n’existe pas on
obtient un message d’erreur.

3 Lecture d’un fichier

3.1 Lecture de la totalité du fichier

Supposons que nous ayons le fichier demofile.txt, situé dans le même dos-
sier que Python :
demofile.txt
salut ! Bienvenue sur demofile.txt
Ce fichier est à des fins de test.
Bonne chance !

Pour ouvrir le fichier, on utilise la fonction open(). La fonction open()

renvoie un objet fichier, qui a une méthode read() pour lire le contenu du
fichier :
Exemple 1 :

f = open("demofile.txt", "r")
print(f.read())

salut! Bienvenue sur demofile.txt

Ce fichier est à des fins de test.
Bonne chance!
254 Programmation Python

Si le fichier se trouve dans une autre répertoire, on utilise :

f = open("D:\\myfiles\\welcome.txt", "r")
print(f.read())
Pour lire le contenu d’un fichier, on utilise f.read(taille), qui lit
une certaine quantité de données et la renvoie sous forme de chaîne (en mode
texte) ou d’objet octets (en mode binaire). taille est un argument numérique
facultatif. Lorsque la taille est omise ou négative, tout le contenu du fichier
sera lu et renvoyé. Si la fin du fichier est atteinte, f.read() renverra une
chaîne vide ("").

3.2 Lecture partielle d’un fichier

Lecture de caractères

Par défaut, la méthode read () renvoie tout le texte, mais il est possible
de spécifier le nombre de caractères que l’on souhaite obtenir.
Exemple 2 :

f = open("demofile.txt", "r")
print(f.read(5))
Renvoie les 5 premiers caractères du fichier
salut

Lecture de lignes

On peut obtenir une ligne en utilisant la méthode readline() :

Exemple 3 :

f = open("demofile.txt", "r")
print(f.readline())

salut! Bienvenue sur demofile.txt

Chapitre B. Fichiers 255

Exemple 4 : En appelant readline() deux fois, on peut lire les deux pre-
mières lignes.
f = open("demofile.txt", "r")
print(f.readline())
print(f.readline())

salut! Bienvenue sur demofile.txt

Ce fichier est à des fins de test.

Lecture ligne par ligne

En parcourant les lignes du fichier, on peut lire l’intégralité du fichier, ligne

par ligne.
Exemple 5 :

f = open("demofile.txt", "r")
for x in f:
print(x)

salut! Bienvenue sur demofile.txt

Ce fichier est à des fins de test.
Bonne chance!

4 Fermeture de fichiers
Il est recommandé de toujours fermer le fichier lorsqu’on en a terminé. Ceci
est une bonne pratique de programmation. Par exemple, dans certains cas, en
raison de la mise en mémoire tampon, les modifications apportées à un fichier
peuvent ne pas s’afficher jusqu’à ce que le fichier soit fermé.
Exemple 6 :

f = open("demofile.txt", "r")
print(f.readline())
f.close()
256 Programmation Python

Exemple 7 : Pour lire le fichier texte suivant contenant les éléments d’une
matrice
matrice.txt
1,4,15,9
0,11,7,3
2,8,12,13
14,5,10,6

f = open(’matrice.txt’)
matrix = []
for line in f.readlines():
line=line.rstrip()
row = [float(x) for x in line.split(’,’)]
matrix.append(row)
f.close()
print(matrix)

[[1.0, 4.0, 15.0, 9.0],

[0.0, 11.0, 7.0, 3.0],
[2.0, 8.0, 12.0, 13.0],
[14.0, 5.0, 10.0, 6.0]]

5 Écriture de fichiers

5.1 Écrire dans un fichier existant

Pour écrire dans un fichier existant, vous devez ajouter un paramètre à la
fonction open() :
• "a" - Ajouter - ajoutera à la fin du fichier
• "w" - Ecrire - écrasera tout contenu existant

Exemple 8 : Pour ouvrir le fichier "demofile.txt" et ajouter du contenu au fi-

chier.
f = open("demofile.txt", "a")
f.write("Maintenant le fichier a plus de contenu!")
Chapitre B. Fichiers 257

f.close()

# Ouvrir et lire le fichier après l’ajout

f = open("demofile.txt", "r")
print(f.read())
f.close()

salut! Bienvenue sur demofile.txt

Ce fichier est à des fins de test.
Bonne chance!

Maintenant le fichier a plus de contenu!

Exemple 9 : Pour ouvrir le fichier "demofile.txt" et écraser le contenu.

f = open("demofile.txt", "w")
f.write("Woops! Le contenu a été supprimé!")
f.close()

# Ouvrir et lire le fichier

f = open("demofile.txt", "r")
print(f.read())
f.close()

Woops! Le contenu a été supprimé!

Remarque : L’utilisation du paramètre "w" écrasera tout le fichier.

5.2 Créer un nouveau fichier

Pour créer un nouveau fichier en Python , utilisez la méthode open(),
avec l’un des paramètres suivants :
• "x" - Créer - crée un fichier, renvoie une erreur si le fichier existe,
• "a"- Ajouter - crée un fichier si le fichier spécifié n’existe pas,
• "w" - Ecriture - crée un fichier si le fichier spécifié n’existe pas.
258 Programmation Python

Exemple 10 : Pour créer un fichier appelé "myfile.txt"

f = open("myfile.txt", "x")

Exemple 11 : Pour créer un nouveau fichier s’il n’existe pas

f = open("myfile.txt", "w")

6 Contexte with
On n’est jamais à l’abri d’une erreur. Surtout quand on manipule des fi-
chiers. Il peut se produire des erreurs, lors de la lecture ou l’écriture, et le
fichier peut rester ouvert. Si une autre partie de votre programme souhaite de
nouveau utiliser ce fichier, il risque d’y avoir un conflit.
Il existe un mot-clé qui permet d’éviter cette situation : with. Voici la
syntaxe :
with open(mon_fichier, mode_ouverture) as variable:
# Opérations sur le fichier
....
Cet exemple contient :
• Le mot-clé with, qui précède le bloc dans lequel on va manipuler le
fichier.
• Le mot-clé as qui signifie « en tant que ».
• la variable qui contiendra notre objet. Si la variable n’existe pas, Python
la crée.

Exemple 12 :

with open(’fichier.txt’, ’r’) as mon_fichier:

texte = mon_fichier.read()
Le mot-clé with permet de vérifier que le fichier est ouvert et fermé,
même si des erreurs se produisent pendant le bloc. On peut le vérifier avec
le test mon_fichier.closed. Il est inutile, par conséquent, de fermer le
fichier à la fin du bloc with. L’utilisation de cette syntaxe est recommandée
car elle est plus sûre.
Chapitre B. Fichiers 259

7 Supprimer un fichier

7.1 Supprimer un fichier

Pour supprimer un fichier, il faut importer le module os et exécuter sa
fonction os.remove() :
Exemple 13 : Pour supprimer le fichier "demofile.txt" :

import os
os.remove("demofile.txt")

7.2 Vérifier si le fichier existe

Pour éviter d’avoir une erreur, il faut vérifier si le fichier existe avant d’es-
sayer de le supprimer.
Exemple 14 :

import os
if os.path.exists("demofile.txt"):
os.remove("demofile.txt")
else:
print("Le fichier n’existe pas!")

7.3 Supprimer un répertoire

Pour supprimer un répertoire entier, utiliser la méthode os.rmdir() :
Exemple 15 : Pour supprimer le répertoire "myfolder"

import os
os.rmdir("myfolder")

Remarque : On ne peut supprimer que des répertoires vides.

Bibliographie

[1] Gérard Swinnen, Apprendre à programmer avec Python 3, Eyrolles 2012.

[2] T.R Padmanabhan, Programming with Python, Springer 2016.
[3] Sandeep Nagar, Introduction to Python for Engineers and Scientists,
apress 2018.
[4] Anders Malthe-Sørenssen, Elementary Mechanics Using Python, Sprin-
ger 2015.
[5] Anthony Scopatz and Kathryn D. Huff, Effective Computation in Physics,
O’Reilly Media 2015.
[6] Gérard Swinnen, Apprendre à programmer en Python 3. http ://info-
ref.be/swi/python.htm 2012.
[7] Arnt Inge Vistnes, Physics of Oscillations and Waves With use of Matlab
and Python , Springer 2018.
[8] Bill Lubanovic, Introducing Python, O’Reilly 2015.
[9] Christian Hill, Learning Scientific Programming with Python, Cambridge
University Press 2015.
[10] Eric Ayars, Computational Physics With Python. ? ? 2013.
[11] David J. Pine, Introduction to Python for Science and Engineering , CRC
Press 2019.
[12] Peter Farerell, Math Adventures With Python,No Starch Press, Inc. 2019.
[13] Francisco J. Blanco-Silva, Learning SciPy for Numerical and Scientific
Computing, Packt Publishing Ltd. 2013
[14] Hans Petter Langtangen, A Primer on Scientific Programming with Py-
thon , Springer 2016.
262 Programmation Python

[15] Steven I. Gordon & Brian Guilfoos , Introduction to Modeling and Si-
mulation with MATLAB® and Python , CRC Press 2017.
[16] Cyrille Rossant , IPython Interactive Computing and Visualization Co-
okbook , Packt Publishing 2018 .
[17] Jesse M. Kinder & Philip Nelson , A Student’s Guide to Python for Phy-
sical Modeling , Princeton University Press 2015 .
[18] John M. Stewart , Python for Scientists , Cambridge University Press
2017.
[19] John Paul Mueller , Beginning Programming with Python For Dummies
John Wiley & Sons, Inc.,2018.
[20] Zed A. Shaw , Lear Python 3, The Hard Way , Addison-Wesley 2017.
[21] Mark Myers, A Smarter Way to Learn Python , Mark Myers 2017 .
[22] Jaan Kiusalaas , Numerical Methods in Engineering with Python , Cam-
bridge University Press 2005.
[23] Robert Johansson , Numerical Python , Apress 2019.
[24] Svein Linge & Hans Petter Langtangen , Programming for Computations
- Python , Springer 2018.
[25] Wes McKinney , Python for Data Analysis , O’reilly 2018.
[26] Rubin H. Landau, Manuel J. Páez & Cristian C. Bordeianu ,Computatio-
nal Physics, Problem Solving with Python WILEY-VCH, 2015 .
[27] Allen B. Downey ,Think Python O’Reilly 2015.
[28] Titus Adrien Beu ,Introduction to numerical programming , CRC Press
2015.
[29] Rubin H. Landau & Manuel José Páez ,Computational Problems for Phy-
sics , 2018.
Achevé d’imprimer sous les presses
de Mitidja Impression
Baraki, Alger