Année académique 2024 - 2025

Simulation numérique
Classes Préparatoires aux Ecoles d’Ingénieur (CPEI)
MP & PC : Semestre 4

Volume horaire : 18 H
Cours Théorique: 12 H, TD/TP: 06 H

Cours de :
Cheick Amed Diloma Gabriel T RAORÉ
[Link]@[Link]
 Sommaire

I Python pour le calcul numérique 5

1 Manipulez des tableaux avec NumPy 7
1.1 Différenciez les arrays des listes classiques . . . . . . . . . . . . . . . . . . . 7
1.1.1 Les arrays NumPy . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.1.2 Créez un array NumPy . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.2 Sélectionnez des éléments au sein d’un array . . . . . . . . . . . . . . . . . . . 10
1.2.1 Accédez à un seul élément . . . . . . . . . . . . . . . . . . . . . . . . 10
1.2.2 Accédez à plusieurs éléments contigus . . . . . . . . . . . . . . . . . . 10
1.2.3 Accédez à plusieurs éléments selon une condition . . . . . . . . . . . . 11
1.3 Utilisez les méthodes d’array . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

2 Transformez vos données en tableaux 14

2.1 Créez un tableau avec NumPy . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2 Analogie entre les arrays et les matrices . . . . . . . . . . . . . . . . . . . . . 16
2.2.1 Définissez des matrices non aléatoire et aléatoire en NumPy . . . . . . 17
2.2.2 Réalisez des opérations d’algèbre sur des ndarray . . . . . . . . . . . . 19
2.3 Accéder au éléments d’un ndarray . . . . . . . . . . . . . . . . . . . . . . . . 21
2.3.1 Accédez à un ou plusieurs éléments d’un ndarray : slicing et conditions
imbriquées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.3.2 Sélectionnez des éléments au sein d’un ndarray . . . . . . . . . . . . . 22
2.3.3 Extension de Numpy par SciPy . . . . . . . . . . . . . . . . . . . . . 23
2.4 Exercices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.4.1 Exercice d’application de fin de chapitre . . . . . . . . . . . . . . . . . 24
2.4.2 Exercices complémentaires . . . . . . . . . . . . . . . . . . . . . . . . 24

3 Créez votre premier data frame avec Pandas 27

3.1 Générez un data frame . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.1.1 Créer votre data frame à partir de fichier(s) préexistant(s) . . . . . . . . 29
3.1.2 Créer un data frame à partir de données que vous avez . . . . . . . . . 30
3.2 Identifiez les caractéristiques de votre data frame . . . . . . . . . . . . . . . . 31
3.2.1 Aperçu du data frame . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.2.2 Caractéristiques globales d’un data frame . . . . . . . . . . . . . . . . 32

4 Manipulez un data frame 34

i
 ii

4.1 Naviguez dans un data frame . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

4.2 Découvrez l’objet Series de Pandas . . . . . . . . . . . . . . . . . . . . . . . . 35
4.3 Manipulez les colonnes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.3.1 Modifiez une colonne existante . . . . . . . . . . . . . . . . . . . . . 37
4.3.2 Créer et supprimez une colonne . . . . . . . . . . . . . . . . . . . . . 38
4.3.3 Renommez une colonne . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.3.4 Changez le type d’une colonne . . . . . . . . . . . . . . . . . . . . . . 40
4.3.5 Triez un data frame . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

5 Filtrez les données du data frame 42

5.1 Appliquez la sélection via des indices . . . . . . . . . . . . . . . . . . . . . . 42
5.2 Utilisez la sélection via des conditions . . . . . . . . . . . . . . . . . . . . . . 43
5.3 Modifiez une sélection . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

6 Maîtrisez les bonnes pratiques de la data visualisation 48

6.1 Importance de la représentation graphique . . . . . . . . . . . . . . . . . . . . 48
6.2 Identifiez le graphique adapté . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
6.2.1 Présentez une évolution dans le temps . . . . . . . . . . . . . . . . . . 49
6.2.2 Comparez différents groupes . . . . . . . . . . . . . . . . . . . . . . . 50
6.2.3 Représentez une distribution . . . . . . . . . . . . . . . . . . . . . . . 51
6.2.4 Représentez la relation entre deux variables numériques . . . . . . . . 52
6.3 Bonnes pratiques de la visualisation des données . . . . . . . . . . . . . . . . 52
6.3.1 Privilégiez la simplicité . . . . . . . . . . . . . . . . . . . . . . . . . . 53
6.3.2 Clarifiez votre graphique . . . . . . . . . . . . . . . . . . . . . . . . . 54
6.3.3 Choisissez le graphique adéquat . . . . . . . . . . . . . . . . . . . . . 55

7 Tracez des graphiques avec Matplotlib 57

7.1 Découvrez Matplotlib . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
7.2 Tracez vos premiers graphiques . . . . . . . . . . . . . . . . . . . . . . . . . . 57
7.2.1 Nuage de points . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
7.2.2 Diagramme circulaire . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
7.2.3 Diagramme à barres . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
7.2.4 Histogramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
7.2.5 Courbes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
7.3 Créez plusieurs graphiques sur une même fenêtre . . . . . . . . . . . . . . . . 63
7.3.1 Créez plusieurs graphiques dans une figure . . . . . . . . . . . . . . . 63
7.3.2 Créez plusieurs sous figures dans une même figure : subplot . . . . . . 64

8 Personnalisez vos graphiques avec Matplotlib 66

8.1 Modifiez les éléments extérieurs . . . . . . . . . . . . . . . . . . . . . . . . . 66
8.2 Modifiez les éléments intérieurs . . . . . . . . . . . . . . . . . . . . . . . . . 68

II Calcul numérique 70
9 Calcul numérique approché 71
9.1 Erreurs absolue et relative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
9.1.1 Erreur absolue . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
9.1.2 Erreur relative . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
9.2 Incertitudes absolue et relative . . . . . . . . . . . . . . . . . . . . . . . . . . 72
9.3 Représentation décimale d’un nombre approché . . . . . . . . . . . . . . . . . 72
 iii

9.3.1 Représentation décimale d’un nombre approché . . . . . . . . . . . . . 72

9.4 Chiffres significatifs exacts d’un nombre approché . . . . . . . . . . . . . . . 74
9.5 Troncature et arrondissement d’un nombre . . . . . . . . . . . . . . . . . . . . 74
9.6 Relation entre erreur relative et c.s.e . . . . . . . . . . . . . . . . . . . . . . . 75
9.7 Exercices d’application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

10 Equations non linéaires 76

10.1 Racines d’équations non linéaires . . . . . . . . . . . . . . . . . . . . . . . . 76
10.2 Séparation des racines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
10.2.1 Méthode graphique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 76
10.2.2 Méthode de balayage . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
10.3 Approximation des racines : Méthodes itératives . . . . . . . . . . . . . . . . . 78
10.3.1 Méthode de Newton-Raphson . . . . . . . . . . . . . . . . . . . . . . 78
10.3.2 Méthode de Newton Raphson pour deux inconnus . . . . . . . . . . . 84
10.3.3 Méthode de Newton-Raphson et polynômes . . . . . . . . . . . . . . . 86
10.3.4 Pseudo-code de la méthode de Newton Raphson pour des polynômes . 88
10.3.5 Méthode de la sécante . . . . . . . . . . . . . . . . . . . . . . . . . . 89
10.3.6 Méthode de dichotomie . . . . . . . . . . . . . . . . . . . . . . . . . . 90
10.3.7 Méthode du point fixe . . . . . . . . . . . . . . . . . . . . . . . . . . 94
10.4 Implémentation SciPy d’équations non linéaires . . . . . . . . . . . . . . . . . 99

Bibliographie 101
 Introduction et installation de l'environnement de
simulation

La simulation numérique, ou plus largement le calcul numérique, est un domaine des mathé-
matiques appliquées qui se concentre sur l’utilisation d’algorithmes et de méthodes numériques
pour résoudre des problèmes mathématiques difficilement résolubles à la main. Ces problèmes,
souvent impossibles ou très difficiles à résoudre analytiquement, impliquent généralement des
équations différentielles, des intégrales ou des systèmes d’équations non linéaires. Le calcul nu-
mérique repose sur des approximations et des simulations permettant de fournir des solutions
pratiques, même si elles ne sont pas exactes.

Pourquoi l'enseigner ?
Le calcul numérique est une passerelle entre la théorie mathématique et le monde réel. L’en-
seigner permet de doter les étudiants d’outils et de compétences nécessaires pour relever les
défis scientifiques et technologiques modernes. Ci-dessous nous énumérons quelques raisons
d’enseigner les simulations numériques.

Résolution de problèmes complexes

Dans de nombreux domaines scientifiques et d’ingénierie, les problèmes réels sont souvent trop
compliqués pour être résolus de manière exacte. Les méthodes numériques offrent une solution
efficace et pragmatique pour relever ces défis.

Applications interdisciplinaires
Le calcul numérique est essentiel dans diverses disciplines, notamment la physique, la chimie, la
biologie, l’économie, la finance, la sociologie et l’intelligence artificielle. Il permet de modéliser
des phénomènes naturels, de prévoir des comportements ou d’optimiser des systèmes.

1
 2

Développement des compétences techniques

Enseigner le calcul numérique initie les étudiants à l’utilisation d’outils modernes tels que les
logiciels de programmation, les bibliothèques numériques et les plateformes de simulation, de-
venus indispensables dans le monde professionnel.

Approche pratique des mathématiques

Contrairement aux mathématiques purement théoriques, le calcul numérique met l’accent sur
l’application pratique des concepts, ce qui motive et engage davantage les apprenants.

Formation à la pensée algorithmique

Les étudiants apprennent à décomposer des problèmes complexes en étapes claires et à concevoir
des solutions précises, des compétences précieuses dans des domaines tels que l’informatique et
la gestion de projets.

À propos de ce cours
Ce cours est destiné aux étudiants de 2ème année des classes préparatoires de l’École Poly-
technique de Ouagadougou (EPO). Son objectif principal est de fournir une variété d’outils
numériques permettant de résoudre efficacement un large éventail de problèmes scientifiques.
Grâce à une approche pédagogique combinant Cours Magistraux (CM), Travaux Dirigés (TD)
et Travaux Pratiques (TP), les étudiants développeront des compétences pratiques et théoriques
adaptées aux défis scientifiques modernes.

Pour rendre l’apprentissage concret et accessible, chaque chapitre du cours sera accompagné
d’exemples illustratifs et d’une série d’exercices. Ces activités renforceront leur compréhension
et faciliteront l’application des techniques enseignées.

Prérequis
Une bonne maîtrise des concepts fondamentaux suivants est indispensable : équations différen-
tielles, méthodes d’intégration, algèbre linéaire.

Objectifs pédagogiques
Au terme du cours, l’apprenant devra être capable de :
• développer une expertise dans l’utilisation de bibliothèques Python spécialisées, notam-
ment numpy, scipy, matplotlib et pandas ;
• acquérir des compétences pratiques pour résoudre des problèmes scientifiques complexes
grâce aux techniques de simulation numérique ;
• maîtriser la visualisation et l’analyse des données à l’aide d’outils graphiques.
 3

Évaluation
Le cours sera évalué à travers un devoir sur table et un TP, permettant de valider les acquis
théoriques et pratiques.

Instructions pour les travaux de laboratoire (simulation)

Mise en place de l'environnement de travail
Mise en place : Nous utiliserons des Notebooks (bloc-notes) Jupyter avec un noyau Python pour
le travail de laboratoire (simulation).

Cela signifie que vous devez installer Python (version 3.12 ou supérieure) sur votre ordinateur
et installer une application Jupyter Notebooks 1 .

Pour travailler sur les tâches de programmation, vous devez installer les paquets Python sui-
vants : numpy, scipy, seaborn, pandas et matplotlib. Ceux qui souhaite se familiariser avec jupy-
ter notebook peuvent suivre la vidéo : [Link]

Remarque 0.1 (Aide : installer jupyter notebook en ligne de commande). Pour installer jupyter
notebook en ligne de commande, vous pouvez suivre les instruction suivante :
1. Ouvrez l’invite de commandes : appuyez sur la touche Windows, tapez « cmd » et appuyez
sur Entrée.
2. Installez Jupyter Notebook : dans l’invite de commandes, tapez la commande suivante et
appuyez sur Entrée : pip install jupyter notebook
3. Lancez Jupyter Notebook : une fois l’installation terminée, tapez la commande suivante
et appuyez sur Entrée : jupyter notebook
Jupyter Notebook s’ouvrira dans votre navigateur web par défaut. Si vous avez un mes-
sage d’erreur (peut-être parce que vous avez anaconda sur votre machine), utilisez la
commande : python -m notebook

Un des atouts majeurs du notebook réside dans sa capacité à combiner code et texte. En ef-
fet, il permet non seulement de programmer, mais aussi de rédiger du texte enrichi grâce au
langage de formatage Markdown. Voici ci-dessous quelques exemples d’instructions en Mark-
down.

1. en ligne de commande [Link]

tutoriels-installation-python/installer-jupyter-notebook ; [Link] ou
via anaconda : [Link] (suivez les liens en pied de page. Bien que vous ayez
deux possibilités pour installer jupyter notebook, je vous recommande d’utiliser la ligne de commande). Si vous
avez besoin d’aide suivez la vidéo : [Link]
 4

Aide-mémoire Markdown
Un titre de niveau 1 :
# Titre

Un titre de niveau 2 :
## Subtitle

Un titre de niveau 3 :
### Sous-soustitre

Texte en gras:
**bold text**

Texte en italique:
*italic text*

Une formule mathématique:

Pythagoras' theorem is $a^2+b^2=c^2$.

Une liste ordonée:

1. First item
2. Second item
3. Third item

Une liste non ordonnée:

* First item
* Second item
* Third item

Tâches
Les travaux pratiques sont destinés à compléter les cours magistraux et à vous faire appliquer la
théorie que vous avez apprise dans les cours magistraux.

Les exercices seront résolus à la fois avec du papier-crayon (pour la formulation mathématiques
et les preuves analytiques) et de la programmation (pour la simulation).

Conclusion
Nous espérons que ce programme vous enthousiasmera et vous donnera les outils nécessaires
pour aborder les défis scientifiques de manière innovante et efficace !
 Première partie

Python pour le calcul numérique

5
 6

Bonjour et bienvenue dans cette partie consacrée aux librairies Python pour la Data Science,
plus précisément pour le calcul numérique.

Dans cette partie, vous allez découvrir les bonnes pratiques et les connaissances fondamen-
tales qui vous aideront à effectuer vos analyses de données ou calculs scientifiques à l’aide de
librairies Python. Vous verrez comment utiliser des librairies Python comme NumPy, Pandas,
Matplotlib ou encore Seaborn pour explorer vos données et les analyser. D’autre part pour
sauvegarder ou présenter vos résultats( sous forme de graphiques). À l’issue de cette partie, vous
saurez :
• manipuler des tableaux avec NumPy ;
• créer des data frames avec Pandas ;
• construire des data visualisations avec Matplotlib et Seaborn.
Python possède de nombreuses librairies, utilisées dans tous les domaines. Pour pouvoir traiter
une grande quantité de données, il est essentiel d’observer quelques règles de base, que vous
allez découvrir dans ce cours.

Dans la première partie, vous prendrez en main NumPy à travers la création d’arrays et de
tableaux de données.

Ensuite, dans la seconde partie du cours, vous créerez vos premiers data frames grâce à Pandas,
et vous les manipulerez grâce à différentes fonctions.

Pour finir, dans le dernier chapitre, vous construirez des data visualisations grâce aux librairies
Matplotlib et Seaborn.

Contexte du travail pratique : des données réelles sur le revenu

Tout au long du cours de cette partie, vous allez vous mettre dans la peau d’une personne
travaillant dans un service data au sein d’une banque. Plus précisément, vous travaillez pour
la filière gérant les différents prêts. L’objectif sera d’utiliser les connaissances acquises sur
les librairies Python pour aider l’agence dans différentes tâches. Les exercices de fin de
chapitres pourront porter sur d’autres thématiques.

Pour ce faire, vous pourrez pratiquer dans des notebooks créés pour l’occasion. Afin de
trouver les solutions justes, je vous recommande :
1. raisonner sur des feuilles de papier ;
2. résoudre mathématiquement les exercices sur vos feuilles ;
3. traduire vous solutions en algorithmes ;
4. simuler vos algorithmes c’est-à-dire traduire vos algorithmes en Python.

Dans cette première partie du cours, nous nous appuierons sur des fondations solides, largement
inspirées par les éclairages pertinents et la structure pédagogique du remarquable travail de
Benjamin Marlé et Nicolas Rangeon pour [Link]. Leur approche constitue une
base précieuse pour appréhender ces concepts initiaux.
 Manipulez des tableaux avec NumPy
1
Les Data Analysts, les Data Scientists ou Mathématiciens ont au quotidien à manipuler des
données en grande quantité et de sources très variées. Celles-ci sont généralement représentées
sous la forme de listes ou tableaux de nombres. Cependant, les objets natifs de Python sont assez
limités pour les manipuler correctement.

Considérons par exemple la liste suivante, représentant le revenu mensuel de cinq clients de
notre banque :

revenus = [1800, 1500, 2200, 3000, 2172]

Si on souhaite calculer la moyenne des éléments de cette liste, il n’y a pas de fonction Python
existante par défaut permettant de le faire : il faudrait la recoder soi-même ! C’est encore plus
compliqué si on souhaite avoir une information plus spécifique, comme la médiane. C’est là que
la librairie NumPy intervient !

Diminutif de Numerical Python, Numpy elle fournit un ensemble de fonctions pour effectuer
efficacement des opérations sur les données, mais propose également un objet qui est au cœur
de presque tout l’écosystème data en Python : l’array.

Découvrons un peu plus en détail cette librairie, et pourquoi elle est aussi réputée dans l’envi-
ronnement data Python aujourd’hui !

Remarque 1.1. Si Numpy n’est pas installé dans votre ordinateur, vous pouvez l’intaller en
ligne de commande via l’instruction : pip install numpy .

1.1 Diérenciez les arrays des listes classiques

1.1.1 Les arrays NumPy
Le tableau NumPy, ou array, en anglais, est d’une certaine manière similaire à une liste Py-
thon. Quel est son avantage ? Il permet d’effectuer simplement et rapidement de nombreuses
opérations complexes telle que celles d’algèbre linéaire, en plus de faciliter le stockage et la

7
1.1. DIFFÉRENCIEZ LES ARRAYS DES LISTES CLASSIQUES 8

manipulation des données.

Reprenons notre exemple de calcul de la moyenne présenté ci-dessus. Dans les faits, la fonction
n’est pas très complexe. Elle pourrait s’écrire :

def moyenne(liste):
return sum(liste)/len(liste)

moyenne(revenus) # => 2134.4

Mais NumPy donne directement accès à une fonction existante.

import numpy as np # importation de la librairie Numpy

[Link](revenus) # calcul de la moyenne de la liste revenus

OK ça a l’air bien ... mais je ne vois pas non plus la révolution annoncée ?
C’est tout à fait logique, car la vraie révolution vient avec les arrays NumPy ! On estime qu’à
mesure que la taille du tableau augmente, des opérations via array NumPy deviennent environ
30 fois plus rapides que via une liste Python classique.

Cette différence aussi importante s’explique par le fait que les arrays NumPy ne peuvent contenir
qu’un seul et même type. En effet, contrairement à une liste classique où l’on peut stocker tous
types d’objets, NumPy n’acceptera qu’un seul type en entrée.

De plus, NumPy donne également accès à de nombreuses autres fonctions mathématiques indis-
pensables, applicables à des arrays ou même à des listes :

Quelques fonctions accéssibles grâce à NumPy

x = [-2, -1, 1, 2]
print("La valeur absolue: ", [Link](x))
print("Exponentielle: ", [Link](x))
print("Logarithme: ", [Link]([Link](x)))

Il existe encore de nombreuses autres fonctions, que je vous invite à découvrir dans la documen-
tation de NumPy. A présent, allons créer notre premier array.
0. Le lien est : [Link]
1.1. DIFFÉRENCIEZ LES ARRAYS DES LISTES CLASSIQUES 9

1.1.2 Créez un array NumPy

Vous pouvez créer un array de différentes façons, mais la plus simple est de le faire ... à partir
d’une liste Python classique :

Création d’une liste array

revenus_array = [Link](revenus)
revenus_array # array([1800, 1500, 2200, 3000, 2172])

Remarque 1.2. Dans un array :

• Si dans la liste de départ il y a des données de types différents, NumPy essaiera de tous les
convertir au type le plus général. Par exemple, si un tableau contient des entiers (int) et des
nombres décimaux (float), tous ses éléments seront convertis en nombres décimaux (float) ;
• vous pouvez accéder au type des éléments d’un array via la méthode .dtype.

Type des éléments d’un array

revenus_array.dtype
# dtype('int32')

Les types en NumPy seront toujours présentés via deux informations :

• le type (ici int) ;
• la précision (ici 32).
Cette dernière correspond au nombre de bits sur lesquels sont codés les nombres, définissant
ainsi les différentes valeurs possibles. Par exemple, un int8 (entier codé sur 8 bits) pourra
prendre des valeurs de -128 à 127 !

Pour plus d’informations sur les types NumPy, consultez la page Data types de la documen-
tation officielle.
[Link]

Il existe également des fonctions NumPy permettant de créer des arrays selon un certain pattern
ou une spécification particulière. Les plus couramment utilisées sont :
[Link](n) : permet de créer un array de n éléments contenant que des 0 ;
[Link](n) : permet de créer un array de n éléments contenant que des 1 ;
[Link](i, j, p) : permet de créer un array rempli avec une séquence linéaire, qui ira de i à j,
par pas de p ;
[Link](i, j, n) : permet de créer un array de n valeurs espacées uniformément entre i et j.
Voyons à présent comment sélectionner des éléments au sein d’un array NumPy.
1.2. SÉLECTIONNEZ DES ÉLÉMENTS AU SEIN D’UN ARRAY 10

1.2 Sélectionnez des éléments au sein d'un array

Comment accéder à un ou plusieurs éléments d’un array ? Tout comme avec une liste classique,
nous pouvons faire cela via l’indice de ces derniers.

1.2.1 Accédez à un seul élément

L’accès à un élément spécifique d’un array se fait via la syntaxe : nom_array[indice].
Accédez à un élément d’un array ou modifiez sa valeur
revenus_array[4] # pour accéder au 5ème élement

revenus_array[-1] # pour accéder au dernier élément

revenus_array[1] = 1900 # pour modifier la valeur du 2ème élément

1.2.2 Accédez à plusieurs éléments contigus

Nous pouvons accéder à un ensemble d’éléments contigus en combinant [] et :. La syntaxe suit
une règle simple : nom_array[i:j:p], avec :
• i : l’indice du début ;
• j : l’indice de fin ;
• p : le pas.
permettant de sélectionner tous les éléments compris entre l’indice i inclus, jusqu’à j-1, l’élé-
ment d’indice j est exclu. La ligne : revenus_array[0:3] permet de sélectionner, au sein de
notre array revenus_array, l’ensemble des éléments de l’indice 0 (soit le premier élément) jus-
qu’à celui d’indice 2 (soit le troisième). L’élément d’indice 3 n’est pas inclus ! Si vous souhaitez
également le sélectionner, il faudra ajouter 1 à l’indice de fin : revenus_array[0:4].

Remarque 1.3. Lors d’un slicing, le début peut être omis si on veut commencer au début de la
liste (c’est-à-dire si début = 0). La fin peut être omise si on veut aller jusqu’au bout de la liste
(c’est-à-dire fin = -1 ou fin = len(liste)). Le pas, ainsi que le dernier :, peuvent être
omis si le pas est de 1 (-1 si la fin est inférieure au début).
Slicing
print(revenus_array[:3]) # Les 3 premiers éléments (de l'indice 0 à 2)

print(revenus_array[2:]) # Les éléments à partir de l'indice 2

print(revenus_array[::2]) # Un élément sur deux

Si le pas est négatif, le début et la fin du slice sont inversés. On peut utiliser cette propriété
1.2. SÉLECTIONNEZ DES ÉLÉMENTS AU SEIN D’UN ARRAY 11

pour inverser un tableau. Par exemple, l’instruction : revenus_array[::-1] inverse notre

tableau.

1.2.3 Accédez à plusieurs éléments selon une condition

On peut aller plus loin dans l’accès aux différents éléments. En effet, lors d’une étude de données
ou de calculs mathématiques on est régulièrement amené à devoir sélectionner une partie de nos
données, selon un critère (ex. un genre spécifique) ou une condition (ex. toutes les personnes en
dessous d’un certain âge). Les arrays NumPy permettent de faire cela !

En effet, de la même façon qu’il est possible de sélectionner des éléments via leur indice, il est
possible avec les arrays NumPy de renseigner la condition selon laquelle on souhaite sélection-
ner les éléments du tableau, avec l’écriture nom_array[condition de sélection].

Voilà par exemple comment sélectionner uniquement les valeurs supérieures à 2 000 :
Sélection conditionnelle d’éléments d’un array
revenus_array[revenus_array > 2000]
# array([2200, 3000, 2172])

Détaillons le fonctionnement de ce processus de sélection :

• Tout d’abord, on cite explicitement le nom de l’array avant les crochets, pour spécifier
dans quel array on souhaite effectuer la sélection ;
• Ensuite, on spécifie à l’intérieur des crochets la condition. Le résultat de ce qui est à
l’intérieur des crochets doit forcément être un array ou une liste de booléens ! Ici, si
on exécute uniquement la condition : revenus_array > 2 000. Vous verrez que vous
aurez simplement un array contenant uniquement des booléens, avec True lorsque la
valeur satisfait la condition, False sinon.

Remarque 1.4. On pourrait naïvement exécuter revenus_array[ > 2000] en pensant que
Python comprendra qu’on souhaite appliquer la condition à l’array qui est cité juste avant. Le
résultat sera une erreur. Il faut bien considérer que l’array dans lequel on sélectionne, et la
condition à appliquer, sont deux choses différentes. Même si cela concerne le même array, il est
nécessaire de le spécifier également dans la condition !

Il est naturellement possible de complexifier cela, avec plusieurs conditions :

Sélection conditionnelle imbriquée d’élément d’un array
revenus_array[(revenus_array > 2000) & (revenus_array < 3000)]
# array([2200, 2172])

Le et logique (respectivement ou logique) n’est pas matérialisé par le mot clé and (respec-
tivement or) comme dans une structure conditionnelle if classique, mais par le symbole
& (respectivement |). De plus, chaque condition doit être absolument délimitée par des pa-
renthèses, sous peine de rencontrer une erreur. Cette écriture s’explique par le fait qu’on ne
1.3. UTILISEZ LES MÉTHODES D’ARRAY 12

compare pas des booléens, mais des arrays de booléens, terme à terme.

Remarque 1.5. La syntaxe de sélection conditionnelle imbriquée ne permet pas uniquement de

sélectionner des éléments, mais qu’elle peut également être utilisée pour modifier des éléments
au sein d’un array. En effet, si vous exécutez :
• revenus_array[3] = 1790, cela signifie que vous remplacez le 4e élément de notre
array par 1790 ;
• revenus_array[revenus_array > 2000] = 0, vous remplacerez tous les éléments su-
périeurs à 2000 au sein de notre array par 0.
Il faut donc être vigilant en utilisant cette syntaxe, pour ne pas remplacer des valeurs qu’il
n’aurait pas été souhaitable de remplacer.

Découvrons à présent, quelques-unes des nombreuses méthodes applicables à des arrays.

1.3 Utilisez les méthodes d'array

Nous avons d’ores et déjà vu comment obtenir le type d’un array à partir de la méthode .dtype.
De la même façon, on peut accéder facilement aux dimensions de notre array via la méthode :
.shape.

Taille d’une liste array

revenus_array.shape
# (5,) on a array contenant 5 éléments

Le résultat nous indique qu’on a un array contenant 5 éléments (nous verrons ultérieurement
la raison de la virgule après le 5).

Aux arrays, on peut également appliquer de nombreuses opérations mathématiques grâce à des
fonctions intégrées (dont certaines sont programmées par des scientifiques comme vous et moi).

Quelques fonctions intégrées de NumPy applicable à une liste array

# calculer la moyenne
revenus_array.mean()

# calculer le maximum (ou le minimum) :

revenus_array.max()
revenus_array.min()

# accéder à l'indice de l'élement minimum (ou maximum) :

revenus_array.argmin()
revenus_array.argmax()
1.3. UTILISEZ LES MÉTHODES D’ARRAY 13

# ordonner (trier) par ordre croissant :

revenus_array.sort()
print(revenus_array)

# calculer la somme :
revenus_array.sum()

Cette liste est naturellement non exhaustive ! Vous pouvez trouver la liste de l’ensemble des
méthodes applicables à un array directement dans la documentation officielle.

Exercice d’application 1.1 (Consignes). Pour cette première tâche, nous avons à notre disposi-
tion les revenus de 10 clients de notre banque. Vous aurez à utiliser les différentes manipulations
présentées dans ce chapitre pour sélectionner certains revenus selon une condition spécifique,
et effectuer diverses opérations.

Je vous invite à lire le notebook préparé à cet effet et a compléter les portions de code dans les
cellules correspondantes. Ce notebook est disponible au lien : https: // colab. research.
google. com/ drive/ 1R2-Yjt-yGiSb5QL9BTjK6eH8kAAAGyJ2? usp= sharing
 Transformez vos données en tableaux
2
2.1 Créez un tableau avec NumPy
Jusque-là, nous n’avons vu que des tableaux/arrays à une dimension, mais on ne travaille que
très rarement avec une seule colonne 1 .

Prenons un exemple : vous travaillez dans le milieu bancaire et vous avez besoin de créer un
tableau où vous retrouveriez, en plus des revenus de vos clients, leurs mensualités de rembour-
sement de prêt, le nombre d’enfants à charge, et toute autre information susceptible de vous être
utile. Considérons les clients suivants :
• Hugo, un jeune homme de 21 ans, gagnant 1 400 par mois et n’ayant aucun enfant ;
• Richard, un homme de 54 ans, gagnant 2800 par mois et ayant 2 enfants ;
• Émilie, une femme de 27 ans gagnant 3 700 et ayant 3 enfants.
Nos données peuvent être représentées via ce tableau :
Nom Âge Revenus Nombre d’enfants
Hugo 21 1400 0
Richard 54 2800 2
Émilie 27 3700 3
Et voici comment pourrait se matérialiser ce tableau en Python, en utilisant des listes :

Créer un tableau en Python

hugo = [21, 1400, 0]
richard = [54, 2800, 2]
emilie = [27, 3700, 3]
tableau = [hugo, richard, emilie]

print(tableau) # afin d'afficher le tableau

1. Notons que la dimension d’un tableau réfère principalement au nombre de colonnes du tableau. En effet, les
variables que nous étudions ou créons au besoin sont principalement stockées dans les colonnes des tableaux.

14
2.1. CRÉEZ UN TABLEAU AVEC NUMPY 15

Décortiquons cela ensemble :

• Dans un premier temps, nous créons une liste pour chaque personne dans notre banque,
contenant l’ensemble des informations à disposition sur cette personne ;
• Enfin, nous créons une liste tableau dans laquelle nous stockons l’ensemble des différentes
listes créées précédemment.
La liste tableau contient donc 3 éléments, qui sont eux-mêmes des listes de 3 éléments : c’est
donc une liste de listes. Nous avons néanmoins toujours l’ensemble des limitations liées aux
listes, avec cette façon de faire.

Comment pourrions-nous faire alors ?

Vous vous en doutez très certainement, mais oui, encore une fois la réponse se trouve du côté
de NumPy et des arrays ! En effet, un array est un objet multidimensionnel, c’est-à-dire qu’il
est possible de créer des arrays de toutes dimensions, et que l’ensemble des méthodes d’array
prennent en compte ce côté multidimensionnel.

La façon la plus simple de créer un tableau est de le faire à partir d’une liste de listes Python,
comme avec une liste classique. Il suffira d’exécuter [Link](tableau) pour transformer
notre liste de listes en array NumPy de 3 lignes et 3 colonnes.

Voyons quelques autres exemples ensemble pour bien comprendre cette notion :

Créer un tableau d’array avec NumPy

tab1 = [Link]([[1, 2], [3, 4], [5, 6]])

tab2 = [Link]([[1, 2, 3], [4, 5, 6]])

Ces quelques lignes de code permettent de créer :

• un array tab1 de 3 lignes et 2 colonnes ;
• et un array tab2 de 2 lignes et 3 colonnes.

Remarque 2.1. Il est possible de créer des tableaux de plus de 2 dimensions. Par exemple, pour
un tableau en 3D il suffira d’utiliser une liste de listes de listes. Voyons quelques autres exemples
ensemble pour bien comprendre cette notion :

Créer un tableau d’array avec NumPy

matrix_3D = [Link]([
[[1, 2, 3], [4, 5, 6], [7, 8, 9]],
[[10, 11, 12], [13, 14, 15], [16, 17, 18]],
[[19, 20, 21], [22, 23, 24], [25, 26, 27]]
])

[Link] # nous donne les dimensions (axes de la matrice)

2.2. ANALOGIE ENTRE LES ARRAYS ET LES MATRICES 16

Dans NumPy, chaque dimension d’un tableau est appelée un axe. La matrice que vous avez
vue précédemment possède trois axes. Les tableaux à trois axes sont également appelés ta-
bleaux tridimensionnels (3D).

Pour accéder à un élément du tableau ci-dessus, vous devez fournir trois indices :

# Accéder à l'élément à la position (3,4) de la première dimension

matrix[0][2][3] # ou matrix[0, 2, 3]

Exercice 2.1. Créer un tableau NumPy de dimension 3 contenant 2 ligne et 4 colonnes. Vous
pouvez remplir le tableau avec n’importe quel nombre.

Comme précédemment, nous pouvons également utiliser des fonctions NumPy pour créer des
tableaux plus ou moins complexes. Voici quelques exemples de fonctions couramment utilisées :

Quelques ndarray particuliers

# un tableau de nxp rempli de 1
[Link]((n, p))

# un tableau de n lignes et de p colonnes contenant que des 0

[Link]((n, p))

# une matrice identité de taille nxn

[Link](n)

# matrice diagonale comportant les éléments: [1, 2, 3, 4]

[Link]([1, 2, 3, 4])

# un tableau de nxp rempli de valeurs aléatoires comprises entre 0 et 1

[Link]((n, p))

Reprenez ces fonctions et exécuter les dans votre propre environnement en changeant cer-
taines valeurs, pour bien appréhender leur fonctionnement.

2.2 Analogie entre les arrays et les matrices

Vous vous souvenez que j’ai évoqué le fait que NumPy était une librairie Python dessinée pour
les calculs scientifiques ? Les tableaux que nous avons vus ensemble jusqu’ici, matérialisés par
des arrays NumPy, portent le nom de matrices, en mathématiques. Le but premier de NumPy,
avant même toutes ses applications dans le domaine de la data, est de proposer des outils pour
manipuler ces matrices et effectuer ce qu’on appelle des calculs matriciels.
2.2. ANALOGIE ENTRE LES ARRAYS ET LES MATRICES 17

Remarque 2.2. Les matrices sont une composante essentielle de l’algèbre linéaire. Vous al-
lez forcément être amené à croiser à nouveau leur chemin si vous poursuivez dans l’analyse
de données ou le calcul numérique, car elles sont la base même de nombreuses méthodes de
modélisation.

2.2.1 Dénissez des matrices non aléatoire et aléatoire en NumPy

En NumPy une matrice est un array d’array c’est-à-dire un tableau de tableau ou un vecteur de
vecteur. Considérons les matrices A et B suivantes :
" # " #
1 2 5 10
A= , B= .
3 4 215 20

Matrices non aléatoires en NumPy

A = [Link]([[1, 2], [3, 4]])
B = [Link]([[5, 10], [15, 20]])

On peut également définir une matrice selon des conditions sur ces vecteurs.

Matrices non aléatoires en NumPy espacée selon un nombre de points

connus
num_points = 1000

D = [Link]([[Link](-100, 150, num_points) for i in range(3)])

display(D) # print(D) marche également mais est moins esthétique

Explication du code :
• Définition du nombre de points : num_points = 1 000 définit le nombre de points dans
chaque ligne du tableau. Ici, nous avons choisi 1 000 points.
• [Link](-100, 100, num_points) génère une séquence de num_points valeurs uni-
formément espacées entre −100 et 100. [[Link](-100, 150, num_points) pour i in
range(3)] crée une liste de trois lignes, chacune contenant num_points valeurs.
• [Link](...) convertit cette liste en un tableau NumPy.
• Affichage du tableau : print(D) affiche le tableau D afin qu’on vérifie si l’on a ce que
l’on veut.
En résumé, ce code crée un tableau NumPy de trois lignes, chaque ligne contenant 1 000
points uniformément espacés entre −100 et 150, puis affiche ce tableau.
2.2. ANALOGIE ENTRE LES ARRAYS ET LES MATRICES 18

Matrices non aléatoires en NumPy espacée selon un pas

# Pas entre les points
step = 0.5 # Par exemple, un pas de 0.5

# Créer les points en utilisant [Link] pour un espacement spécifique

E = [Link]([[Link](-100, 100 + step, step) for i in range(4)])

display(E)

Explication du code :
1. Définition du pas : step = 0.5 définit le pas entre chaque point. Vous pouvez ajuster
cette valeur selon vos besoins.
2. Création du tableau avec un espacement spécifique :
• E = [Link]([[Link](-100, 100 + step, step) for i in range(3)])
crée un tableau NumPy.
• [Link](-100, 100 + step, step) génère une séquence de valeurs allant
de -100 à 100 (inclus) avec un espacement de step.
• [[Link](-100, 100 + step, step) for i in range(3)] crée une liste
de trois lignes, chacune contenant des valeurs espacées selon step.
• [Link](...) convertit cette liste en un tableau NumPy.

Remarque 2.3. En Numpy, les vecteurs des matrices sont des vecteurs lignes. Ainsi lors de la
définition de matrice, il faudra avoir en tête que, par défaut, les vecteurs sont ajoutés ligne après
ligne.

Une matrice aléatoire est une matrice dont les cellules contiennent des valeurs aléatoires. En
Numpy, une matrice aléatoire peut-être vue comme un vecteur de vecteur(s) aléatoire(s).

Matrices aléatoires en NumPy

# matrice 3x3 avec des valeurs suivant une distribution exponentielle
S = [Link](scale=1.0, size=(3, 3))

# matrice 4x4 avec des valeurs suivant une distribution binomiale (nombre
# de succès pour 10 essais avec une probabilité de succès de 0.5).
T = [Link](n=10, p=0.5, size=(4, 4))

# matrice aléatoire 3x3 dont chaque cellule contient un élément

# sélectionné aléatoirement dans la liste [1, 2, 3, 4, 5]
U = [Link]([1, 2, 3, 4, 5], size=(7, 7))

# matrice 4x5 avec des valeurs aléatoires entières sur [0,10[

2.2. ANALOGIE ENTRE LES ARRAYS ET LES MATRICES 19

V = [Link](0, 10, size=(4, 5))

# matrice aléatoire de 3 lignes 2 colonnes suivant la loi uniforme sur [0,1[

W=[Link](0, 10, size=(3,2))

# matrice aléatoire de 3 lignes 2 colonnes suivant la loi uniforme sur [0,10]

X = [Link](0, 10, size=(3,3))

# matrice aléatoire 5x6 suivant une distribution normale de moyenne 4,

# d'écart type 0.75
Y = [Link](4, 0.75, size=(5,6))

# matrice aléatoire 4x5 suivant une distribution de Poisson de paramètre 2.1

Z = [Link](2.1, size=(4,5))

Ces fonctions de génération de matrices aléatoires ne sont pas exhaustives, il en existe

d’autres ! ! !

2.2.2 Réalisez des opérations d'algèbre sur des ndarray

Considérons les matrices A, B et C suivantes :
" # " # " #
1 2 5 10 2 4 6
A= , B= , C= .
3 4 215 20 8 10 12

La méthode .shape() qui retourne le couple (n, m) correspondant au format de la matrice.

Format de matrice (array)

[Link]
[Link]
[Link]

La méthode .reshape() permet de modifier le format d’une matrice tout en conservant tous
les éléments de la matrice. Par exemple : [Link](1,4) .

Comme elles sont de même dimension (même nombre de lignes et de colonnes), on peut calculer
la somme (ou la différence) de la matrice A et de la matrice B, en additionnant terme à terme
chaque élément : " # " #
1 + 5 2 + 10 6 12
A+B = = .
3 + 15 4 + 20 18 24
2.2. ANALOGIE ENTRE LES ARRAYS ET LES MATRICES 20

Addition et soustraction terme à terme de matrices

A+B
A-B

Il est également possible de faire une multiplication terme à terme via l’opérateur *, comme
avec une multiplication normale : A*B, cela s’appelle la multiplication élément par élément.

Cependant, lorsqu’on effectue des calculs matriciels, on utilise beaucoup plus ce qu’on appelle
le produit matriciel. C’est un calcul assez fastidieux à faire à la main –d’autant plus avec des
matrices de grande dimension– mais qu’un ordinateur n’a en revanche aucun problème à réaliser.

Avec NumPy, le produit matriciel se fait via l’opérateur @ : A @ C. Cependant, cet opérateur
n’est disponible que depuis Python 3.5. Avant cela, le produit matriciel se faisait via la fonction
dot de NumPy : AC = [Link](A, C). Cette dernière fonctionne toujours aujourd’hui, les deux
syntaxes sont donc possibles !

Dans NumPy, il existe une bibliothèque dédiée à l’algèbre linéaire et à la résolution matricielle
de problèmes mathématiques. Cette sous-bibliothèque s’appelle [Link]. Pour l’impor-
ter, il suffit d’ajouter l’une des instructions suivante :
import [Link] as linalg
from numpy import linalg

Ci-dessous quelques instructions Numpy permettant de faire de l’algèbre linéaire.

Quelques opérations d’algèbre linéaire avec des array

# Transposé d'une matrice
G = [Link](A) # ou encore: A.T
print("Transposée de A:\n", G)

# Transconjuguée d'une matrice

K = [Link]([[1+2j, 3+4j], [5+6j, 7+8j]])
K_transconj = [Link](K).T
print('Matrice initiale:\n {}
Matrice transconjuguée:\n {}\n' .format(K, K_transconj))

# déterminant d'une matrice

det_A = [Link](A)
print("Déterminant de A:", det_A)

# calcul du l'inverse d'une matrice

inv_A = [Link](A)
print("Inverse de A:\n", inv_A)
2.3. ACCÉDER AU ÉLÉMENTS D’UN NDARRAY 21

# valeurs propres et vecteurs propres

eigenvalues, eigenvectors = [Link](A)
display("Valeurs propres de A:", eigenvalues)
print("Vecteurs propres de A:\n", eigenvectors)

# Norme d'une matrice

A_n = [Link](A)

# Norme d'un vecteur

x = [Link]([1,2])
x_n = [Link](x)

2.3 Accéder au éléments d'un ndarray

Vous vous souvenez lorsque je vous ai dit que l’ensemble des méthodes d’array prenaient en
compte l’aspect multidimensionnel des arrays ? Je vous propose d’approfondir cela ensemble
dans les lignes ci-dessous. Nous verrons notamment :
• comment modifier un array existant ;
• comment accéder aux différents éléments d’un array via leurs indices ;
• quelques méthodes qui sauront se montrer utiles lors de calculs scientifiques.

2.3.1 Accédez à un ou plusieurs éléments d'un ndarray : slicing et

conditions imbriquées
Nous allons travaillez sur les données de 10 clients voulant un financement de notre banque. Sur
ces clients, nous avons trois informations : le revenu, la mensualité, l’âge.

import numpy as np

# revenu, mensualite, age

hugo = [1_300, 400, 23]
richard = [1_700, 560, 24]
emilie = [2_500, 900, 30]
gaspard = [3_000, 1_000, 22]
yohann = [2_400, 700, 34]
cloe = [3_000, 700, 34]
luc = [4_000, 1_200, 33]
rachel = [3_300, 950, 27]
maude = [1_850, 600, 25]
2.3. ACCÉDER AU ÉLÉMENTS D’UN NDARRAY 22

# creation du tableau python

tableau = [hugo, richard, emilie, gaspard, yohann, cloe, luc, rachel, maude]

tableau # affichage de nos donnees afin de vérifier leurs conformites

data = [Link](tableau) # creation du ndarray

data

2.3.2 Sélectionnez des éléments au sein d'un ndarray

Une fois les données obtenues, on peut sélectionner les éléments que l’on souhaite.

Slicing
# selection du premier element du tableau
data[0,0]

# selection de la premiere ligne

data[0,:] # ':' permet de signifier qu'on selectionne toute les colonnes

# selection de la troisieme colonne ie tous les ages dans nos donnees

data[:,2] # ':' permet de signifier qu'on selectionne toute les lignes

Sélections conditionnées
# selection de tous les clients dont l'age est inférieur à 25
data[data[:,2]<= 25]

# selection des individus ayant un revenu strictement superieur à 2000

data[data[:, 0]> 2000]

# selection d'individus de moins de 25 ans avec un revenu de plus de 2000

data[(data[:,2]<= 25) & (data[:, 0]> 2_000)]

Ajouter des ligne ou des colonnes à un ndarray

Plusieurs fonctions permettent d’ajouter des lignes ou des colonnes à des ndarray, les plus
utilisées sont :
vstack pour ajouter, à la fin du tableau existant, des lignes c’est à dire des individus ;
column_stack pour ajouter, à la fin du tableau existant, des colonnes c’est à dire des va-
riables.
2.3. ACCÉDER AU ÉLÉMENTS D’UN NDARRAY 23

# ajout d'un client

fred = [1_750, 700, 27]
[Link]((data, fred)) #ajout de la ligne

# ajout d'une variable sur la solvabilite.

# 1: solvable; 0: insolvable
solvability = [Link](0,2, size=11)
np.column_stack((data, solvability)) # ajout de la colonne

2.3.3 Extension de Numpy par SciPy

Pour le calcul scientifique, NumPy est une excellente bibliothèque, mais il existe également
d’autres bibliothèques puissantes en Python. SciPy est une bibliothèque qui étend les fonction-
nalités de NumPy avec des modules pour l’optimisation, l’intégration, l’interpolation, l’algèbre
linéaire, les statistiques, etc. Par exemple :

Il existe d’autres opérations liées aux matrices, dans la sous-bibliothèque linalg de SciPy :
expm : exponentielle d’une matrice ;
logm : logarithme d’une matrice ;
sinm, cosm, tanm : fonctions trigonométriques sur des matrices ;
sqrtm : racine carrée.
Z 1
Pour calculer x2 dx :
0
from [Link] import quad

def integrand(x):
return x**2

result, error = quad(integrand, 0, 1)

print("Résultat de l'intégration:", result)

Remarque 2.4. Afin de programmer, nous même les algorithmes de résolutions de nos pro-
blèmes nous utiliserons peu SciPy. Cela, permettra une grande maîtrise des concepts de pro-
grammation mathématique.

Nous pourrons utiliser SciPy, en seconde option, pour l’initiation à l’usage de fonctions de
calcul scientifique dédiées.
2.4. EXERCICES 24

2.4 Exercices
Tous les exercices sont à traiter dans un notebook. Afin de trouver les solutions justes, je vous
recommande :
1. raisonner sur des feuilles de papier ;
2. résoudre mathématiquement les exercices sur vos feuilles ;
3. traduire vous solutions en algorithmes ;
4. simuler vos algorithmes c’est-à-dire traduire vos algorithmes en Python.

2.4.1 Exercice d'application de n de chapitre

Exercice d’application 2.1. Pour cette seconde tâche, nous travaillons toujours sur les mêmes
10 clients, mais nous avons cette fois trois informations à disposition sur chacun d’eux :
• le revenu mensuel ;
• l’âge du client ;
• le nombre d’enfants à charge.
L’objectif va être de créer un tableau NumPy à partir de ces informations, et de répondre aux
différentes demandes formulées par notre service Prêt, en manipulant ce tableau avec les diffé-
rentes techniques présentées tout au long de ce chapitre.

Je vous invite à suivre ce lien pour retrouver l’exercice : https: // colab. research. google.
com/ drive/ 1MNhJ5rcO68nI4XcLkdoiAAigLbICpH3t? usp= sharing

2.4.2 Exercices complémentaires

Nous passerons du temps à jouer à Lights Out !, un jeu électronique des années 1990 (qui peut
encore être joué en ligne à ce lien 2 ) où l’objectif est d’éteindre toutes les lumières en appuyant
dessus (ce qui modifie également l’état des lumières voisines). Bien que le jeu puisse paraître
simple, le résoudre nécessite la résolution d’un système linéaire [1].

2. Le jeu peut-être joué sur : [Link]

2.4. EXERCICES 25

Lors de simulations Python, nous programmerons le jeu en utilisant des matrices. Cela inclura à
la fois la programmation du jeu et celle d’un solveur. Nous aborderons les questions suivantes :
• Peut-on toujours gagner à partir de n’importe quelle configuration initiale ?
• Si une solution existe, est-elle unique ?
• S’il existe plusieurs solutions, comment trouver celle avec le nombre minimal de mouve-
ments ?
Les exercices ci-dessous ont pour but de créer le jeu Lights out (Exercices 2 à 4) puis de savoir
dans quelles dimensions le jeu a toujours une solution (Exercice 6) puis de créer un solutionneur
(Exercices 5 à 8).

Exercice 2.2 (Création des matrices croix). Créer une fonction Croix(i, j, n) qui crée la
matrice Ci, j de taille n2 avec des 1 seulement en (i, j) et les voisins verticaux et horizontaux. Il
y aura des zéros aux autres positions.

Les exercices suivants ne sont pas indépendants ! ! ! Je vous invites à lire tous les énoncés avant
de débuter leur résolution.

Exercice 2.3 (Jeu 3×3). Dans cette question, on demande de créer une fonction Lights_Out()
sans variable d’entrée qui lance le jeu avec les indications :
1. Phrase d’accueil dans le jeu,
2. Tirage d’une configuration aléatoire avec la commande [Link]() de Numpy,
3. Affichage de la configuration initiale,
4. Demande de la case où le joueur veut jouer,
5. Récupération du numéro de ligne et de colonne avec la commande input(),
6. Mise à jour de la configuration et affichage de celle-ci.
7. On continue jusqu’à ce que le joueur éteigne toutes les lampes et dans ce cas, on affiche
un message de félicitations et on sort du jeu.

Exercice 2.4 (Matrice de passage). Créer une fonction Matrice_Passage(n) qui prend en
entrée la dimension n et retourne la matrice dont les vecteurs sont les Ci, j exprimés dans la base
canonique de Mn (F2 ). On prendra les Ci, j dans le même ordre que les vecteurs Ei, j de la base
canonique.

Exercice 2.5. On veut déterminer pour quelles dimensions le jeu a toujours une solution.
1. Écrire une boucle qui calcule pour n = 2 à 11, le déterminant de Matrice_Passage(n).
On rappelle que ce déterminant est un nombre dans F2 , c’est-à-dire 0 ou 1. Comme Py-
thon fait les calculs avec des nombres à virgule flottante, il pourra être utile d’utiliser les
commandes round(), int() et ajouter %2 pour avoir le reste dans la division euclidienne
par 2.
2. Donner la liste des dimensions inférieures à 11 pour lesquelles le jeu possède une solution
unique pour toute configuration initiale
2.4. EXERCICES 26

Exercice 2.6 (Inverse de la matrice de passage en dimension 3). Grâce à Python, calculer l’in-
verse de la matrice de passage en dimension 3. On pourra soit :
• faire les calculs avec la commande [Link]() de Numpy, se ramener aux entiers puis
réduire modulo 2 ou charger le package Scipy ;
• changer le type de la matrice avec Matrix() et calculer l’inverse dans M(F2 ) avec la
méthode .inv_mod(2).

Exercice 2.7 (Solutionneur en dimension 3). Écrire une fonction Solution(A) qui prend en
entrée une configuration initiale sous forme d’une matrice A de format 3 × 3 et retourne une
matrice solution S (qui contient des 1 pour les cases où il faut appuyer et des 0 ailleurs).

Exercice 2.8 (Bonus). Créer une interface graphique pour le jeu grâce à la bibliothèque Py-
game. On pourra le faire en dimension 3 puis laisser le choix de la dimension au joueur, ajouter
un bouton pour afficher la solution (Dans ce cas, on tirera la solution au hasard et la configu-
ration initiale sera son image par la matrice de passage) ...
 Créez votre premier data frame avec Pandas
3
Comme nous avons pu le voir, les arrays NumPy sont particulièrement efficaces pour traiter des
valeurs numériques. Mais les données, dans la réalité, ne sont pas composées uniquement de
chiffres et de nombres. En effet, on retrouve aussi :
• des catégories ;
• des labels ;
• des dates ;
• du texte brut.
De plus, ces données ont généralement un format prédéfini en analyse de données, où chaque
ligne va correspondre à un individu (au sens statistique du terme), et chaque colonne va être une
caractéristique spécifique des individus. C’est ce que l’on appelle une variable. Voici quelques
exemples pour illustrer cela :
• dans le milieu automobile, chaque individu sera une voiture, et on pourra avoir comme
caractéristiques la puissance du moteur, les dimensions du véhicule, la marque, le modèle,
la couleur, etc. ;
• dans une étude de grande distribution, chaque individu pourra être un produit sur lequel
on aurait plusieurs informations (le prix, la catégorie, etc.) ;
• dans le milieu bancaire enfin, chaque individu sera une personne, sur laquelle on aurait
enregistré le salaire moyen, le genre, ses mensualités de remboursement de prêt, etc. ;
Voilà par exemple à quoi pourrait ressembler ce dernier cas.

F IGURE 3.1 – Base de données au format excel

27
 28

Excel est encore pour beaucoup d’entreprises un format très utilisé pour stocker et déplacer des
données. Mais ce n’est pas le seul, les données peuvent être stockées sous bien des formats
différents. Par exemple, on retrouve régulièrement des fichiers texte ou des fichiers CSV (pour
comma-separated values). Ce sont simplement des fichiers contenant l’ensemble des données
brutes, séparées par un délimiteur.

Voici un exemple avec un jeu de données automobiles, dont le délimiteur est le point-virgule :
La base de données peut également être sous la forme de fichier JSON. Le JavaScript Object

F IGURE 3.2 – Base de données au format CSV

Notation (JSON) est un format standard utilisé pour représenter des données structurées. Cela
ressemble à un gros dictionnaire Python pouvant contenir lui-même d’autres dictionnaires et/ou
listes. C’est une description un peu "réductrice", mais une image vaut mieux que mille mots :
Nous n’aurons malheureusement pas l’occasion d’approfondir le format JSON dans le cadre de

F IGURE 3.3 – Base de données au format JSON

ce cours, mais il existe de nombreuses ressources qui traitent le sujet en détail. Le JSON est un
format très standard dans le monde informatique !

Remarque 3.1. Nous n’avons ici vu que les formats texte, JSON et CSV, mais la liste n’est
naturellement pas exhaustive. De plus, plutôt que de stocker les données dans des fichiers, on a
3.1. GÉNÉREZ UN DATA FRAME 29

plutôt l’habitude de le faire dans des bases de données SQL.

Dans ce chapitre nous recherchons un outils qui nous permette de représenter les données avec
le format souhaité (individus/variables), de manipuler différents types de données, et de lire les
données provenant de différentes sources. Cet outil n’est autre que la librairie Pandas, et plus
particulièrement les objets data frame.

Le data frame est un objet Python permettant de représenter les données sous forme de tableau,
où chaque colonne est explicitement nommée. Il reprend les mêmes paradigmes que l’array
NumPy : chaque colonne peut naturellement être d’un type différent, mais une colonne ne peut
contenir qu’un seul type ! Cette organisation simplifie l’accès aux variables, et permet de nom-
breuses manipulations de données plus ou moins complexes.

Question : quel est l’intérêt de la librairie NumPy si Pandas permet de faire mieux ?

Reponse : au fur et à mesure de ce cours, et plus globalement de vos futures modélisations,

que vous serez régulièrement amené à jongler entre les deux. Il est assez courant que certaines
méthodes appliquées à des data frames retournent des arrays, et qu’on ait besoin de retransformer
ces arrays en data frames à postériori. C’est pourquoi il est nécessaire de maîtriser les deux
librairies, pour être parfaitement armé avant de plonger dans une modélisation.

3.1 Générez un data frame

Nous allons explorer les différentes méthodes permettant de créer un data frame. On peut créer
un data frame à partir :
• de fichier(s) préexistant(s) dans divers formats tels que Excel, CSV, JSON, etc. ;
• de données contenues dans des arrays ou des dictionnaires.
La capacité de convertir des données en data frames est essentielle pour faciliter leur manipula-
tion et analyse dans des contextes variés.

3.1.1 Créer votre data frame à partir de chier(s) préexistant(s)

Nous allons créer un data frame à partir des formats cités ci-dessus ; je vous propose d’importer
le même jeu de données sous 3 formats différents : Excel, CSV et JSON.

Vous trouverez les trois fichiers dans ce dossier compressé :[Link]

com/courses/7771531/Ressources+t%C3%A9l%C3%A9chargeables/P2C1_clients.zip.
Création d’un data frame à partir de fichiers préexistant
import pandas as pd

# Importation du fichier csv qu'on stocke dans une variable

data_csv = pd.read_csv('[Link]')
3.1. GÉNÉREZ UN DATA FRAME 30

data_csv.head() # afin d'afficher les 5 premières lignes du dataset

# Importation du fichier json qu'on stocke dans une variable

data_json = pd.read_json('[Link]')
data_json.head()

# Importation du fichier excel qu'on stocke dans une variable

data_excel = pd.read_excel('[Link]')
data_excel.head() # .tail() permet d'afficher les 5 derniers éléments

Il est important de décompresser le dossier .zip et de placer les fichiers csv dans le même
dossier que le notebook jupyter pour en faciliter l’importation ! Sinon vous devrez utilisez
leurs adresses.

Une fois le data frame importé, commence alors le travail principal : la manipulation de données.
Et avant toute manipulation, il est nécessaire de connaître son jeu de données (dataset en anglais).

3.1.2 Créer un data frame à partir de données que vous avez

Il existe plusieurs méthodes pour créer un DataFrame à partir de données en Python, notamment
en utilisant la fonction DataFrame de la bibliothèque pandas. Ci-dessous quelques-unes des
méthodes les plus courantes.

À partir d'un dictionnaire

data = {
'Nom': ['Alice', 'Kouraogo', 'Alphonse'],
'Âge': [25, 30, 35],
'Ville': ['Paris', 'Lyon', 'Marseille']
}

df_dict = [Link](data)
df_dict.head()

L’index par défaut est une séquence numérique commençant à 0. Les colonnes du DataFrame
sont directement définies par les clés du dictionnaire. Cela n’est pas le cas quand le data frame
est créé à partir d’une liste.

À partir d'une liste de listes

3.2. IDENTIFIEZ LES CARACTÉRISTIQUES DE VOTRE DATA FRAME 31

data = [
['Alice', 25, 'Paris'],
['Kouraogo', 30, 'Lyon'],
['Alphonse', 35, 'Marseille']
]

df_liste = [Link](data, columns=['Nom', 'Âge', 'Ville'])

df_liste.head()

L’index par défaut est une séquence numérique commençant à 0. Les noms des colonnes du data
frame doivent être définies à l’aide de l’argument columns.

3.2 Identiez les caractéristiques de votre data frame

Pandas met à notre disposition plusieurs méthodes afin qu’on puisse analyser notre data frame.

3.2.1 Aperçu du data frame

Comme effectué ci-dessus, un bon réflexe à adopter après l’importation, et après toute transfor-
mation, est de visualiser le dataset, ou du moins quelques lignes, afin de vérifier que tout s’est
correctement déroulé. Pour cela, il existe deux méthodes principales :
• la méthode .head() permettant de sélectionner par défaut les 5 premières lignes du data
frame. Il est possible de préciser entre parenthèses le nombre de lignes à afficher ;
• la méthode .tail() permettant de sélectionner par défaut les 5 dernières lignes du data
frame. Il est également possible de préciser entre parenthèses le nombre de lignes à affi-
cher.

Remarque 3.2. Il n’est pas possible (par défaut) d’afficher plus de 60 lignes d’un data frame,
afin de ne pas surcharger inutilement le notebook. De façon globale, chercher à visualiser l’en-
semble d’un data frame n’est généralement pas une bonne pratique. Si cela est tout à fait envi-
sageable avec quelques dizaines de lignes, ça devient vite impossible avec plusieurs millions de
lignes ! Si vous cherchez à afficher plus de 60 lignes, vous aurez finalement comme résultat les 5
premières et dernières lignes du data frame.

Exemple
# chargement du fichier
import pandas as pd
data = pd.read_csv("[Link]")

# afficher les 5 premières lignes

[Link]()
3.2. IDENTIFIEZ LES CARACTÉRISTIQUES DE VOTRE DATA FRAME 32

# afficher les 2 dernières lignes

[Link](2)

# afficher les 5 premières et dernières lignes

data

On peut également accéder aux caractéristiques globales d’un data frame.

3.2.2 Caractéristiques globales d'un data frame

Lorsqu’on parle de caractéristiques globales, il est question ici des attributs, des informations
générales qu’on retrouve sur tous les data frames, et dont on aura besoin régulièrement.

En premier lieu viennent les dimensions d’un data frame. Combien d’individus (de lignes) ou de
variables (de colonnes) comportent un data frame ? Et combien de colonnes ? Tout comme avec
les arrays NumPy, il est possible de répondre à ces questions via l’attribut .shape :

Caractéristique globale d’un data frame

[Link]

Le résultat sera un tuple dont le premier élément correspond au nombre de lignes, et le

second au nombre de colonnes. On peut naturellement stocker le résultat de cet attribut dans
une variable pour réutiliser ces éléments ultérieurement :

size = [Link]
print(size[0]) # 228
print(size[1]) # 4

Au-delà du nombre de ligne et de colonnes, on peut avoir envie de connaître les types de cha-
cune de nos variables. On peut accéder à cela très simplement à partir de l’attribut .dtypes :

[Link]

Vous observez que le type des variables e-mail, nom et genre est objet, alors que nous
avons pourtant des chaînes de caractères. Cela est dû au fait que le type objet de Pandas
correspond en fait à une colonne de type chaîne de caractères (ou string).

Enfin, nous avons évoqué précédemment le lien qui peut exister entre Pandas et NumPy. Je
vous propose dès à présent de matérialiser ce lien en transformant notre data frame en array :

De Pandas à Numpy
clients_array = [Link]
display(clients_array)

Nous avons à présent un array NumPy en lieu et place d’un data frame.
3.2. IDENTIFIEZ LES CARACTÉRISTIQUES DE VOTRE DATA FRAME 33

Maintenant que nous sommes au point sur les informations générales d’un data frame. Dans le
chapitre suivant, nous allons découvrir un peu plus en détail ce que Pandas nous permet de faire
en termes de manipulation de data frame.
 Manipulez un data frame
4
Dans le chapitre précédent, nous avons importé notre premier data frame mais c’est loin d’être le
dernier. Une fois nos données correctement importées, la suite logique va être de les manipuler
à notre guise.

Voici un cas concret : nous souhaitons accéder à la liste de tous les e-mails des clients ayant
contracté un prêt dans la banque, à partir du data frame clients importé lors du chapitre pré-
cédent, pour créer une liste de diffusion pour des offres commerciales préférentielles. Comment
faire cela avec Pandas ? C’est ce que je vous propose de voir à présent !

4.1 Naviguez dans un data frame

Dans un data frame, chaque colonne est explicitement nommée, rendant la compréhension de
cette dernière plus claire, et permettant d’accéder à une colonne spécifique à partir de son nom !

Pour accéder à une colonne d’un data frame, il suffit d’utiliser la syntaxe :
nom_dataframe[nom_colonne].

Accéder à une variable (colonne) d’un data frame

Pour accéder à la liste des e-mails du data frame data importé dans le chapitre précédent :

data['email']

On peut même décider de stocker cette variable email (au sens des données) dans une autre
variable (au sens informatique, cette fois !) pour les besoins de la liste de diffusion présentée
ci-dessus. Ici, je crée une variable email dans laquelle je stocke tous les e-mails de ma base
clients :

email = data['email']

Question : comment accéder à plusieurs colonnes ?

34
4.2. DÉCOUVREZ L’OBJET SERIES DE PANDAS 35

Réponse : il suffit de stocker l’ensemble des noms des colonnes auxquelles vous souhaitez
accéder dans une liste. Voilà par exemple comment accéder aux colonnes : nom et l’e-mail :

Accéder à plusieurs variables (colonnes) d’un data frame

variables = ['nom', 'email']
data[variables]

Dans le code précédent :

1. On souhaite accéder au nom et à l’e-mail de nos clients. On crée donc dans un premier
temps une liste que l’on nomme variables, dans laquelle nous stockons l’ensemble
des noms des variables.
2. On utilise la même syntaxe que vu précédemment, pour sélectionner dans notre data
frame la liste des variables définie.
Vous pouvez réaliser ces deux étapes en une fois avec : data[['nom', 'email']].

Vous noterez que les variables s’affichent dans l’ordre dans lequel nous l’avons spécifié (ici : le
nom avec l’e-mail) et non comme elles sont disposées initialement (l’e-mail est avant le nom
dans notre data frame data). Et si vous vérifiez le data frame initial, vous verrez que l’ordre
initial est bien conservé. Ainsi, le processus de sélection nous permet de réorganiser l’ordre des
colonnes comme on le souhaite, sans modifier le data frame initial.

4.2 Découvrez l'objet Series de Pandas

Vous commencez à bien connaître l’objet data frame, mais une colonne d’un data frame n’est
plus un data frame ! En effet, il est temps de vous présenter le second objet de Pandas que vous
allez énormément utiliser, et qui est intimement lié au data frame : la Series.

En effet, chaque colonne de votre data frame est de type Series. Vous pouvez vérifier cela par
vous-même via la fonction type : type(data['email']). On obtient le résultat :
[Link].

Il est important de différencier le data frame et la Series. Même s’ils partagent de nombreuses
méthodes, certaines sont néanmoins exclusives à l’un ou l’autre, et cela peut être une source
d’erreur lors de l’implémentation d’analyse de données avec Python.

Remarque 4.1. Une différence évidente, mais que je me permets tout de même de noter : un data
frame a 2 dimensions avec plusieurs colonnes, alors que la Series n’a qu’une seule dimension.
Cela peut fortement vous aider lorsque vous utiliserez certaines méthodes, car vous pourrez
savoir à quel type d’objet vous faites face, en vous basant sur l’affichage que vous avez de ce
dernier (encore une raison d’utiliser la méthode .head).

Regardons la Figure 4.1.

4.2. DÉCOUVREZ L’OBJET SERIES DE PANDAS 36

(a) Exemple de data frame (b) Exemple de Series

F IGURE 4.1 – Différence d’affichage entre un data frame et un Series

La Figure 4.1a est relativement « jolie », avec une organisation en tableau, où chaque colonne
(une ici) est explicitement nommée : c’est un data frame. De plus, les informations affichées
en bas sont le nombre de lignes et de colonnes. C’est finalement assez logique, car nous avons
sélectionné ici 1 colonne.

Vous noterez que la Figure 4.1b est un peu plus austère et surtout, que les informations affichées
en bas ne sont pas les mêmes : c’est une Series.
En information, vous avez notamment le nom de la Series, la longueur (ou le nombre de lignes),
et enfin le type de la colonne (entier, chaîne de caractères, etc.).

Une Series ne peut contenir qu’un seul type, alors qu’un data frame, qui est finalement une
collection de Series, peut contenir des colonnes de types différents : une colonne d’entiers, une
colonne de nombres décimaux, etc.

Il est important de garder ces notions en tête lors de vos futures analyses de données. De nom-
breuses méthodes sont communes à ces deux objets, alors que d’autres sont spécifiques. Par
exemple, l’ensemble des attributs vus au chapitre précédent (shape, head, dtypes) existent
pour des Series. Mais certaines méthodes, notamment certaines que nous verrons un peu plus
tard dans ce cours, sont exclusives aux data frames, à cause de leur aspect multidimensionnel.

Voyons, à présent, quelques manipulations possibles avec des Series.

4.3. MANIPULEZ LES COLONNES 37

4.3 Manipulez les colonnes

Manipuler un data frame revient à manipuler ses lignes ou ses colonnes. Dans cette section, je
vous propose de voir quelques manipulations indispensables sur les colonnes (variables) d’un
data frame :
• créer ou supprimer une colonne ;
• renommer une colonne ;
• changer le type d’une colonne ;
• trier un data frame selon une ou plusieurs colonnes.

4.3.1 Modiez une colonne existante

Avant de voir comment créer une colonne, voyons comment en modifier une déjà existante.

Reprenons la syntaxe vue précédemment, nom_dataframe[nom_colonne]. Cette dernière per-

met d ?accéder à une colonne d’un data frame sans modifier ce dernier. Ce que vous ne savez
pas encore, c’est qu’elle permet également de modifier un data frame existant.

Considérons une variable informatique a déjà existante :

• on peut y accéder en l’appelant, lui appliquer plusieurs fonctions différentes (comme
print(a) pour l’afficher) sans modifier sa valeur ;
• mais on peut également définir ou changer sa valeur (a=4 qui stockera l’entier 4 dans notre
variable a).
C’est exactement la même chose avec une colonne d’un data frame :
• on peut y accéder et appliquer plusieurs fonctions et/ou méthodes : c’est ce que nous avons
fait jusque-là ;
• on peut également changer les valeurs qui se trouvent à l’intérieur.
Par exemple, si j’exécute :

data['nom'] = 1

Cela aura deux effets : cela va modifier la variable nom existante en remplaçant toutes les valeurs
par 1, et cela transforme également le type de la variable, comme vous pourrez le constater si
vous regardez la Figure 4.2 : nom était de type object avant la transformation (Figure 4.2a) ; elle
est à présent de type integer car 1 est un entier (Figure 4.2b).

Ainsi, si on le remplace par une valeur fixe (comme c’est le cas ici), cela aura pour effet de
remplacer l’ensemble des valeurs de notre colonne par cette valeur fixe, et changera le type de
la colonne dans le type de la valeur fixe spécifiée, qu’elle soit numérique ou non.

On peut également remplacer une colonne par un objet de même dimension. Comprenez par là
une liste, un array ou une series comprenant l’exact même nombre d’éléments. Par exemple, si
4.3. MANIPULEZ LES COLONNES 38

(a) Avant la transformation (b) Après la transformation

F IGURE 4.2 – Transformation d’une colonne du type object vers le type integer

je souhaite modifier la colonne identifiant par elle-même multipliée par 100, je peux le faire de
la façon suivante :

Modifiez une colonne du data frame

data['identifiant'] = data['identifiant']*100

On peut ainsi décider de remplacer les données de la colonne par des valeurs aléatoires
suivant la loi de Poisson de paramètre 5 :

import numpy as np

data['identifiant'] = [Link](5,[Link][0])

Vous noterez que l’array généré pour remplacer les valeurs a strictement la même dimension
que la colonne qu’il remplace. Vous aurez une erreur si ce n’est pas le cas, donc soyez vigilant
sur cet aspect !

Si vous souhaitez revenir à vos valeurs originales après avoir modifié la colonne nom, vous ne
pouvez pas compter sur Pandas pour conserver un historique des data frames. À la place, vous
pouvez recharger les données originales en utilisant pd.read_csv.

Remarque 4.2. En pratique, on ne modifiera une colonne que lorsqu’on est vraiment sûr de
nous, afin justement de ne pas supprimer par mégarde des données dont on aurait besoin.

4.3.2 Créer et supprimez une colonne

Pour créer une colonne, on procède de la même façon que pour modifier une. Cette nouvelle
colonne est créer à la fin du data frame.
4.3. MANIPULEZ LES COLONNES 39

Créez une colonne dans le data frame

Dans notre data frame, on souhaite créer une colonne nommée id.

# Méthode 1
data['id'] = 100 # création de la colonne
[Link]() #affichage du data frame

# Méthode 2: à partir d'une colonne préexistante

data['id'] = data['identifiant'] + 1000
[Link]()

Pour résumer, que ce soit pour modifier ou créer une colonne col, la syntaxe sera :
mon_dataframe['col'] = x où x représente soit une valeur fixe, soit un objet de même
dimension que la colonne qu’on souhaite modifier/créer.

Pour supprimer une colonne dans un data frame, il existe (à ce jour) trois méthodes : .drop,
.del, .pop.

Supprimez une colonne dans un data frame

Dans notre data frame, on souhaite supprimer une colonne nommée id.

# Méthode 1: .drop
[Link](columns = 'id')

Contrairement aux deux options suivantes, la méthode .drop ne modifie pas le data frame
existant, elle renvoie juste une sorte de copie du data frame en y ayant appliqué les modifica-
tions, ici supprimer la colonne id. Vous aurez besoin de remplacer votre data frame pour pal-
lier cela : data_suppresion_definitive = [Link](columns='id', inplace=True)
pour supprimer définitivement la colonne.

# Méthode 2: .del
del data['id']
[Link]()

# Méthode 3: .pop
[Link]('id')
[Link]()

L’utilisation de l’une ou l’autre de ces méthodes dépendra de votre préférence.

4.3.3 Renommez une colonne

La méthode pour renommer une colonne est .rename. On peut ainsi renommer une ou plusieurs
colonnes via les syntaxes :
• mon_dataframe.rename(columns = {'ancien_nom': 'nouveau_nom'}) ;
4.3. MANIPULEZ LES COLONNES 40

• mon_dataframe.rename(columns={'ancien_nom1': 'nouveau_nom1', 'ancien_nom2':

'nouveau_nom2', . . . , 'ancien_nomN': 'nouveau_nomN'})
Renommez une ou plusieurs colonnes dans un data frame
Renommer la colonne nom en youre :

[Link](columns = {'nom': 'youre'})

Renommer les colonnes genre et email en sexe et mail :

[Link](columns = {'genre': 'sexe', 'email': 'mail'})

Remarque 4.3. la méthode rename ne modifie pas le data frame existant. Il existe cepen-
dant un argument pour cette méthode (et pour toutes les méthodes similaires) nommé inplace,
qu’il suffit de fixer à Vrai (True) pour pallier cela. Ainsi, [Link](columns={'sexe':
'genre'}, inplace=False) est strictement équivalent à data = [Link](columns={'sexe':
'genre'}).

4.3.4 Changez le type d'une colonne

La méthode .astype permet de changer le type d’une colonne. Par exemple, si on souhaite
transformer la colonne identifiant, initialement composée d’entiers, en nombres décimaux, on
peut le faire de la façon suivante :

data['identifiant'].astype(float)

4.3.5 Triez un data frame

En analyse de données, on a régulièrement besoin de trier des données selon une ou plusieurs
colonnes. Pandas met à disposition la méthode .sort_values pour faire cela très aisément. Il
suffit de préciser entre parenthèses la ou les colonnes selon lesquelles il faut trier. Voici quelques
exemples :

# trier selon l'identifiant, par ordre croissant :

data.sort_values('identifiant')

#trier selon l'identifiant par ordre décroissant :

data.sort_values('identifiant', ascending = False)

# trier selon le genre puis le nom, par ordre croissant :

data.sort_values(['sexee', 'youre'])
4.3. MANIPULEZ LES COLONNES 41

Le mot clé ascending permet de définir si on souhaite trier par ordre croissant ou décroissant.

Question : Comment procéder si on souhaite avoir l’un par ordre croissant et l’autre par ordre
décroissant ?

Réponse : il faudra donner une liste de paramètres (True ou False) à ascending.

Voici par exemple comment trier par sexe en ordre croissant et par youre en ordre décroissant :

data.sort_values(['sexe', 'youre'], ascending = [True, False])

Maintenant que nous sommes au point avec ces outils, mettons ce que nous avons appris en
pratique !

Exercice d’application 4.1. Nous allons travailler à présent sur notre fichier de prêts immobi-
liers. Chaque ligne du fichier correspond à un prêt qui a été accordé à un de nos clients. Chaque
client est identifié par : son identifiant ! Nous avons les informations suivantes :
• la ville et le code postal de l’agence où le client a contracté le prêt ;
• le revenu mensuel du client ;
• les mensualités remboursées par le client ;
• la durée du prêt contracté, en nombre de mois ;
• le type de prêt ;
• et enfin le taux d’intérêt.
Votre rôle cette fois-ci va être de modifier ce jeu de données pour calculer différentes variables
nécessaires pour identifier les clients à la limite de leur capacité de remboursement, et détermi-
ner les bénéfices réalisés par la banque.

Voici un exercice pour vous entraîner à manipuler un data frame : https: // colab. research.
google. com/ drive/ 1S3FkSdeckSNuuuoiGphc7piPfxgGMZyt? usp= sharing
 Filtrez les données du data frame
5
Imaginons les situations suivantes :
• pour une offre commerciale spécifique, on cherche à ne sélectionner que les hommes de
notre data frame ;
• on souhaite identifier les hauts revenus parmi notre clientèle. Pour cela, on souhaite sélec-
tionner tout ceux gagnant mensuellement plus de x ;
• on souhaite identifier les clients dits "risqués", c’est-à-dire ceux qui ont un taux d’endet-
tement supérieur aux 35% légaux.
Jusqu’à présent, nous avons été capables de sélectionner des colonnes spécifiques et de les ma-
nipuler à notre guise. Mais les exemples précédents ne peuvent être satisfaits avec de simples
manipulations de colonnes : il faut appliquer une condition spécifique pour ne sélectionner que
les lignes pertinentes.

Cette opération est ce qu’on appelle une restriction, ou un filtrage. Naturellement, Pandas permet
de faire cela, pour avoir un contrôle total sur nos données.

5.1 Appliquez la sélection via des indices

Le premier type de sélection est réalisé via des indices. Il se fait via la méthode .iloc. La mé-
thode .iloc suit la syntaxe suivante : mon_dataframe.iloc[indice_ligne, indice_colonne].

Exemple 5.1 (Sélection d’un élément). on souhaite sélectionner le nom du premier client de
notre base de données. Comme c’est le premier client, son indice de ligne sera 0. Nous souhai-
tons sélectionner son nom ; la variable nom est la 3ème variable de notre data frame, l’indice de
sa colonne sera donc 2. Le code de sélection serait donc :

mon_dataframe.iloc[0, 2]
'Laurent Dagenais'

42
5.2. UTILISEZ LA SÉLECTION VIA DES CONDITIONS 43

Question : Maintenant, admettons que je souhaite sélectionner le nom des 10 premiers clients,
comment procéder ?

Réponse : Comme avec les arrays, nous pouvons utiliser l’opérateur : pour sélectionner la
plage souhaitée.

Sélection de plusieurs éléments avec .iloc

# sélectionner le nom des 10 premiers clients :
[Link][:10, 2]

# sélectionner le genre des 10 premiers clients :

[Link][:10, 3]

# sélectionner toutes les colonnes des 10 premiers clients :

[Link][:10, :]

# sélectionner l'email et le nom des 10 clients à 20:

[Link][10:20, 1:3]

# sélectionner l'e-mail et le genre des 10 derniers clients :

[Link][-10:, [1, 3]] # On sélectionne les colonnes 1 et 3

La méthode .iloc peut être utile dans certains cas, mais elle est finalement assez limitée. En
effet, elle n’est pas adaptée si on souhaite sélectionner selon une certaine condition (par exemple
tous les revenus supérieurs à x), et il faut absolument connaître l’indice des différentes colonnes.
Cela reste jouable avec 5 − 6 colonnes, mais devient beaucoup plus compliqué lorsqu’on est en
présence de dizaines de colonnes.

Il existe une autre méthode, qui est similaire à .iloc mais qui permet de pallier l’ensemble de
ces inconvénients : la méthode .loc.

5.2 Utilisez la sélection via des conditions

Les data frames possèdent de nombreuses méthodes, comme vous avez pu commencer à vous
en rendre compte. Mais de toutes, il y en a certainement une que vous allez utiliser et réutiliser
à outrance : c’est la méthode .loc ! Celle-ci suit la syntaxe suivante :

mon_dataframe.loc[condition sur les lignes, colonne(s)].

C’est à première vue très simple, mais nous allons voir que cette syntaxe peut en pratique devenir
vite complexe, et peut permettre en même temps une grande flexibilité.
5.2. UTILISEZ LA SÉLECTION VIA DES CONDITIONS 44

Sélection de plusieurs éléments avec .loc

On va travailler avec le fichier [Link].

import pandas as pd

data = pd.read_csv('[Link]')
[Link]()

# Sélection des prêts de type automobile

[Link][data['type'] == 'automobile', :]

# Sélection des personnes ayant un revenu > 4_000

[Link][data['revenu'] > 4_000, :]

# Sélection des personnes ayant un revenu > 4_000 et un prêt automobile

[Link][(data['revenu'] > 4_000) & (data['type'] == 'automobile'), :]

# Sélection des personnes ayant un revenu > 4_000 ou un prêt automobile

[Link][(data['revenu'] > 4_000) | (data['type'] == 'automobile'), :]
---------------------------------------------------------------------------

# sélection des identifiants des personnes ayant contractés

# un prêt automobile
[Link][data['type'] == 'automobile', 'identifiant']

# sélection des identifiants et revenus des personnes ayant

# contractés un prêt automobile
[Link][data['type'] == 'automobile', ['identifiant', 'revenu']]

Une autre option de la méthode .loc est la sélection par index. Avant d’aller plus loin sur cet
aspect, laissez-moi redéfinir la différence entre des index et des indices ! Les indices sont la
position intrinsèque d’un élément au sein d’un tableau. Les index, en revanche, correspondent
à une valeur qui est associée à chaque ligne. C’est ce que vous voyez sur la gauche de votre
data frame : Par défaut, les index correspondent aux indices ! Mais ils peuvent ne pas être numé-
riques ; on pourrait par exemple fixer le nom de la personne comme index, si on est sûr qu’il n’y
aura pas de doublons.

Faisons un simple tri pour bien comprendre la différence entre l’indice et l’index (Figure 5.2) :
Cette situation est intéressante, car si on regarde notre première ligne, son index est 13. Pourtant,
c’est bel et bien la première ligne, donc son indice est 0 ! ! !

Je pense que vous commencez à comprendre la différence : un indice est relatif aux opérations
5.2. UTILISEZ LA SÉLECTION VIA DES CONDITIONS 45

F IGURE 5.1 – Localisation de l’index dans le data frame : colonne en rouge

F IGURE 5.2 – Différence entre index et indice

réalisées. Un individu peut avoir le premier indice à un moment, et un tout autre indice en
fonction du tri effectué. En revanche, l’index est intrinsèque aux lignes au sein d’un data frame.
Peu importe les opérations effectuées, que ce soit un tri, une suppression, etc., l’index sera
toujours le même ! La seule condition, c’est que chaque ligne doit avoir un index unique : c’est-
à-dire qu’il ne doit pas y avoir deux fois la même valeur au sein d’un index ; on ne pourra par
exemple pas avoir 2 fois l’index 0.

Question : Pourquoi parler de tout cela ?

Réponse : Parce qu’il est possible de faire une sélection au sein d’un data frame selon les
index, avec la méthode .loc.

Sélection selon les index avec .loc

On va travailler avec le fichier [Link].

display([Link][0:10, :]) # Sélection via les index

display([Link][0:10, :]) # Sélection via les indices

Remarque 5.1. Il est possible d’accéder à la liste des index d’un data frame via l’attribut
.index. Par exemple, [Link] nous renverra l’ensemble des index du data frame.
5.3. MODIFIEZ UNE SÉLECTION 46

Il est parfois intéressant, après avoir effectué certaines opérations, de réinitialiser ces index –
nous verrons dans les prochains chapitres des exemples concrets, où cela est même nécessaire.
C’est possible via la méthode reset_index().

Réinitialisation d’index
# création d'un data frame trié pour "désordonner" les Index
df_temp = clients.sort_values('nom')
display(df_temp)

# reset_index :
display(df_temp.reset_index())

# reset_index sans garder les anciens Index :

display(df_temp.reset_index(drop=True))

5.3 Modiez une sélection

Comme avec les colonnes, on peut utiliser les méthodes .iloc ou .loc pour modifier les lignes
d’un data frame existant. C’est même encore plus intéressant que ce que nous avions vu jusque-
là, car il est possible de modifier précisément une partie d’un data frame.

Modification d’une sélection

On va travailler avec le fichier [Link]. Mettons nous dans les situation où l’on veut accorder
une remise :
• à nos trois premiers clients à un taux de 1.05% ;
• à l’ensemble des personne de la région parisienne ;
• en ajoutant 0.05 au taux des individus de la région marseillaise

import pandas as pd

data = pd.read_csv('[Link]')
[Link]()

#%accès et modification de la valeur du taux des 3 premiers clients

[Link][:3, 7] = 1.05
[Link]()

# Pour les individus de la région parisienne

[Link][data['ville'] == 'PARIS', 'taux'] = 1.05
[Link](15)
5.3. MODIFIEZ UNE SÉLECTION 47

# taux + 0.05 pour les marseillais

mask = data['ville'] == 'MARSEILLE'
data['taux'].astype(int)
[Link][mask, 'taux'] = [Link][mask, 'taux'] + 0.05
[Link](15)

Un mask à l’intérêt de pouvoir être réutiliser ainsi que celui d’améliorer la lisibilité du code

Exercice d’application 5.1. Certaines demandes ont été spécifiquement formulées par le res-
ponsable du service Prêt de notre établissement. Il souhaite que vous puissiez appliquer les
traitements nécessaires pour lui donner des réponses précises.

Vous allez devoir mettre en application l’ensemble des processus de sélection présentés ci-
dessus, pour répondre à ces différentes demandes :

• Le taux d’endettement autorisé est de 35 %. Pourriez-vous me communiquer le nombre de

personnes ayant dépassé ce seuil ?
• Même question, mais cette fois-ci uniquement sur l’agence parisienne.
• Pour faciliter le traitement d’éventuelles futures demandes de prêts, pourriez-vous ajouter
une variable nommée risque, qui nous permettrait d’identifier facilement les clients à
risque ?
• Combien de prêts automobiles ont été accordés ? Quel est le coût total moyen de ceux-ci ?
• Quel est le bénéfice mensuel total réalisé par l’agence toulousaine ?

Voici un exercice pour vous entraîner à filtrer des données dans un data frame : https: //
colab. research. google. com/ drive/ 1JCqeRTFxsCFpUlyNSUn1hNYpKgou82rn? usp= sharing
 Maîtrisez les bonnes pratiques de la data
6
visualisation

6.1 Importance de la représentation graphique

Aujourd’hui, les entreprises du monde entier génèrent un volume de données extrêmement im-
portant : plusieurs dizaines de zettaoctets (milliards de téraoctets) selon les dernières estimations.
Et ce chiffre ne fait qu’augmenter exponentiellement au fur et à mesure que les technologies de
stockage évoluent.

Il devient donc indispensable pour une entreprise d’avoir des outils pour analyser ces données,
afin d’en tirer des enseignements exploitables au niveau business (des tendances d’achat selon
les périodes, par exemple) et plus globalement, de pouvoir surveiller les différentes activités de
l’entreprise afin d’identifier d’éventuels problèmes.

Toutes les librairies vues jusqu’à présent font partie de ces outils, mais demandent une certaine
technicité, au moins en programmation. Or, la plupart des personnes en charge de la stratégie au
sein d’une entreprise (ceux qu’on appelle les décideurs) n’ont généralement pas ce bagage.

Solution : il faut un outil permettant de rendre la donnée accessible à ces personnes ?

Tout à fait ! C’est ce qu’on appelle la data visualisation (ou dataviz). La data visualisation est un
ensemble de techniques utilisées pour communiquer des informations clés sur un gros volume de
données, afin d’en faciliter la compréhension et la lecture pour tous. Ce domaine s’est vraiment
démocratisé en entreprise dans les années 80, lorsque les entreprises ont pris conscience que
l’analyse de leurs données pourrait aider grandement à la prise de décision !

Remarque 6.1 (Selon Confucius : « Une image vaut mille mots. »). Cette citation résume assez
bien l’idée de la data visualisation. Car finalement, peu importe le choix du graphique ou de la
représentation, l’objectif final reste de résumer une information de façon visuelle, de sorte à ce
que quiconque puisse la comprendre et se l’approprier.

Lorsqu’il est question de représentation ou de graphique, de nombreux choix s’offrent à nous.

48
6.2. IDENTIFIEZ LE GRAPHIQUE ADAPTÉ 49

On peut citer de façon non exhaustive :

• les courbes pour représenter une évolution d’une caractéristique (comme la démographie
d’un pays) dans le temps ;
• les graphiques circulaires (ou graphiques camemberts) pour représenter une répartition ;
• des cartes lorsqu’on souhaite afficher une information géographique.
Il en existe bien d’autres, découvrons à présent de découvrir en détail les principales.

6.2 Identiez le graphique adapté

Le choix d’un graphique va énormément dépendre des différentes variables qu’on cherche à
représenter, et de l’information dont on dispose.

6.2.1 Présentez une évolution dans le temps

Ce cas se présente lorsqu’on souhaite représenter une variable numérique qui évolue dans le
temps : la notion d’évolution implique qu’on ne peut avoir qu’une valeur numérique par pas de
temps choisi – par mois, par année, etc.

F IGURE 6.1 – Data frame à expliciter en graphique

Pour représenter une évolution dans le temps, on peut utiliser :

• des diagrammes en ligne, ou en courbes ;
• des diagrammes à barres ou en bâtons.

F IGURE 6.2 – Exemple de diagramme en ligne

6.2. IDENTIFIEZ LE GRAPHIQUE ADAPTÉ 50

F IGURE 6.3 – Exemple de diagramme en barres

6.2.2 Comparez diérents groupes

On utilise ce type de graphique généralement lorsqu’on a des données agrégées sur une variable
non numérique. On a ainsi une valeur numérique agrégée par groupe ou par catégorie :

F IGURE 6.4 – Data frame à valeur numérique agrégée par quantité

Afin de représenter ces données, on peut utiliser des diagrammes circulaires, encore appelés
des camemberts.

F IGURE 6.5 – Exemple de diagramme circulaire

Mais l’idéal reste tout de même les diagrammes à barres.

6.2. IDENTIFIEZ LE GRAPHIQUE ADAPTÉ 51

F IGURE 6.6 – Autre exemple de diagramme à barres

6.2.3 Représentez une distribution

Ce type de graphique est particulièrement utile lors d’une analyse préliminaire, lorsqu’on sou-
haite comprendre les données à disposition, et la façon dont chaque variable se répartit. Il y a
deux cas possibles : une variable numérique et une variable non numérique.

Dans le cas d’une variable numérique, on utilise généralement un histogramme :

F IGURE 6.7 – Exemple d’histogramme

Il existe aussi une variante de l’histogramme, appelée diagramme à densité. Le diagramme à

densité est très utilisé pour représenter des variables quantitatives continue.

Dans le cas d’une variable non numérique, techniquement, c’est une visualisation que nous
avons déjà rencontrée. Car la première étape est d’agréger les données pour compter le nombre
d’occurrences au sein de notre variable, par catégorie ou groupe. Ensuite, on se retrouve simple-
ment dans le cas de comparaison cité ci-dessus : on peut utiliser un diagramme circulaire ou un
diagramme à barres.
6.3. BONNES PRATIQUES DE LA VISUALISATION DES DONNÉES 52

F IGURE 6.8 – Exemple de diagramme à densité

6.2.4 Représentez la relation entre deux variables numériques

Le dernier cas, que nous n’avons pas traité mais qui est couramment rencontré, est le choix
du graphique lorsqu’on souhaite représenter la relation entre deux variables numériques. Le
jeu de données contient dans ce cas plusieurs lignes, exprimées sur (au moins) deux variables
numériques.

F IGURE 6.9 – Data frame mettant en relation deux variables numériques

On peut tracer plusieurs points (un pour chaque ligne) en mettant l’une des variables en abscisse
et l’autre en ordonnée : c’est ce qu’on appelle un nuage de points.

La liste n’est naturellement pas exhaustive, et ce cours serait bien trop long s’il fallait tous les
traiter, mais voici cependant un bon échantillon des principales que vous allez être amené à
rencontrer.

6.3 Bonnes pratiques de la visualisation des données

Maintenant que nous avons différents graphiques à notre portée mais aussi savons dans quel
contexte utiliser chacun d’eux. Il est temps de faire un point sur la façon de réaliser ces gra-
phiques, ce qu’on pourrait résumer par : « les bonnes pratiques en data visualisation ».

Ce sont des « règles » simples qu’il est très vivement conseillé de suivre pour assurer la lisibilité
et la compréhension des visualisations.
6.3. BONNES PRATIQUES DE LA VISUALISATION DES DONNÉES 53

F IGURE 6.10 – Exemple de nuage de points

6.3.1 Privilégiez la simplicité

Lorsqu’on travaille dans l’analyse de données, on est souvent amené à travailler avec de nom-
breuses variables. Il est assez tentant de toutes les mixer en un seul graphique, en jouant par
exemple sur les couleurs, sur la taille des points, sur la forme des points, etc. Par exemple : Sur

F IGURE 6.11 – Un graphique « trop complexe » présentant cinq informations

ce graphique, les cinq informations suivantes sont présentées :

• la taille en abscisse ;
• le poids en ordonnée ;
• le revenu via la taille des points ;
• le statut marital via la forme des points.
Vous admettrez que même si on peut arriver à le lire en s’aidant de la légende, ce graphique est
trop chargé d’informations. Il vaut mieux dans ce genre de cas faire plusieurs graphiques avec
peu d’informations sur chacun, mais qui soient clairs et interprétables au premier coup d’œil !
6.3. BONNES PRATIQUES DE LA VISUALISATION DES DONNÉES 54

Afin d’éviter d’avoir un graphique illisible, privilégiez la simplicité, quitte à faire plusieurs
graphiques.

6.3.2 Clariez votre graphique

Il existe aujourd’hui de nombreuses représentations hyper stylées et complexes dans le monde
de la data visualisation. Gardez à l’esprit que votre but premier, lors de la création d’une visua-
lisation, est de rendre cette dernière la plus lisible possible. D’une certaine façon, un graphique
doit être autosuffisant : n’importe qui doit être en mesure de le lire et de le comprendre, à
partir des seuls éléments présents dessus et autour.

Imageons cela en considérant le graphique suivant :

F IGURE 6.12 – Exemple de graphique à clarifier

Ce graphique peut paraître sympa, mais ...

• de quoi parle-t-on ?
• Quelles sont les informations représentées ?
• À quoi correspond chaque barre ?
• À quoi correspond chaque couleur ?
Il manque beaucoup trop d’informations pour être en mesure de l’interpréter.

À présent, que dire de celui-ci (Figure 6.13) : C’est exactement le même graphique, sauf qu’à
présent, nous avons la grille de lecture pour le lire et le comprendre. Qu’est-ce qui a rendu cela
possible ?

Quatre choses :
• Les titres des axes. On a même ici précisé l’unité !
• La légende pour la compréhension des couleurs.
6.3. BONNES PRATIQUES DE LA VISUALISATION DES DONNÉES 55

F IGURE 6.13 – Un graphique clarifié avec des titres, une légende et des valeurs pertinentes

• Le titre, qui nous indique clairement de qui et de quoi on parle.

• Les valeurs indiquées au-dessus des barres pour éviter l’imprécision.

Faites toujours en sorte de donner l’ensemble des informations pertinentes à votre lecteur,
pour qu’il soit en mesure d’interpréter correctement son graphique.

6.3.3 Choisissez le graphique adéquat

Cela fait directement écho à la présentation des différents graphiques faite précédemment. Consi-
dérons le graphique suivant :

F IGURE 6.14 – Un exemple de graphique inadapté

Nous avons la quantité en stock de chaque catégorie (A, B, C ou D) de différents produits.

6.3. BONNES PRATIQUES DE LA VISUALISATION DES DONNÉES 56

Question : seriez-vous en mesure de dire dans quelle catégorie, entre B et C, nous disposons
le plus de stock ? Ce n’est pas évident, n’est-ce pas ? Prenons la visualisation pour les mêmes
données mais cette fois-ci avec un diagramme en barres :

F IGURE 6.15 – Un graphique plus adapté pour permettre de comparer les stocks

La différence est d’un coup beaucoup plus nette, la catégorie C possède plus de stock que la
catégorie B. Pourtant, ce sont exactement les mêmes données. C’est pour cela qu’un diagramme
en barres est généralement plus avisé qu’un diagramme circulaire, à partir du moment où il y a
plus de deux groupes à comparer.

En jouant sur les axes, les graduations, les couleurs, le type de graphique, etc., on peut
assez facilement masquer certaines informations sur un graphique, voire lui faire dire autre
chose que ce qu’il veut vraiment dire. Choisissez bien tous ces différents paramètres avec
précaution, afin de ne pas induire votre lecteur en erreur.

Allons tracer des graphiques avec Matplotlib ! ! !

 Tracez des graphiques avec Matplotlib
7
7.1 Découvrez Matplotlib
À ce stade, nous avons réuni de nombreuses informations sur nos clients, que nous pourrions
mixer et représenter au sein de différents graphiques. Par exemple, plutôt que d’avoir l’infor-
mation sous forme de tableau, il serait intéressant de représenter le chiffre d’affaires total par
agence. On peut aussi regarder le taux d’endettement de nos clients en fonction de leur revenu,
pour voir si une tendance se dégage.

Il nous faut donc une librairie pour réaliser ces différents graphiques avec Python. Il en existe
une multitude, et c’est parfois un peu compliqué de comprendre l’intérêt et la plus-value de
l’une par rapport à une autre. C’est pourquoi je vous propose de regarder en détail la librairie
principalement utilisée pour réaliser des visualisations : Matplotlib. Enfin, nous allons plutôt
utiliser pyplot qui est inclus dans Matplotlib.
Importer Matplotlib
import [Link] as plt

Chaque représentation graphique a une fonction correspondante avec Matplotlib :

• nuage de points ou scatter plot, en anglais : scatter() ;
• diagrammes en ligne ou en courbes : plot() ;
• diagrammes en barres (bâton) : bar() ;
• histogrammes : hist() ;
• diagrammes circulaires : pie() .

7.2 Tracez vos premiers graphiques

7.2.1 Nuage de points
Représentons le taux d’endettement en fonction du revenu. Ces deux variables sont numériques,
sans évolution dans le temps : nous allons donc tracer un nuage de points, via la fonction

57
7.2. TRACEZ VOS PREMIERS GRAPHIQUES 58

scatter. Cette fonction nécessite de définir x et y, qui sont les valeurs à placer en abscisse
et en ordonnée.

[Link](prets['revenu'], prets['taux_endettement'])

F IGURE 7.1 – Application de la fonction scatter

Il existe de nombreuses options pour personnaliser un nuage de points. On peut modifier :

• la couleur des points, en utilisant l’argument color ou c ;
• la taille des points, via l’argument size ou s ;
• le type de marqueur via l’argument marker ;
• la transparence des points via l’argument alpha .
Reprenons le même graphique, avec des croix rouges dont la taille aura été modifiée, et avec
50% de transparence :

[Link](prets['revenu'], prets['taux_endettement'],
s=60, alpha=0.5, c='red', marker='P')

F IGURE 7.2 – Application d’options sur la fonction scatter

Cette liste n’est pas exhaustive. Vous trouverez la liste complète des arguments sur la documenta-
tion officielle de la fonction : [Link]
[Link].
7.2. TRACEZ VOS PREMIERS GRAPHIQUES 59

On va maintenant représenter le chiffre d’affaires total par agence. Comme nous l’avons vu pré-
cédemment, il existe deux possibilités pour cela : soit un diagramme à barres, soit un diagramme
circulaire. Nous allons réaliser ces deux visualisations.

7.2.2 Diagramme circulaire

Là où nous autres francophones et amateurs de fromages voyons dans le diagramme circulaire
un camembert, les anglo-saxons y voient plutôt une tarte (pie, en anglais) à découper en plu-
sieurs parts ! C’est de là que provient le nom de la fonction permettant de tracer un diagramme
circulaire : pie. Son utilisation est très similaire à celle de scatter. Il y a deux arguments à
préciser : labels, correspondant à la variable non numérique, celle sur laquelle ont été agrégées
les données, et x, les valeurs agrégées correspondantes. La première étape va donc être d’agréger
les données.

data = [Link]('ville')['remboursement'].sum()
data = data.reset_index()

Le reset_index est nécessaire car nous allons avoir besoin de la variable ville dans la
création de nos prochains graphiques.

Traçons à présent notre diagramme circulaire à partir de ces données agrégées :

[Link](x=data['remboursement'], labels=data['ville'])

F IGURE 7.3 – Application de la fonction pie

On peut améliorer ce graphique en affichant textuellement le pourcentage associé à chaque

« part ». Pour cela, il faut spécifier un format numérique via l’argument autopct.

[Link](x=data['remboursement'], labels=data['ville'], autopct='%.2f%%')

Ce format permet d’afficher la part du chiffre d’affaires total réalisé par chaque agence, avec
2 chiffres après la virgule, et suivie du caractère % .
7.2. TRACEZ VOS PREMIERS GRAPHIQUES 60

7.2.3 Diagramme à barres

L’alternative au diagramme circulaire est un diagramme à barres ! On peut représenter exacte-
ment la même information, mais avec une perspective différente.

Pour utiliser la fonction bar, qui est l’implémentation de Matplotlib des diagrammes à barres, il
faut préciser deux arguments :
• x : les différentes valeurs de la variable non numérique, l’équivalent du labels de pie ;
• height : les valeurs agrégées, équivalent du x de pie .
Représentons maintenant la même information (le chiffre d’affaires total par agence) via un
diagramme à barres.

[Link](height=data['remboursement'], x=data['ville'])

F IGURE 7.4 – Application de la fonction bar

Remarque 7.1. Si vous souhaitez ordonner du plus grand au plus petit, il faudra tricher un petit
peu. En effet, la fonction bar de Matplotlib ne permet pas, par défaut, de réaliser cela. MAIS on
peut tout de même trier le data frame en amont.

data_sorted = data.sort_values('remboursement', ascending=True)

[Link](height=data_sorted['remboursement'], x=data_sorted['ville'])

F IGURE 7.5 – Application d’options sur la fonction bar

7.2. TRACEZ VOS PREMIERS GRAPHIQUES 61

7.2.4 Histogramme
Lorsqu’il s’agit de connaissance client dans le milieu bancaire, on arrive assez rapidement aux
questions :
• comment se répartissent nos clients en termes de revenus ?
• a-t-on majoritairement des classes moyennes ?
• des revenus plus modestes ?
Hormis le cadre bancaire, des questions de statistique descriptives se posent généralement.

L’histogramme est particulièrement utile lorsqu’on souhaite avoir une idée de la distribution
d’une variable, et donc particulièrement adéquat pour répondre à cette problématique. La fonc-
tion Matplotlib correspondante est hist. Il suffit de lui passer en paramètre la variable numé-
rique dont on souhaite connaître la distribution :

[Link](prets['revenu'])

Il existe de nombreuses possibilité de personnalisation, notamment sur le nombre de tranches,

leur composition, etc. Vous pourrez retrouver tout cela, dans la documentation de la fonction :
[Link] .

F IGURE 7.6 – Application de la fonction hist

En un coup d’œil, on peut déterminer, grâce à l’histogramme, que nous avons majoritairement
des revenus modestes au sein de notre clientèle.

7.2.5 Courbes
On souhaite suivre l’évolution du chiffre d’affaires sur les quatre premiers mois, pour voir la
façon dont il varie, et éventuellement anticiper la suite. Nous avons pour cela à notre disposition
le chiffre d’affaires réalisé par notre banque sur les prêts de janvier à avril 2013.
7.2. TRACEZ VOS PREMIERS GRAPHIQUES 62

evolution_ca = [Link]({
'date': ['2013-01-01', '2013-02-01', '2013-03-01', '2013-04-01'],
"chiffre d'affaire": [183000, 193020, 179032, 219174]
})

evolution_ca

On a ici une évolution dans le temps, donc le choix de représentation le plus pertinent serait de
tracer une courbe. Pour ce faire, on utilise la fonction plot de Matplotlib. Celle-ci prend deux
arguments en entrée : les informations à mettre en abscisse, et celles à mettre en ordonnée.

Traçons, l’évolution de notre chiffre d’affaire.

[Link](evolution_ca['date'], evolution_ca["chiffre d'affaire"])

F IGURE 7.7 – Application de la fonction plot

Il eut un chiffre d’affaires en hausse globale sur le premier tiers de 2013.

Remarque 7.2. Comme pour le nuage de points, il existe de très nombreuses options de person-
nalisation. Vous pouvez jouer sur la couleur de la ligne (color ou c), son style (linestyle ou
ls), son épaisseur (linewidth ou lw), si on souhaite ajouter un marqueur en plus de la ligne
(marker), etc. Vous trouverez l’ensemble des possibilités sur la documentation de Matplotlib.

Avec les mêmes données, traçons un graphique plot avec des lignes rouges hachurées, où on
ajoute un point à chaque date.
7.3. CRÉEZ PLUSIEURS GRAPHIQUES SUR UNE MÊME FENÊTRE 63

[Link](evolution_ca['date'], evolution_ca["chiffre d'affaire"],

marker='o', linestyle='--', color='red')

F IGURE 7.8 – Application d’options sur la fonction plot

Ces différents graphiques ne respectent pas vraiment les bonnes pratiques présentées précé-
demment. Ce n’est pas un oublie, on y remédiera dans le chapitre suivant.

7.3 Créez plusieurs graphiques sur une même fenêtre

7.3.1 Créez plusieurs graphiques dans une gure
Nous avons six agences différentes avec plusieurs dizaines de clients par agence. Le responsable
national souhaite avoir, en un seul graphique, une idée du comportement des agences en termes
d’attribution de taux, en fonction du revenu.

Question : représenter le revenu en fonction du taux est assez simple : on peut faire cela via
un nuage de points. Mais comment représenter, en plus, l’information de l’agence ?

Réponse En ajoutant une information supplémentaire à notre graphique, comme la couleur des
points ! Cependant, il n’existe pas d’option par défaut avec Matplotlib pour mettre en couleur
les points. On va être forcés de créer plusieurs graphiques –un par agence– qu’on va superposer
sur une seule et même fenêtre graphique.

# Importation des librairies et du jeu de données

import numpy as np
import pandas as pd
import [Link] as plt

data=pd.read_csv('prets_2.csv')
[Link]()
7.3. CRÉEZ PLUSIEURS GRAPHIQUES SUR UNE MÊME FENÊTRE 64

# Tracé du revenue en fonction du taux pour les villes

# de Paris et de Toulouse
df1 = [Link][data['ville']=='PARIS', :]
df2 = [Link][data['ville']=='TOULOUSE', :]

[Link](df1['revenu'], df1['taux_interet'], label='Paris')

[Link](df2['revenu'], df2['taux_interet'], label='Toulouse')
[Link]()
[Link]()

On a pu tracer pour deux villes. Afin de tracer pour toutes les villes ont va utiliser une boucle.

for temp in data['ville'].unique():

df = [Link][data['ville']==temp, :]
[Link](df['revenu'], df['taux'], label=temp)
# On affiche la legende et le graphique hors de la boucle
[Link]()
[Link]()

7.3.2 Créez plusieurs sous gures dans une même gure : subplot
La fonction figure de python permet de créer une figure en mui spécifiant des paramètres tels
que : la taille de la figure, la résolution en dvi, ...

import [Link] as plt

# Créer une figure avec des paramètres spécifiques

fig = [Link](figsize=(10, 6), dpi=100, facecolor='w', edgecolor='k')

# Créer deux sous-graphiques

[Link](1, 2, 1) # 1 ligne, 2 colonnes, premier sous-graphe
[Link]([1, 2, 3], [4, 5, 6])

[Link](3, 4, 2) # 3 lignes, 4 colonnes, deuxième sous-graphe

[Link]([1, 2, 3], [6, 5, 4])

# Afficher la figure
[Link]()

Dans le code Python précédent : Dans la fonction figure on a utilisé les arguments :
• figsize=(10, 6) : Définit la taille de la figure en pouces (largeur, hauteur).
7.3. CRÉEZ PLUSIEURS GRAPHIQUES SUR UNE MÊME FENÊTRE 65

• dpi=100 : Définit la résolution de la figure en points par pouce.

• facecolor='w' : Définit la couleur de fond de la figure (ici, blanc).
• edgecolor='k' : Définit la couleur du bord de la figure (ici, noir).
Pour les autres lignes de codes :
• [Link](1, 2, 1) : Crée un sous-graphe dans une figure avec 1 ligne et 2 co-
lonnes, et place ce sous-graphe dans la première position.
• [Link]([1, 2, 3], [4, 5, 6]) : Trace des données sur le premier sous-graphe.
• [Link](3, 4, 2) : Crée un sous-graphe dans une figure avec 3 ligne et 4 co-
lonnes, et place ce sous-graphe dans la deuxième position.
• [Link]([1, 2, 3], [6, 5, 4]) : Trace des données sur le deuxième sous-graphe.
• [Link]() : Affiche la figure avec les sous-graphiques.

Exercice d’application 7.1. Vous êtes en train de préparer le rapport mensuel à présenter
chaque fin de mois à votre responsable. La présentation devra comprendre certains graphiques
clés : vous allez donc devoir utiliser vos compétences en visualisation de données pour produire
les différentes visualisations attendues.

Les graphiques à produire sont donc :

• la proportion de chaque type de prêt ;
• le bénéfice mensuel réalisé en fonction du revenu du client pour les prêts immobiliers ;
• la distribution des bénéfices réalisés ;
• le bénéfice mensuel total réalisé par agence.
Je vous invite à vous entraîner avec cet exercice : https: // colab. research. google. com/
drive/ 1bpkYUS1qaS89VksVuhXSDkzm7nPZulfl? usp= sharing .
 Personnalisez vos graphiques avec Matplotlib
8
Nous avons jusque-là tracé de nombreux graphiques fonctionnels. Cependant, ils ne sont pas
vraiment conformes aux bonnes pratiques énoncées précédemment. En effet, sur la quasi totalité,
il manque des éléments indispensables pour faciliter la lecture, comme le titre, les titres des axes
ou la légende. Voyons maintenant comment ajouter tout cela avec Matplotlib.

8.1 Modiez les éléments extérieurs

Considérons les données suivantes dont le graphique est ci-dessous.
Ville Bordeaux Lyon Marseille Nice Paris Toulouse
Chiffre d’affaires 15330.59 26064.67 40895.72 23544.24 94052.61 19286.18

F IGURE 8.1 – Graphique de chiffre d’affaires total par agence

Vous remarquez que ce graphique est difficile à comprendre. Il lui manque en effet :
• l’information globale de ce qui est représenté : le titre du graphique ;
• des informations sur l’axe des ordonnées et sur l’unité utilisée !

66
8.1. MODIFIEZ LES ÉLÉMENTS EXTÉRIEURS 67

Afin de compléter les informations manquantes, nous utiliserons des fonctions supplémentaires
dans notre fenêtre graphique.

# Créons notre jeu de données

import pandas as pd

dict = {'ville': ['Bordeaux', 'Lyon', 'Marseille', 'Nice', 'Paris', 'Toulouse'],

'chiffre_aff': [15330.59, 26064.67, 40895.72, 23544.24, 94052.61, 19286.18]}
data = [Link](dict)
[Link]()

# Traçons et personnalisons notre graphique

import [Link] as plt

[Link](data['ville'], data['chiffre_aff'])
# Ajoutons un titre ayant une police: arial et une taille de 18
[Link]("Chiffre d'affaire réalisé par agence", fontname='Arial', fontsize=18)

# Renommons les axes des abscisses et des ordonnées

[Link]("Agences", color='red', fontweight='bold') # en rouge et en gras
[Link]("Chiffre d'affaire (¿)")
[Link]()

F IGURE 8.2 – Graphique de chiffre d’affaires total par agence après ajout d’éléments externes

On a ainsi un graphique complet avec une grille de lecture claire. Il existe cependant d’autres
options pour donner plus de clarté à une visualisation, ou pour en améliorer la qualité esthétique.
8.2. MODIFIEZ LES ÉLÉMENTS INTÉRIEURS 68

8.2 Modiez les éléments intérieurs

Pour un graphique, il y a de nombreux aspects internes au graphique sur lesquels on peut jouer.
Vous en avez déjà en aperçu un, avec l’affichage textuel des valeurs sur les pie plots ou les bar-
plots. Il est également possible de jouer sur les graduations (ou ticks, en anglais), le quadrillage,
ou encore les couleurs de fond.

(a) Avant modification (b) Après modification

F IGURE 8.3 – Graphique de chiffre d’affaires total par agence avant et après modification d’élé-
ments internes

Voyons comment passer de la Figure 8.3a à celle 8.3b.

# Traçons et personnalisons notre graphique

import [Link] as plt

[Link](figsize=(10,6)) #afin d'agrandir la taille de l'image

[Link](data['ville'], data['chiffre_aff'])
# Ajoutons un titre ayant une police: arial et une taille de 18
[Link]("Chiffre d'affaire réalisé par agence", fontname='Arial', fontsize=18)

# Renommons les axes des abscisses et des ordonnées

[Link]("Agences", color='red', fontweight='bold') #en rouge et en gras
[Link]("Chiffre d'affaire (¿)")

[Link](axis='y') # grille sur l'axe y

[Link](0, 120_000) # pour borner l'axe des y
[Link]([0, 30_000, 60_000, 90_000, 120_000]) #parametrer l'espacement sur l'axe y

ca = data['chiffre_aff'].tolist()
for i in range(len(ca)):
8.2. MODIFIEZ LES ÉLÉMENTS INTÉRIEURS 69

[Link](i-0.2, ca[i]+2_000, round(ca[i], 1))

[Link]("chiffre_affaire_agence") #enregistre la figure dans le dossier courant

[Link]()

Remarque 8.1. Ce que nous avons vu n’est qu’une partie de tout ce qu’il est possible de faire
avec Matplotlib. Plus on plonge dans l’aspect de personnalisation des graphiques, plus on se
rend compte que les possibilités sont infinies. Si vous souhaitez aller plus loin, je peux vous
rediriger vers ce notebook Jupyter (https: // nbviewer. org/ urls/ gist. githubusercontent. com/ Jwink3101/
e6b57eba3beca4b05ec146d9e38fc839/ raw/ f486ca3dcad44c33fc4e7ddedc1f83b82c02b492/ Matplotlib_ Cheatsheet ) qui ré-

pertorie des exemples concrets, que vous pourrez reproduire.

Exercice d’application 8.1. Les bénéfices mensuels par type de prêt pour l’année 2021 viennent
de sortir au niveau de l’agence où vous travaillez. Dans le cadre du rapport mensuel, il vous est
demandé de réaliser un graphique spécifique représentant cette évolution, par type de prêt.

Voici le graphique qui avait été obtenu l’an dernier :

On cherche à reproduire le même graphique avec les données de l’année 2021.

Je vous invite à vous entraîner avec cet exercice : https: // colab. research. google. com/
drive/ 1jkF6wpXEiHJfPkJOxTWcB-63vXrr_ QRK? usp= sharing
Deuxième partie

Calcul numérique

70
 Calcul numérique approché
9
9.1 Erreurs absolue et relative
Afin de définir les notions d’erreurs absolue et relative, nous avons besoin d’introduire les no-
tions de quantités ou de valeurs exactes et de quantités approximatives ou valeurs approchées ;
ce que nous illustrons ci-après au moyen d’exemples.
— Exemples de quantités ou de valeurs exactes :

√
 
1 2π
1, , 5, 3, π, ln 2, cos , e, ...
3 7

— Exemples de quantités approximatives ou de valeurs approchées (ci-après, en souligné) :

√
3 ≈ 1.732, π ≈ 3.14, ln 2 ≈ 0.69315, e ≈ 2.718, . . .

Soient x un nombre réel et x∗ une valeur approchée de x :

— Si x∗ > x, x∗ est dite valeur approchée par excès ;
— Si x∗ < x, x∗ est dite valeur approchée par défaut.

9.1.1 Erreur absolue

Définition 9.1. On appelle erreur absolue de x∗ sur x, la quantité : E = |x − x∗ |.

Remarque 9.1. — Plus l’erreur absolue de x∗ est petite, plus x∗ est précise.
— L’erreur absolue sert à déterminer la précision de la valeur approchée x∗ relativement à
la valeur exacte x.

9.1.2 Erreur relative

|x − x∗ | E
Définition 9.2. On appelle erreur relative de x∗ la quantité : Er = = .
|x| |x|

71
9.2. INCERTITUDES ABSOLUE ET RELATIVE 72

Remarque 9.2. — L’erreur relative est souvent exprimée en pourcentage.

— Elle est généralement utilisée pour comparer la précision de différentes valeurs appro-
chées x∗ , y∗ , z∗ , . . . relativement à différentes valeurs exactes respectives x, y, z, . . .

9.2 Incertitudes absolue et relative

Dans le cas où, en plus d’une valeur approchée qui lui est associée, une valeur exacte est connue,
il est possible de déterminer ses erreurs absolue et relative mais souvent cette dernière ne l’est
pas. Dans ce dernier cas, les erreurs absolue et relative deviennent impossible à calculer. Afin de
les apprécier on introduit alors les notions d’incertitude absolue et d’incertitude relative.

Définition 9.3. On appelle incertitude absolue d’une valeur approchée x∗ , tout nombre réel
positif, noté ∆x, vérifiant : E = |x − x∗ | ≤ ∆x ou de manière équivalente : x∗ − ∆x ≤ x ≤ x∗ + ∆x.

Remarque 9.3. — Une incertitude absolue est un majorant de l’erreur absolue.

— Plus ∆x est petite, plus la valeur approchée x∗ est précise. D’où, en pratique, on prend le
plus petit ∆x possible.
— On écrit : x = x∗ ± ∆x ou encore x ≃ (x∗ ± ∆x), qui exprime le fait que :
x ∈ [x∗ − ∆x, x∗ + ∆x].
x1 + x2
— Si x1 et x2 sont tels que : x1 ≤ x ≤ x2 alors x∗ = est une valeur approchée de x
2
x1 − x2
avec comme incertitude absolue : ∆x = .
2
— Souvent au lieu d’écrire : x = x∗ ± ∆x ou x ≃ (x∗ ± ∆x), on écrit : x = x∗ ± δ x.100% ou
encore x ≃ (x∗ ± δ x.100%) où la quantité δ x est définie par :

∆x
δx = .
|x∗ |

Cette quantité est appelée incertitude relative à x∗ .

— Si l’incertitude relative δ x est connue, on en déduit un encadrement du nombre exact x
comme ceci : x∗ (1 − δ x) ≤ x ≤ x∗ (1 + δ x) ou encore x = x∗ (1 ± δ x), car ∆x = x∗ |δ x|.

9.3 Représentation décimale d'un nombre approché

9.3.1 Représentation décimale d'un nombre approché
Tout nombre réel positif x peut être représenté sous la forme d’un nombre décimal de dévelop-
pement limité ou illimité :

x = am .10m + am−1 .10m−1 + · · · + am−n .10m−n + . . .

où les ai sont les chiffres du nombre réel x (ai ∈ {0, 1, 2, . . . , 9}), avec am ̸= 0 et m est un entier
naturel appelé rang supérieur du nombre réel x.
9.3. REPRÉSENTATION DÉCIMALE D’UN NOMBRE APPROCHÉ 73

Remarque 9.4. Dans le cas où le nombre réel x est négatif, il suffit de considérer la représen-
tation décimale du nombre y = −x.

Exemple 9.1. Considérons les exemples ci-dessous.

1. Exemple de développement limité :

7413.2680 = 7.103 + 4.102 + 1.101 + 3.100

+ 2.10−1 + 6.10−2 + 8.10−3 + 0.10−4 .

2. Autre exemple d’un développement limité (faire attention aux zéros !) :

0.041502 = 4.10−2 + 1.10−3 + 5.10−4 + 0.10−5 + 2.10−6 .

3. Exemple de développement illimité :

π = 3.14159265358 . . .
= 3 · 100 + 1 · 10−1 + 4 · 10−2 + 1 · 10−3
+ 5 · 10−4 + 9 · 10−5 + 2 · 10−6 + . . .

Dans la pratique on n’utilise, essentiellement, que des nombres approchés de développements

limités :

x ≃ bm 10m + bm−1 10m−1 + · · · + b1 101 + · · · + bm−n 10m−n , avec bm ̸= 0.

• Tous les chiffres bi , i = m, . . . , m − n, s’appellent chiffres significatifs du nombre appro-

ché x∗ .
• Certains des bi peuvent être nuls.

Les exemples suivants illustrent les cas où le zéro n’est pas considéré comme chiffre significatif.
• x∗ = 2.10−3 + 0.10−4 + 1.10−5 + 0.10−6 qui s’écrit en notation décimale x∗ = 0.002010.
Les zéros soulignés ne sont pas des chiffres significatifs.
• x∗ = 3.106 +0.105 +0.104 +7.103 +0.102 +0.101 +0.100 qui s’écrit en notation décimale
x∗ = 3007000. Les zéros soulignés ne sont pas des chiffres significatifs.

Question : En règle générale, comment reconnaître un chiffre significatif ?

Réponse : elle est apportée par la définition 9.4.

Définition 9.4. On appelle chiffre significatif (c.s.) d’un nombre approché, tout chiffre dans sa
représentation décimale différent du zéro ; et un zéro s’il se trouve entre deux chiffres significatifs
ou s’il constitue un chiffre conservé.
9.4. CHIFFRES SIGNIFICATIFS EXACTS D’UN NOMBRE APPROCHÉ 74

Exemple 9.2. 1. Une approximation à 6 décimales de 0.00502037 est :

2. Si on approche le nombre 1789 à la centaine près par 1800, à la place des chiffres négligés
8 et 9, on introduit deux zéros. Ils ne servent qu’à fixer l’ordre de grandeur du nombre
pris comme valeur approchée ; ce ne sont pas des chiffres significatifs. Par contre si on
approche le nombre 1789.7 à l’unité près par le nombre 1790, le zéro est alors un chiffre
significatif.

9.4 Chires signicatifs exacts d'un nombre approché

Soient x un nombre réel et x∗ une valeur approchée de x.

Définition 9.5. Un chiffre significatif de x∗ est dit exact (c.s.e) si l’erreur absolue de ce nombre
ne dépasse pas une demi-unité de rang du chiffre significatif, c’est-à-dire que :

E = |x − x∗ | ≤ 0.5 × l’unité de rang du c.s.

Ainsi :
— Le n-ième c.s après la virgule est exact si : |∆x| ≤ 0.5 · 10−n .
— Le n-ième c.s avant la virgule est exact si : |∆x| ≤ 0.5 · 10n−1 .
Attention ! Un c.s.e de x∗ ne coïncide pas nécessairement avec le c.s. correspondant dans x.

Proposition 9.1. — Si un c.s est exact, tous les c.s à sa gauche sont exacts.
— Si un c.s n’est pas exact, tous ceux à sa droite ne le sont pas.

Remarque 9.5. Si l’erreur absolue de x∗ ne dépasse pas une unité de rang du dernier c.s, on
dit que x∗ est une valeur approchée au sens large ou encore qu’il est une valeur approchée à
chiffres significatifs exacts au sens large.

9.5 Troncature et arrondissement d'un nombre

Pour approcher le nombre π = 3.14159265358 . . . , on peut considérer la valeur approchée 3.14
ou encore 3.14159, etc., selon le besoin. Dans le premier cas, le nombre π est tronqué (coupé en
éliminant une partie) après 2 décimales ; dans le second cas, après 5 décimales.
9.6. RELATION ENTRE ERREUR RELATIVE ET C.S.E 75

Une méthode habituelle pour tronquer un nombre pour ne garder qu’un nombre fini de chiffres
significatifs est l’arrondi.

Règle d’arrondissement. Pour arrondir un nombre jusqu’à n c.s, on élimine les chiffres à
droite du n-ième c.s conservé si l’on se trouve après la virgule, sinon on remplace par des zéros.
Dans les deux cas on procède de la manière suivante :
1. Si le (n + 1)-ième c.s est strictement plus grand que 5, on augmente le n-ième chiffre de
1. Si, par contre, il est strictement plus petit que 5, les chiffres retenus restent inchangés.
2. Si le (n + 1)-ième c.s est égale à 5 alors deux cas sont possibles :
— Tous les chiffres rejetés, situés après le (n + 1)-ième c.s, sont des zéros : on applique
la règle du chiffre pair, c’est-à-dire que le n-ième chiffre reste inchangé s’il est pair.
On lui ajoute 1 s’il est impair.
— Parmi les chiffres rejetés, situés après le (n + 1)-ième c.s, il existe au moins un qui
soit non nul : on ajoute 1 au n-ième chiffre.

Remarque 9.6. Si on applique la règle d’arrondissement ci-dessus, l’erreur absolue de la valeur

approchée ainsi obtenue, et qu’on appelle erreur d’arrondi, ne dépasse pas une demi-unité de
rang du dernier c.s. retenu, c’est-à-dire qu’on a :

E = |x − x∗ | ≤ 0.5 × l’unité de rang du dernier c.s. retenu.

Conséquence : un nombre correctement arrondi ne possède que des c.s.e.

9.6 Relation entre erreur relative et c.s.e

Proposition 9.2. Soient x un nombre réel, x∗ une valeur approchée de x et Er l’erreur relative
à x∗ .
— Si x∗ possède n c.s.e, alors Er < 5 · 10−n (sauf si le nombre est 1 suivi de (n − 1) zéros).
— Si Er ≤ 0.5 · 10−n alors x∗ possède au moins n c.s.e.

9.7 Exercices d'application

Exercice d’application 9.1. Vérifier que pour la valeur exacte x = 2/3, la valeur approchée
x1∗ = 0.666667 est 1 000 fois plus précise que la valeur approchée x2∗ = 0.667.
2 1
Exercice d’application 9.2. Pour les valeurs exactes x = et y = , on considère les valeurs
3 15
approchées x∗ = 0.67 et y∗ = 0.07. Comparer les précisions de x∗ et y∗ .
 Equations non linéaires
10
10.1 Racines d'équations non linéaires
Définition 10.1. Soit f : R −→ R une fonction donnée, définie sur une partie D f de R. On dit
que x∗ ∈ D f est une racine de l’équation non linéaire

f (x) = 0 (10.1)

s’il vérifie
f (x∗ ) = 0. (10.2)

Résoudre l’équation (10.1) consiste à déterminer tous les nombres réels x∗ ∈ D f tels que (10.2)
soit vérifiée. En d’autres termes, on cherche à déterminer l’ensemble R = {x ∈ D f : f (x) = 0},
qui est l’ensemble des racines de l’équation (10.1). Il n’est pas toujours possible de résoudre
complètement ce problème pour toutes les formes de fonctions f . L’ensemble R peut, en effet,
avoir un grand nombre de structures possibles.

Définition 10.2. On dit qu’une racine x∗ de l’équation (10.1) est séparable si on peut trouver
un intervalle [a, b] ⊆ D f tel que x∗ soit la seule racine de cette équation dans cet intervalle ; ou
encore si R ∩ [a, b] = {x∗ }. La racine x∗ est alors dite séparée (on dit aussi racine isolée).

10.2 Séparation des racines

Il n’y a pas de méthode générale pour séparer les racines de l’équation (10.1). Dans la pratique,
en dehors de l’étude théorique directe de f si celle-ci est donnée analytiquement, on utilise deux
types de méthodes : une méthode graphique et une méthode dite de balayage.

10.2.1 Méthode graphique

Elle consiste en ceci :

76
10.2. SÉPARATION DES RACINES 77

• soit on trace, expérimentalement (à l’aide d’un logiciel) ou par étude des variations de f ,
le graphe de la fonction f , puis on cherche son intersection avec l’axe Ox ;
• soit on décompose f en deux fonctions f1 et f2 de sorte que l’équation (10.1) puisse
s’écrire de manière équivalente : f1 (x) = f2 (x), puis on cherche les points d’intersection
des graphes de f1 et f2 , dont les abscisses sont les racines de l’équation (10.1).

Remarque 10.1. Les fonctions f1 et f2 sont souvent choisies de sorte que leurs courbes soient
simples et connues.

Exercice d’application 10.1. Séparer les racines des équations :

1. f (x) = x4 − 4x − 1 = 0. (Indication : étude des variations de f ).
2. f (x) = x + ex = 0. (Indication : décomposer f en f = f1 − f2 ).

10.2.2 Méthode de balayage

On choisit un intervalle [a, b], contenu dans le domaine de définition D f de f , dans lequel on
pense qu’il y a des racines de l’équation (10.1). On le subdivise par une suite croissante finie
de points xi , i = 0, 1, . . . , n, avec x0 = a et xn = b. Si f est continue et si f (xi ) f (xi+1 ) < 0 alors
il existe entre xi et xi+1 au moins une racine de (10.1) (c’est le théorème classique des valeurs
intermédiaires (Théorème 10.3)). La méthode consiste donc à déterminer parmi les quantités
f (xi ) f (xi+1 ), i = 0, 1, . . . , n − 1, celles qui sont négatives.

Remarque 10.2. — La méthode de balayage ne permet de conclure qu’à l’existence d’au

moins une racine dans un intervalle [xi , xi+1 ].
—• Si une racine x∗ est double ( f (x∗ ) = f ′ (x∗ ) = 0 et f ′′ (x∗ ) ̸= 0), cette méthode ne
permet pas de la séparer (voir Figure 10.1).

F IGURE 10.1 – Racine double

10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 78

—• De même, si deux racines sont très voisines, on risque de ne pas les séparer dans le
processus ci-dessus.

F IGURE 10.2 – Racine voisine

— L’intervalle de départ [a, b] doit être suffisamment grand afin de contenir les racines éven-
tuelles de l’équation (10.1) ; mais, sauf dans des cas particuliers, il est difficile d’estimer
correctement sa longueur.

10.3 Approximation des racines : Méthodes itératives

Définition 10.3. On appelle méthode itérative un procédé de calcul de la forme :

xk+1 = F(xk ), k∈N (10.3)

dans lequel on part d’une valeur (approchée) x0 pour calculer x1 , puis à l’aide de x1 on calcule
x2 , etc.

La formule (10.3) est dite formule de récurrence. Le procédé est dit convergent si la suite des
itérations (xk )k est convergente.

Parmi les méthodes numériques en général et les méthodes itératives en particulier, les plus
puissantes permettant la résolution approchée des équations du type (10.1), figure la méthode
suivante.

10.3.1 Méthode de Newton-Raphson

Soient x∗ une racine exacte recherchée de l’équation (10.1) et x0 une valeur approchée de x∗ . On
suppose que f est de classe C 2 au voisinage de x∗ . Le développement de Taylor d’ordre 2 de f
donne :
f ′′ (ξ ) ∗
f (x∗ ) = f (x0 ) + f ′ (x0 )(x∗ − x0 ) + (x − x0 )2 où ξ ∈]x∗ , x0 [.
2

Comme f (x∗ ) = 0, en supposant f ′ (x0 ) ̸= 0, on tire x∗ de sorte à obtenir :

f (x0 ) f ′′ (ξ ) ∗
x∗ = x0 − ′
− ′
(x − x0 )2 . (10.4)
f (x0 ) 2 f (x0 )
10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 79

En négligeant le reste
f ′′ (ξ ) ∗
R2 = − (x − x0 )2 ,
2 f ′ (x0 )
la quantité
f (x0 )
x1 = x0 −
f ′ (x0 )
dans (10.4), qu’on notera x1 , constitue alors une valeur approchée améliorée de x∗ . En itérant le
procédé on déduit la formule de récurrence :

f (xk )
xk+1 = xk − , k ∈ N.
f ′ (xk )

qu’on appelle : formule de récurrence de Newton-Raphson.

Ainsi l’algorithme de Newton-Raphson s’écrit :


x0 ∈ [a, b]

f (xk )
xk+1 = xk − ′
 , k∈N
f (xk )

où l’intervalle [a, b] est choisi convenablement (voir section 10.3.1 ci-dessous).

Critère d'arrêt dans la méthode de Newton-Raphson

Soient x∗ une racine isolée de l’équation (10.1), x0 une valeur approchée de x∗ et (xk )k la suite
des approximations obtenue à l’aide de la formule de récurrence de Newton-Raphson. Comme
nous avons supposé plus haut (voisinage de x∗ ), elle est donc aussi de classe C 1 au voisinage de
x∗ . Le développement de Taylor d’ordre 1 donne alors, pour k ∈ N :

f (x∗ ) = f (xk ) + f ′ (ξk )(x∗ − xk ), ξk ∈]x∗ , xk [

ce qui donne :
f (xk )
xk − x∗ = .
f ′ (ξk )
D’autre part :
f (xk ) f (xk )
xk+1 = xk − =⇒ xk+1 − xk = .
f ′ (xk ) f ′ (xk )
En faisant l’approximation f ′ (ξ ) ≃ f ′ (xk ) on obtient finalement :

|xk − x∗ | ≃ |xk+1 − xk |.

Ainsi, si on veut calculer une valeur approchée de x∗ ayant la n-ième décimale qui est exacte
(c’est-à-dire, avec la précision ε = 0.5 · 10−n ), il suffit d’aller dans les itérations jusqu’à ce que
xk vérifie :
|xk+1 − xk | ≤ 0.5 · 10−n . (10.5)
10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 80

La formule (10.5) s’appelle : critère d’arrêt de la méthode de Newton Raphson.

Convergence de la méthode de Newton Raphson

Reprenons la formule de Newton-Raphson :

f (xk )
xk+1 = xk − , k ∈ N.
f ′ (xk )

f (x)
On a donc : xk+1 = g(xk ) où g(x) = x − . Comme
f ′ (x)

( f ′ (x))2 − f (x) f ′′ (x) f (x) f ′′ (x)

g′ (x) = 1 − = ,
( f ′ (x))2 ( f ′ (x))2

alors pour x = x∗ , x∗ étant une racine séparée de l’équation f (x) = 0, on a g′ (x∗ ) = 0 (puisque
f (x∗ ) = 0) et de là |g′ (x∗ )| = 0 < 1 au voisinage de x∗ .

Conséquence : Les conditions i) et ii) du théorème du point fixe (Théorème 10.4) sont donc
réalisées, et par suite on a convergence de la suite des itérations (xk )k vers x∗ .
C’est dans ce but qu’on choisit comme voisinage de x∗ un intervalle [a, b] de sorte que :
1. x∗ ∈ [a, b],
2. f est de classe C 2 sur [a, b],
3. f ′ ̸= 0 sur [a, b].
On vérifiera ci-après qu’avec une condition supplémentaire sur l’intervalle [a, b], la suite (xk )k
converge vers x∗ , indépendamment du choix de la valeur approchée initiale x0 ∈ [a, b].

Remarque 10.3. • f étant de classe C 2 sur [a, b], f ′′ est continue sur [a, b] et donc bornée
sur [a, b] par une constante M > 0 de manière à ce qu’on ait :

∀x ∈ [a, b], | f ′′ (x)| ≤ M.

• f ′ ne s’annulant pas sur [a, b], il existe m > 0 tel que :

∀x ∈ [a, b], | f ′ (x)| ≥ m.

Sous les conditions (1), (2) et (3) ci-dessus, faisons un développement de Taylor de f à l’ordre
1 au voisinage de xk pour obtenir :

1
f (x) = f (xk ) + f ′ (xk )(x − xk ) + f ′′ (ξk )(x − xk )2 où ξk ∈]x, xk [.
2

Comme f (x) = 0 pour x = x∗ , il s’ensuit :

1
0 = f (xk ) + f ′ (xk )(x∗ − xk ) + f ′′ (ξk )(x∗ − xk )2 , où ξk ∈]x∗ , xk [.
2
10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 81

En divisant par f ′ (xk ) ̸= 0 et en translatant, on obtient :

f (xk ) ∗ f ′′ (ξk )(x∗ − xk )2

− = x − xk + .
f ′ (xk ) 2 f ′ (xk )

Or
f (xk ) f (xk )
xk+1 = xk − ′
=⇒ − ′ = xk+1 − xk .
f (xk ) f (xk )
D’où, après simplification :
f ′′ (ξk )(x∗ − xk )2
xk+1 − x∗ = ,
2 f ′ (xk )
soit
f ′′ (ξk ) ∗
xk+1 − x∗ = (x − xk )2 .
2 f ′ (xk )
Comme | f ′′ (x)| ≤ M et | f ′ (x)| ≥ m > 0, on aboutit alors à :

M.|xk − x∗ |2
|xk+1 − x∗ | ≤ . (10.6)
2m

Ainsi, on constate que l’erreur absolue de la (k + 1)-ième approximation est proportionnelle au

carré de l’erreur absolue de la k-ième approximation. On dit que la méthode de Newton-Raphson
est une méthode itérative du second ordre.
M
Posons C = . L’inégalité (10.6) entraîne par induction :
2m
k+1 −1 k+1
|xk+1 − x∗ | ≤ C|xk − x∗ |2 ≤ C(C|xk−1 − x∗ |2 )2 = C3 |xk−1 − x∗ |4 ≤ · · · ≤ C2 |x0 − x∗ |2 .

De là, on déduit que :

k −1 k
|xk − x∗ | ≤ C2 |x0 − x∗ |2 .

Comme : |x0 − x∗ | ≤ |b − a| = b − a, alors :

k −1 k
|xk − x∗ | ≤ C2 (b − a)2 ,

ou encore k
∗ [C(b − a)]2
|xk − x | ≤ .
C
Il y a donc convergence vers x∗ si :

M
C(b − a) = (b − a) < 1,
2m

et c’est pour cette raison que l’on choisit [a, b] de longueur telle que :

2m
b−a < .
M
10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 82

Conclusion : Si en plus des conditions (1), (2) et (3), on choisit l’intervalle [a, b] tel que
2m
b−a < , alors : ∀x0 ∈ [a, b], l’algorithme de Newton-Raphson converge (vers x∗ ).
M
Remarque 10.4 (Choix de la valeur approchée initiale x0 ). La valeur approchée initiale x0 est
généralement choisie de manière à ce que : f (x0 ) · f ′′ (x0 ) > 0. En particulier on prend x0 = a
ou x0 = b, s’il vérifie cette condition.

Algorithme/pseudo-code de la méthode de Newton Raphson

L’algorithme 1 permet d’aller vers une programmation de la méthode de Newton Raphson.

Algorithme 1 : méthode de Newton-Raphson

Pré-condition : f de classe C 2 au voisinage de x0
Input : f (x), f ′ (x) (dérivée de f (x)), x0 (point initial), tol (tolérance), max_iter (nombre max
d’itérations)
Output : x∗ (approximation de la solution)
begin
iter ← 0 ;
x ← x0 ;
while | f (x)| > tol et iter < max_iter do
f (x)
x ← x− ′ ;
f (x)
iter ← iter + 1 ;
if | f (x)| ≤ tol then
return x ; // Solution trouvée
else
return "Pas de convergence" ; // Nombre max d'itérations atteint

Exercice d’application 10.2. 1. Montrer que l’équation x3 − x − 1 = 0 possède 1 seule ra-

cine et qu’elle est comprise entre 1 et 2.
2. Calculer cette racine avec 4 c.s.e en utilisant la méthode de Newton-Raphson. Prendre
x0 = 2.

Solution. 1. Posons f (x) = x3 − x − 1 et considérons son tableau de variations :

√ √
3 3
x −∞ − 3 3 +∞
f ′ (x) + 0 − 0 +
√ √
f (x) −∞ ↗ f (− 33 ) ↘ f ( 33 ) ↗ +∞
 √  √ 
Comme : f − 3 < 0, f 33 < 0, f (1) < 0 et f (2) > 0, d’après les variations
3

de f , il s’en suit que : ∃! x∗ ∈ R : x∗ ∈ [1, 2] et f (x∗ ) = 0.

Afin de montrer que f possède une seule racine sur [1, 2], on aurait également pu tracer
la courbe de la fonction f sur l’intervalle [1, 2].
10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 83

2. L’algorithme de Newton-Raphson correspondant s’écrit


x0 = 2

x3 − xk − 1
xk+1 = xk − k 2
 , k ∈ N.
3xk − 1

On arrête les itérations dès que |xk+1 − xk | ≤ 0.5 × 10−3 est vérifiée.

Commentaire : Le choix de la 3eme décimale dans le critère d’arrêt est dicté par le fait que
la racine x∗ étant contenue dans l’intervalle [1, 2], elle s’écrit nécessairement sous la forme
x∗ = 1, . . . . Comme par hypothèse le nombre de c.s.e exigé est 4, il vient que la racine x∗ doit
être calculée avec 3 décimales exactes.

Les itérations sont reportées dans le tableau suivant où les calculs sont faits avec 1 décimale de
plus.
k xk E = |xk+1 − xk |
0 2
1 1.5455 0.4545
2 1.3596 0.1859
3 1.3258 0.0338
4 1.3247 0.0011
5 1.3247 0
Ainsi l’algorithme de Newton-Raphson nécessite 5 itérations afin d’obtenir une valeur appro-
chée de la racine de f (x) = 0 ayant 4 c.s.e (ou encore, 3 décimales exactes).

D’où, la racine s’écrit : x∗ = 1.325 ± 0.5 × 10−3 .

Exercice d’application 10.3. Utiliser de deux manières différentes l’algorithme de Newton-

Raphson sur l’équation non linéaire suivante : x = 2 sin(x).

Solution. 1re méthode : On pose f (x) = x − 2 sin(x). En utilisant la méthode de Newton-

Raphson pour une seule variable afin de résoudre l’équation : f (x) = x − 2 sin(x) = 0 on déduit
f (xk ) xk − 2 sin(xk )
la formule récurrente suivante : xk+1 = xk − ′ = xk − , k ∈ N.
f (xk ) 1 − 2 cos(xk )
2e méthode : On décompose l’équation traitée en un système de deux équations :
 
y = x F(x, y) = y − x = 0
⇐⇒
y = 2 sin x G(x, y) = y − 2 sin x = 0

qui donne la formule de récurrence de Newton-Raphson pour deux inconnues, suivante :

! ! !−1 !
∂F ∂F
xk+1 xk ∂ x (xk , yk ) ∂ y (xk , yk ) F(xk , yk )
= − ∂G ∂G
, k ∈ N.
yk+1 yk ∂ x (xk , yk ) ∂ y (xk , yk ) G(xk , yk )
10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 84
! ! !−1 !
xk+1 xk −1 1 yk − xk
Soit : = − , k ∈ N.
yk+1 yk −2 cos(xk ) 1 yk − 2 sin(xk )

10.3.2 Méthode de Newton Raphson pour deux inconnus

Algorithme
Soit à résoudre le système d’équations non linéaires :

F(x, y) = 0
G(x, y) = 0

où F et G sont des fonctions données des variables indépendantes x et y. Soit (x0 , y0 ) une valeur
approchée d’une solution exacte (x∗ , y∗ ). Posons :
(
x∗ = x0 + ε0
où ε0 et λ0 sont les erreurs absolues de x0 et y0 .
y∗ = y0 + λ0

En faisant un développement de Taylor à l’ordre 1 des deux fonctions F et G au point (x0 , y0 ),

on obtient, d’une part :

0 = F(x∗ , y∗ ) = F(x0 + ε0 , y0 + λ0 )
∂F ∂F
= F(x0 , y0 ) + (x0 , y0 ) · ε0 + (x0 , y0 ) · λ0 + R0
∂x ∂y

où R0 = termes d’ordres supérieurs à 1 en ε0 et λ0 .

On obtient d’autre part :

0 = G(x∗ , y∗ ) = G(x0 + ε0 , y0 + λ0 )
∂G ∂G
= G(x0 , y0 ) + (x0 , y0 ) · ε0 + (x0 , y0 ) · λ0 + R1
∂x ∂y

où R1 = termes d’ordres supérieurs à 1 en ε0 et λ0 .

Ce qui précède s’écrit sous la forme matricielle :

 
! ! ∂F ∂F ! !
0 F  ∂x ∂y  ε 0 R 0
= + ∂ G ∂G
 +
0 G (x ,y )  λ0 R1
0 0
∂x ∂ y (x0 ,y0 )
10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 85
 −1
∂F ∂F
 ∂x ∂y 
En supposant l’existence de 
∂G ∂G
 , on déduit alors que :
∂x ∂ y (x0 ,y0 )

 −1
! ∂F ∂F !
ε0  ∂x ∂y  F
= −
∂G ∂G
 + termes d’ordres supérieurs à 1 en ε0 et λ0
λ0 G (x ,y )
0 0
∂x ∂ y (x0 ,y0 )

De là, la solution exacte (x∗ , y∗ ) s’écrit :

 −1
! ! ∂F ∂F !
x∗ x0  ∂x ∂y 
 F
= −
∂G ∂G + termes d’ordres supérieurs à 1 en ε0 et λ0
y∗ y0 G (x ,y )
0 0
∂x ∂ y (x0 ,y0 )

En négligeant le reste qui est formé des termes d’ordres supérieurs à 1, la quantité :
 −1
! ∂F ∂F !
x0  ∂x ∂y 
 F
−
∂G ∂G
y0 G (x ,y )
0 0
∂x ∂ y (x0 ,y0 )

constitue une valeur approchée (x1 , y1 ) de la valeur exacte (x∗ , y∗ ). Ainsi :

 −1
! ! ∂F ∂F !
x1 x0  ∂x ∂y  F
= −
∂G ∂G

y1 y0 G (x ,y )
0 0
∂x ∂ y (x0 ,y0 )

En itérant le procédé, on déduit la formule de récurrence de Newton-Raphson pour deux incon-

nues :  −1
! ! ∂F ∂F !
xk+1 xk  ∂x ∂y  F
= −∂G ∂G
 , k∈N
yk+1 yk G (x ,y )
k k
∂ x ∂ y (xk ,yk )
qui donne l’algorithme de Newton-Raphson en dimension deux :




(x0 , y0 ) ∈ [a0 , b0 ] × [a1 , b1 ]
  −1
∂F ∂F

     
xk+1 xk  ∂x ∂y  F
  =  −    , k∈N

 ∂G ∂G
yk+1 yk G
 


 ∂x ∂ y (xk ,yk ) (xk ,yk )
10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 86

où [a0 , b0 ] × [a1 , b1 ] est choisi convenablement.

Pseudo-code de la méthode de Newton-Raphson pour deux inconnus

L’algorithme 2 permet d’aller vers une programmation de la méthode de Newton Raphson pour
deux inconnus.

Algorithme 2 : méthode de Newton-Raphson pour deux inconnus

Data : f1 (x, y), f2 (x, y), x0 , y0 , ε, max_iterations
Result : (x∗ , y∗ )
begin
Initialiser x ← x0 ;
Initialiser y ← y0 ;
Initialiser iteration ← 0;
while iteration < max_iterations do
Calculer F1 ← f1 (x, y);
Calculer F2 ← f2 (x, y);
 
dF1_dx dF1_dy
Construire la matrice Jacobienne J ← ;
dF2_dx dF2_dy
Calculer l’inverse de la matrice Jacobienne J_inv;
 
−F1
Calculer les corrections δ ← J_inv · ;
−F2
δx ← δ [0];
δy ← δ [1];
Mettre à jour les valeurs des inconnus x ← x + δx ;
y ← y + δy ;
q
if δx2 + δy2 < ε then
Afficher "Convergence atteinte";
return (x∗ , y∗ ) ← (x, y);
iteration ← iteration + 1;
Afficher "La méthode n’a pas convergé";

Exercice d’application 10.4. Voir exercice 10.8.

10.3.3 Méthode de Newton-Raphson et polynômes

On suppose que f est un polynôme P(n) (x) de degré n à coefficients réels, n’ayant que des racines
distinctes :
f (x) = P(n) (x) = a0 xn + a1 xn−1 + · · · + an−1 x + an , a0 ̸= 0

Objectif : approximer les racines réelles de l’équation non linéaire

P(n) (x) = 0.

Cette approximation peut être réalisée moyennant la méthode de Newton-Raphson. En outre,

nous avons dans ce cas des outils pratiques permettant aussi bien la détermination du nombre
10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 87

des racines réelles simples de l’équation, que leur localisation. Il s’agit des outils suivants :

Définition 10.4. On appelle suite de Sturm la suite définie par :




 S0 (x) = Pn (x)
S1 (x) = Pn′ (x) 




 
S0 (x)


S2 (x) = −Reste





 S1 (x)
 ..
 .. ..
. . .  
 S i−2 (x)
Si (x) = −Reste


Si−1 (x)



. . .




 .. .. ..

  

 Sn−2 (x)
 Sn (x) = −Reste .


Sn−1 (x)

Théorème 10.1 (Théorème de Sturm : nombres de racines réelles). Le nombre de solutions

réelles (supposées simples) de l’équation P(n) (x) = 0 a pour valeur N(a) − N(b) où N(ξ ) est
le nombre de changement de signe de la suite {Si (ξ ) : i ∈ J1, . . . , nK}. Les réels a et b sont les
extrémités de l’intervalle contenant les racines.

Théorème 10.2 (Localisation). Les racines réelles de l’équation P(n) (x) = 0 sont contenues dans
1
l’intervalle ] − T, T [ avec : T = 1 + · max{|ai | : i ∈ J1, . . . , nK}.
|a0 |
Proposition 10.1. Si la suite {Si (ξ ) : i ∈ J1, . . . , nK} est d’ordre p, c’est-à-dire que
S p+1 (x) = 0, p < n, alors les racines multiples du polynôme P(n) (x) sont les racines simples du
polynôme S p (x).

Remarque 10.5. Dans le cas des polynômes, la divergence de la méthode de Newton-Raphson

est essentiellement due aux deux raisons suivantes :
• soit au mauvais choix de x0 ,
• soit à l’absence de racines réelles.

Exercice d’application 10.5. Résoudre par la méthode de Newton-Raphson, l’équation :

x3 − 3x2 + x − 3 = 0. (10.7)

Solution. Remarquons que le membre de gauche de l’équation (10.7) est le polynôme

P(3) (x) = x3 − 3x2 + x − 3.

Localisation des solutions. Celles-ci sont contenues dans l’intervalle [−T, T ] avec

1 1
T = 1+ max{|ai |; i = 1, 2, 3} = 1 + max{| − 3|, |1|, | − 3|} = 1 + 3 = 4.
|a0 | 1
10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 88

Ainsi, les solutions de l’équation (10.7), si elles existent, se trouvent contenues dans l’intervalle
[−4, 4].

Nombre de racines. Considérons pour cela la suite de Sturm associée au polynôme

P(3) (x) = x3 − 3x2 + x − 3. Elle est définie comme suit :



S0 (x) = P(3) (x) = x3 − 3x2 + x − 3




S1 (x) ′ (x) = 3x2 − 6x + 1
= P(3)

  

 S0 (x)
S2 (x) = −Reste
 S1 (x)




 = x+2 (à un facteur multiplicatif constant près)
  

 S1 (x)
S3 (x) = −Reste = −25.


S2 (x)

Nous avons alors résumé dans le tableau suivant les différents changements de signe des termes
de la suite de Sturm, ainsi que leur nombre :

S0 (x) S1 (x) S2 (x) S3 (x) N(−)

− + − − 2
+ + + − 1

Le nombre de racines réelles de l’équation (10.7) est donc 2 − 1 = 1.

Résolution par la méthode de Newton-Raphson. Pour cela nous commençons par réduire l’in-
tervalle contenant la racine recherchée x∗ . Nous avons P(3) (0) = −3 et P(3) (4) = 69 > 0, donc
x∗ ∈ [0, 4]. Prenons par exemple x0 = 0. Nous avons alors :

P(3) (x0 ) −3 P(3) (x1 )

x1 = x0 − ′ = 0− =3 et x2 = x1 − ′ (x ) = 3 = x1 .
P(3) (x0 ) 1 P(3) 1

De même, pour tout k ∈ N, on obtient : xk = 3 = x1 .

Ainsi, nous obtenons une suite stationnaire qui donne dans ce cas particulier, non pas une racine
approchée mais la racine exacte égale à 3.

10.3.4 Pseudo-code de la méthode de Newton Raphson pour des

polynômes
Les algorithmes 4 et 3 permettent d’aller vers une programmation de la méthode de Newton
Raphson pour des polynômes. En effet, l’algorithme 3 implémente la méthode de Newton-
Raphson pour trouver une racine d’un polynôme. Elle prend en entrée le polynôme, sa dérivée,
une valeur initiale x0 , une tolérance pour la convergence et un nombre maximum d’itérations.

L’algorithme 4 est une fonction qui évalue un polynôme à une valeur donnée x. Elle parcourt
10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 89

Algorithme 3 : Méthode de Newton Raphson pour des polynômes

Input : polynome, derivee, x0 , tolérance, max_iterations
Output : Une racine approchée du polynôme
Initialiser x ← x0 ;
for i ← 1 to max_iterations do
f x ← EvaluerPolynome(polynome, x);
f _prime_x ← EvaluerPolynome(derivee, x);
if f _prime_x est proche de zéro then
afficher "La dérivée est proche de zéro. La méthode échoue.";
return x;
fx
x_new ← x − ;
f _prime_x
if |x_new − x| < tolrance then
return x_new;
x∗ ← x_new;
afficher "La méthode n’a pas convergé après le nombre maximum d’itérations.";
return x∗ ;

chaque terme du polynôme et calcule la somme des termes évalués à x.

Algorithme 4 : EvaluerPolynome
Input : polynome, x
Output : La valeur du polynôme évaluée en x
Initialiser valeur ← 0;
for chaque terme dans polynome do
valeur ← valeur + ([Link] f f icient × ([Link] ));
end
return valeur;

Exercice d’application 10.6. NR poly

10.3.5 Méthode de la sécante

Rappelons que dans l’algorithme de Newton-Raphson qui s’écrit :

x0 ∈ [a, b]

f (xk )
xk+1 = xk − ′
 , k∈N
f (xk )

nous avons besoin de la connaissance de la dérivée de f . Dans certaines circonstances (si f pro-
vient d’un calcul expérimental par exemple), on ne peut calculer f ′ . L’idée est alors de remplacer
f ′ par le taux d’accroissement de f sur un petit intervalle.

Supposons que x0 et x1 soient deux valeurs approchées de la racine x∗ de l’équation

f (x) = 0 avec x0 < x∗ < x1 .

10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 90

f (x1 ) − f (x0 )
Le taux d’accroissement de f sur [x0 , x1 ] est donné par : τ1 = et l’équation de la
x1 − x0
sécante (S) au graphe de f aux points (x0 , f (x0 )) et (x1 , f (x1 )) s’écrit :

f (x1 ) − f (x0 )
y − f (x1 ) = τ1 (x − x1 ) + f (x1 ) = (x − x1 ) + f (x1 ). (10.8)
x1 − x0

On obtient une nouvelle valeur approchée x2 de x∗ en calculant l’abscisse du point d’intersection

x1 − x0
de la sécante (S) avec l’axe Ox : x2 = x1 − f (x1 ) obtenu en posant y = 0 dans
f (x1 ) − f (x0 )
(10.8).
xk − xk−1
On itère ce procédé pour obtenir : xk+1 = xk − f (xk ) .
f (xk ) − f (xk−1 )
L’algorithme correspondant, dit algorithme de la sécante, s’écrit alors :

x0 , x1 donnés
xk − xk−1
xk+1 = xk − f (xk ) , k ∈ N∗
f (xk ) − f (xk−1 )

F IGURE 10.3 – Méthode de la sécante

Critère d'arrêt dans la méthode de la sécante

C’est le même que celui de la méthode de Newton-Raphson.

Algorithme/pseudo-code de la méthode de la sécante

L’algorithme 5 permet d’aller vers une programmation de la méthode de la sécante.

10.3.6 Méthode de dichotomie

La méthode dichotomique, également connue sous le nom de méthode de bissection, est une
méthode numérique pour trouver les racines d’une fonction continue. Cette méthode est parti-
10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 91

Algorithme 5 : méthode de la sécante

Input : f (x), x0 , x1 (points initiaux), tol (tolérance), max_iter (nombre max d’itérations)
Output : x∗ (approximation de la solution)
begin
iter ← 0 ;
while | f (x1 )| > tol et iter < max_iter do
x1 − x0
x2 ← x1 − f (x1 ) · ;
f (x1 ) − f (x0 )
x0 ← x1 ;
x1 ← x2 ;
iter ← iter + 1 ;
if | f (x1 )| ≤ tol then
return x1 ; // Solution trouvée
else
return "Pas de convergence" ; // Nombre max d'itérations atteint

culièrement utile pour les fonctions continues sur un intervalle où la fonction change de signe,
garantissant ainsi l’existence d’une racine dans cet intervalle.

L’idée est la construction d’une suite d’intervalles de plus en plus petits contenant une racine
isolée de l’équation f (x) = 0. L’outil utilisé est le Théorème des valeurs intermédiaires.

F IGURE 10.4 – Méthode de dichotomie

Théorème 10.3 (Théorème des valeurs intermédiaires). Soit f : [a, b] −→ R une fonction conti-
nue, telle que : f (a) · f (b) < 0. Alors, il existe au moins x∗ ∈]a, b[ tel que f (x∗ ) = 0.

Remarque 10.6. Si de plus la fonction f est injective, alors x∗ est unique.

Algorithme et pseudo-code de la méthode de la dichotomie

Supposons que a et b soient tels que : x∗ ∈ [a, b], avec f (a) f (b) < 0. On pose : a0 = a, b0 = b
et [a0 , b0 ] = I0 . Puis on divise l’intervalle I0 = [a0 , b0 ] en deux, pour construire l’intervalle I1 =
a0 + b0
[a1 , b1 ] comme suit : pour x0 = (milieu du segment [a0 , b0 ]) on fait le test suivant :
2

Si f (a ) · f (x ) < 0 alors [a , x ] = [a , b ] = I ;
0 0 0 0 1 1 1
sinon [x , b ] = [a , b ] = I .
0 0 1 1 1
10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 92

De là on itère le procédé pour obtenir une suite d’intervalles emboîtés :

Ik = [ak , bk ], k ∈ N∗

ak + bk
dont les extrémités sont définies comme suit : on pose xk = et on procède au test suivant :
2

Si f (a ) f (x ) < 0 alors [a , x ] = [a , b ] = I ;
k k k k k+1 k+1 k+1
sinon [x , b ] = [a , b ] = I .
k k k+1 k+1 k+1

On prend alors comme valeur approchée de x∗ la valeur xk .

Critère d'arrêt dans la méthode de dichotomie

Soit k ∈ N. Nous avons, par récurrence :

bk − ak bk−1 − ak−1 b0 − a0
bk+1 − ak+1 = = 2
= · · · = k+1 .
2 2 2

Si x∗ est la racine de l’équation f (x) = 0, nous obtenons :

bk − ak b0 − a0
|x∗ − xk | ≤ bk+1 − ak+1 = = k+1 .
2 2

Donc, si on souhaite calculer une valeur approchée xk de x∗ ayant la n-ième décimale qui est
exacte (précision ε = 0.5 · 10−n ), il suffit de poser

b0 − a0
k+1
≤ 0.5 · 10−n .
2

Ce qui revient à ce qu’on aille dans les itérations jusqu’à ce que k vérifie l’inégalité :

ln(b0 − a0 ) − ln(0.5 · 10−n )

k≥ − 1. (10.9)
ln(2)

Ainsi, les itérations s’achèvent à la k0 -ième étape où k0 est le premier entier naturel vérifiant
(10.9).

Pseudo-code de la méthode de la dichotomie

L’algorithme 6 permet d’aller vers une programmation de la méthode dichotomique ou méthode
de la bissection.

Dans la résolution d’équations non linéaires, la méthode dichotomique est sûre mais a une
convergence lente.

Exercice d’application 10.7. Sachant que l’équation x3 − x − 1 = 0 possède une seule racine
positive comprise entre 1 et 2,
10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 93

Algorithme 6 : méthode de la bissection ou dichotomique

Input : f (x), a (borne inf de l’intervalle), b (borne sup de l’intervalle), tol (tolérance), max_iter
(nombre max d’itérations)
Output : x∗ (approximation de la solution)
begin
if f (a) · f (b) ≥ 0 then
Afficher "Erreur : La condition f (a) · f (b) < 0 n’est pas satisfaite." ;
return "Pas de solution garantie" ;
else
iter ← 0 ;
while (b − a) > tol et iter < max_iter do
a+b
xm ← ; // Milieu de l'intervalle
2
if f (xm ) = 0 then
return xm ; // Solution exacte trouvée
if f (a) · f (xm ) < 0 then
b ← xm ; // La racine est dans [a, xm ]
else
a ← xm ; // La racine est dans [xm , b]
iter ← iter + 1 ; // Incrémenter l'itération
a+b
return ; // Approximation de la solution
2

1. déterminer le nombre d’itérations suffisantes pour trouver cette racine avec 4 chiffres
significatifs exacts en utilisant la méthode de dichotomie ;
2. calculer cette racine avec 2 chiffres significatifs exacts en utilisant la dichotomie.

Solution. Soit x∗ la racine de f (x) = x3 − x − 1 = 0 avec x∗ ∈ [1, 2].

1. Détermination du nombre d’itérations. Comme x∗ ∈ [1, 2] alors x∗ s’écrit x∗ = 1, . . . . Donc
le nombre de 4 chiffres significatifs exacts correspond à 3 décimales exactes. D’où, le
nombre correspondant d’itérations suffisantes, k0 , se calcule comme suit :

ln(2 − 1) − ln(0.5 × 10−3 )

k≥ − 1 ≃ 9.97.
ln(2)

On prend alors k0 = 10.

2. Le nombre suffisant d’itérations, k0 , à effectuer afin d’obtenir une valeur approchée ayant
2 chiffres significatifs exacts (c’est-à-dire, 1 décimale exacte) est donné par l’inégalité
suivante :
ln(2 − 1) − ln(0.5 × 10−1 )
k≥ − 1 ≃ 3.32.
ln(2)

Donc, on prend k0 = 4.

En faisant les calculs intermédiaires avec 1 chiffre significatif de plus, on obtient :

10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 94

k ak bk xk f (ak ) f (bk ) f (xk )

0 1 2 1.5 − + +
1 1 1.5 1.25 − + −
2 1.25 1.5 1.38 − + +
3 1.25 1.38 1.32 − + −
4 1.32 1.38 1.36

Ainsi, la racine recherchée est telle que : x∗ = 1.4 ± 0.5 × 10−1 .

10.3.7 Méthode du point xe

La méthode du point fixe a été mise en œuvre afin de palier aux insuffisances de la :
• méthode de Newton qui est rapide mais à condition de bien choisir x0 ;
• méthode de la sécante qui est rapide mais condition de bien choisir x0 et x1 qui doivent
vérifier certaines conditions ;
• méthode dichotomique est sûre mais lente à converger.

Définition 10.5. Soit f : R −→ R une fonction dont le domaine de définition est une partie D f de
R. On suppose que f est continue sur D f . On dit que x∗ ∈ D f est un point fixe de f si f (x∗ ) = x∗ .

Théorème 10.4 (Théorème du point fixe). Supposons que f est définie sur l’intervalle [a, b] et
satisfait aux conditions suivantes :
(i) f ([a, b]) ⊆ [a, b], i.e., ∀x ∈ [a, b], a ≤ f (x) ≤ b. On dit alors que l’intervalle [a, b] est stable
par l’application f .
(ii) f est strictement contractante, i.e., ∃ L ∈ R, 0 ≤ L < 1 tel que

| f (x) − f (y)| ≤ L · |x − y|, ∀x, y ∈ [a, b]. (10.10)

Alors, f admet un point fixe unique x∗ ∈ [a, b]. De plus l’algorithme, dit du point fixe, défini par :

x ∈ [a, b]
0
x
k+1 = f (xk ), k∈N

converge vers x∗ .

Remarque 10.7. La condition (ii) du Théorème 10.4 entraîne :

• la continuité de la fonction f sur [a, b] ;
• si la fonction f est dérivable en x, en divisant les deux membres de l’inégalité (10.10) par
le terme |x − y| et en passant à la limite lorsque y tend vers x, on obtient : | f ′ (x)| ≤ L < 1.

Théorème 10.5 (Théorème d’Ostrowski). Soit x∗ un point fixe d’une fonction f continue et
dérivable sur [a, b] contenant x∗ . Si | f ′ (x)| ≤ L′ < L < 1 sur [c, d] alors il existe un intervalle
[c, d] ⊂ [a, b] tel que la suite (xk ) converge vers x∗ pour tout x0 ∈ [c, d].
10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 95

La convergence de la suite xk+1 = f (xk ) vers x∗ sur [c, d] est encore plus rapide que celle obtenue
sur l’intervalle [a, b] car : |x∗ − xk | ≤ L′k |x∗ − x0 |.

Le choix d’un intervalle plus petit permet souvent d’obtenir une meilleure estimation du point
fixe, surtout si L′ est significativement plus petit que L, ce qui accélère la convergence.

Critère d'arrêt no 1 dans la méthode du point xe

Soit f : [a, b] −→ R une fonction satisfaisant aux hypothèses du théorème du point fixe (Théo-
rème 10.4), et soit (xk )k la suite des approximations définie par la relation xk+1 = f (xk ), k ∈ N.
Pour k, n ∈ N, n > k, nous avons :

|xn − xk | = | f (xn−1 ) − f (xk−1 )| ≤ L|xn−1 − xk−1 |

Par récurrence, on déduit que :

|xn − xk | ≤ L|xn−1 − xk−1 |

≤ L2 |xn−2 − xk−2 |
.. .. ..
. . .
|xn − xk | ≤ Lk |xn−k − x0 |
..
. ≤ Lk (|xn−k − x∗ | + |x∗ − x0 |)
≤ Lk (Ln−k |x0 − x∗ | + |x0 − x∗ |)
|xn − xk | ≤ Lk (Ln−k + 1)|b − a|

En passant à la limite sur n, on obtient :

|x∗ − xk | ≤ Lk · |b − a| car Ln−k + 1 −−−→ 1

n→∞

Ainsi, si on souhaite calculer une valeur approchée xk de x∗ ayant la n-ième décimale qui est
exacte (précision ε = 0.5 · 10−n ), il suffit d’arrêter les itérations dès que k vérifie :

ln(0.5 · 10−n ) − ln(b − a)

k≥ . (10.11)
ln(L)

obtenue en posant Lk (b − a) ≤ 0.5 · 10−n . Les itérations s’arrêtent donc à la k0 -ième étape où k0
est le premier entier vérifiant (10.11).

Critère d'arrêt no 2 dans la méthode du point xe

Soit k ∈ N. Nous avons :

|xk+1 − x∗ | = | f (xk ) − f (x∗ )|

..
. ≤ L|xk − x∗ |
≤ L|xk − xk+1 + xk+1 − x∗ |
|xk+1 − x∗ | ≤ L|xk − xk+1 | + L|xk+1 − x∗ |.
10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 96

D’où l’on déduit que :

|xk+1 − x∗ |(1 − L) ≤ L|xk − xk+1 |

pour obtenir finalement

L
|xk+1 − x∗ | ≤ |xk − xk+1 |.
1−L
Donc, pour avoir la n-ième décimale dans xk+1 qui est exacte (précision ε = 0.5 · 10−n ), on arrête
les itérations dès que l’inégalité suivante est vérifiée :

1−L
|xk+1 − xk | ≤ 0.5 · 10−n . (10.12)
L

Remarque 10.8. En général L est assez petit de sorte que 2L < 1 d’où L < 1 − L. Ce qui donne :

L
|xk − xk+1 | ≤ |xk − xk+1 |.
1−L

Conséquence : au lieu du critère d’arrêt (10.12), on prend souvent comme critère d’arrêt la
condition suivante :
|xk+1 − xk | ≤ 0.5 · 10−n .

Accélération de la convergence dans la méthode du point xe

Lemme 10.1. On suppose que la dérivée f ′ existe. Alors, plus la valeur | f ′ (x∗ )| est petite, plus
la convergence est rapide.

Preuve. On pose Ek = xk − x∗ . Un développement de Taylor de f donne :

Ek2 ′′ ∗
xk+1 = f (xk ) = f (x∗ + Ek ) = f (x∗ ) + Ek f ′ (x∗ ) + f (x ) + . . . .
2!

En négligeant les termes d’ordre supérieur à 1 en Ek , il vient :

xk+1 − f (x∗ ) ≃ xk+1 − x∗ ≃ f ′ (x∗ ).Ek =⇒ Ek+1 = xk+1 − x∗ ≃ f ′ (x∗ ).Ek .

Comme (Ek ) est une suite convergente vers 0, il apparaît clairement que plus la valeur | f ′ (x∗ )|
est petite, plus la convergence est rapide. □

Accélération. Soit λ ̸= −1. Posons

λ x + f (x)
g(x) = .
1+λ

Comme f (x) = x ⇐⇒ g(x) = x, alors x∗ est un point fixe de f si et seulement si il l’est pour G.
On a :
λ + f ′ (x)
g′ (x) =
1+λ
10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 97

donc :
λ + f ′ (x∗ )
g′ (x∗ ) = .
1+λ
Il suffit alors de prendre λ voisin de − f ′ (x∗ ) pourvu que f ′ (x∗ ) soit petit (pour qu’on puisse
appliquer l’algorithme du point fixe à f ). Donc, d’après le Lemme 10.1, la convergence sera
plus rapide que celle donnée par f (x) = x.

Algorithme d’accélération.
1. Calculer x0 , x1 , . . . , xn par la méthode lente :

x ∈ [a, b]
0
x
k+1 = f (xk ), k = 0, 1, . . . , n − 1

où n est choisi selon les cas.

2. On pose λ = − f ′ (xn ).
3. On calcule les approximations suivantes par : xk+1 = g(xk ), k = n, n + 1, . . . où :

λ x + f (x)
g(x) = .
1+λ

Algorithme/pseudo-code de la méthode du point xe

L’algorithme 7 permet d’aller vers une programmation de la méthode du point fixe.

Algorithme 7 : méthode du point fixe

Pré-condition : Vérifier les conditions du théorème 10.4
Input : f (x), x0 (point initial), tol (tolérance), max_iter (nombre max d’itérations)
Output : xnew = x∗ (approximation du point fixe)
begin
x ← x0 // Initialisation
iter ← 0 // Compteur d'itérations
while iter < max_iter do
xnew ← g(x) // Application de l'itération du point fixe
if |xnew − x| < tol then
return xnew // Convergence atteinte
x ← xnew // Mise à jour de x
iter ← iter + 1 // Incrémenter l'itération

// Si l'algorithme ne converge pas

Afficher "L’algorithme n’a pas convergé après max_iter itérations."
return xnew // Dernière approximation obtenue

Exercice d’application 10.8. Déterminez les racines des équations non linéaires simultanées
suivantes 
y = −x2 + x + 0.75
y + 5xy = x2
10.3. APPROXIMATION DES RACINES : MÉTHODES ITÉRATIVES 98

en utilisant :
1. L’itération à point fixe.
2. La méthode de Newton-Raphson.
Utilisez des suppositions initiales de x = y = 1.2 et discutez des résultats.

Solution. Nous avons deux équations non linéaires simultanées :


y = −x2 + x + 0.75
y + 5xy = x2

L’objectif est de déterminer les racines x et y qui satisfont ces deux équations en utilisant deux
méthodes : l’itération à point fixe et la méthode de Newton-Raphson.

1. Méthode du point fixe Pour résoudre cette équation par itération à point fixe, nous ré-
arrangeons la première équation pour obtenir une forme itérative pour y en fonction de x. La
deuxième équation est déjà en termes de y, et nous l’utiliserons directement pour vérifier la
solution à chaque itération.

La première équation devient : y = −x2 + x + 0.75 et la deuxième équation peut être réécrite
x2
pour exprimer y en fonction de x : y = . Nous pouvons alors utiliser ces expressions pour
1 + 5x
itérer l’algorithme 7 afin d’obtenir les solutions.

2. Méthode de Newton-Raphson La méthode de Newton-Raphson est une méthode plus ra-

pide et plus robuste pour trouver les racines d’un système d’équations. Nous devons d’abord
formuler le système d’équations sous forme de fonctions f1 (x, y) et f2 (x, y), calculer leurs déri-
vées partielles et exprimer la matrice Jacobienne.

Les équations sont : f1 (x, y) = y + 5xy − x2 , f2 (x, y) = −x2 + x + 0.75 − y.

Les dérivées partielles nécessaires pour la méthode de Newton-Raphson sont :

∂ f1 ∂ f1 ∂ f2 ∂ f2
= 5y − 2x, = 5x, = −2x + 1, = −1
∂x ∂y ∂x ∂y

Nous formons la matrice Jacobienne J et la solution par Newton-Raphson est donnée par :
! !
xn+1 xn
= − J −1 · F(xn , yn )
yn+1 yn

où F(xn , yn ) est le vecteur des fonctions f1 et f2 . Avec ces éléments on peut itéré l’algorithme 2
afin d’obtenir les solutions.
10.4. IMPLÉMENTATION SCIPY D’ÉQUATIONS NON LINÉAIRES 99

10.4 Implémentation SciPy d'équations non linéaires

La fonction fsolve est utilisée pour résoudre des équations non linéaires de la forme f (x) = 0.
Elle prend une fonction f et une estimation initiale x0 et tente de trouver les valeurs de x pour
lesquelles f (x) = 0.

import numpy as np
from [Link] import fsolve

# Définir la fonction
def func(x):
return [x[0] + x[1] - 2, x[0]**2 + x[1]**2 - 4]

# Estimation initiale
x0 = [1, 1]

# Trouver la racine avec des informations supplémentaires

racine, infodict, ier, mesg = fsolve(func, x0, full_output=True)

# Afficher la racine
print("x*=", racine)

# Afficher le dictionnaire d'informations supplémentaires

print("\nInformation Dictionary:")
for key, value in [Link]():
print(f"{key}: {value}")

# Afficher le message et le code d'erreur

print("\nMessage:", mesg)
print("ier:", ier)

La fonction [Link] est basée sur les algorithmes hybrides de Powell, spéci-
fiquement les algorithmes hybrd et hybrj de la bibliothèque MINPACK. Ces algorithmes sont
conçus pour résoudre des systèmes d’équations non linéaires en utilisant une combinaison de la
méthode de Newton et de la méthode de Gauss-Newton, avec des ajustements pour améliorer
la robustesse et la convergence. L’algorithme hybride de Powell est particulièrement efficace
pour les problèmes où les dérivées peuvent être difficiles à calculer ou lorsque les solutions
sont sensibles aux conditions initiales. Cependant, fsolve ne permet pas de spécifier directe-
ment une autre méthode de résolution. Si vous avez besoin de spécifier une méthode particu-
10.4. IMPLÉMENTATION SCIPY D’ÉQUATIONS NON LINÉAIRES 100

lière, vous devrez utiliser une autre fonction de SciPy qui permet de choisir la méthode, comme
[Link].

Les méthodes pouvant être spécifier avec [Link] :

• 'hybr' : Méthode hybride de Powell (équivalente à fsolve).
• 'lm' : Méthode de Levenberg-Marquardt.
• 'broyden1' : Première méthode de Broyden.
• 'broyden2' : Deuxième méthode de Broyden.
• 'anderson' : Méthode d’Anderson.
• 'linearmixing' : Méthode de mélange linéaire.
• 'diagbroyden' : Méthode de Broyden diagonale.
• 'excitingmixing' : Méthode de mélange excitant.
• 'krylov' : Méthode de Krylov.
• 'df-sane' : Méthode de SANE (Simultaneous Analysis and Normal Equations).

import numpy as np
from [Link] import root

# Définir la fonction
def func(x):
return x**2 - 4

# Estimation initiale
x0 = [Link]([1.0])

# Utiliser la méthode 'lm' (Levenberg-Marquardt)

result = root(func, x0, method='lm')

print("Les racines sont:", result.x)

print("Informations supplémentaires:", result)
 Bibliographie

[1] B. Duchesne. Algèbre linéaire ii.

101