Introduction complète à MatPlotLib : Fondamentaux, Graphiques 2D et Visualisation 3D en Python

© 2025
Support de cours
YOUSSOUF EL ALLIOUI
Université Sultan Moulay Slimane
y.elallioui@usms.ma
2025
Introduction à MatPlotLib
REPRÉSENTATION GRAPHIQUE ET EXPLORATION
VISUELLE EN PYTHON

Y. EL ALLIOUI – USMS – FPK – y.elallioui@usms.ma 2 / 35
Table des matières
TABLE DES MATIÈRES ___________________________________________________________ 2
AVANT-PROPOS ________________________________________________________________ 5
INTRODUCTION GÉNÉRALE______________________________________________________ 6
CHAPITRE 1 : FONDAMENTAUX DE MATPLOTLIB___________________________________ 7
Introduction à Matplotlib __________________________________________________________________ 7
Qu’est-ce que Matplotlib ? ________________________________________________________________ 7
Installation de Matplotlib__________________________________________________________________ 7
Importer Matplotlib ______________________________________________________________________ 7
Pyplot_________________________________________________________________________________ 8
Exemple simple : tracer une droite __________________________________________________________ 8
Le traçage (Plotting) dans Matplotlib _____________________________________________________ 8
Tracer uniquement des points (Markers) ____________________________________________________ 9
Plusieurs points _________________________________________________________________________ 9
Valeurs par défaut pour l’axe X_____________________________________________________________ 9
Matplotlib – Les Markers (Marqueurs)_______________________________________________________ 9
Qu’est-ce qu’un Marker ? _________________________________________________________________ 9
Exemple simple : _______________________________________________________________________ 10
Tableau des Markers disponibles___________________________________________________________ 10
Notation raccourcie (fmt)________________________________________________________________ 10
Types de lignes possibles_________________________________________________________________ 11
Couleurs abrégées ______________________________________________________________________ 11
Personnalisation des Markers _____________________________________________________________ 11
Taille (markersize ou ms)___________________________________________________________ 11
Couleur des bords (markeredgecolor ou mec)__________________________________________ 11
Couleur de l’intérieur (markerfacecolor ou mfc)_______________________________________ 11
Bord + intérieur______________________________________________________________________ 11
Couleurs avancées____________________________________________________________________ 12
Matplotlib – Les Lignes et la Mise en Forme des Graphiques____________________________________ 12
Linestyle (Style de ligne)_________________________________________________________________ 12
Principaux styles de ligne ______________________________________________________________ 12
Couleur de la ligne______________________________________________________________________ 13
Largeur de la ligne______________________________________________________________________ 13
Tracer plusieurs lignes___________________________________________________________________ 13
Exemple : deux lignes avec deux appels plot() ___________________________________________ 13
Exemple : deux lignes dans le même plot()______________________________________________ 13
Labels et Titre _________________________________________________________________________ 13
Personnaliser les polices avec fontdict_________________________________________________ 14
Position du titre______________________________________________________________________ 14
Ajouter une Grille ______________________________________________________________________ 14
Subplots (plusieurs graphiques dans une même figure)_______________________________________ 15
Exemple : 2 graphiques côte à côte_______________________________________________________ 15
Exemple : 2 graphiques l’un au-dessus de l’autre ___________________________________________ 15

Exemple : 6 graphiques (2 lignes & 3 colones) _____________________________________________ 15
Titres dans Subplots_____________________________________________________________________ 16
Conclusion______________________________________________________________________________ 16
CHAPITRE 2 : TYPES DE GRAPHIQUES SPÉCIALISÉS_______________________________ 17
Matplotlib – Scatter Plots (Nuages de points) _________________________________________________ 17
Créer un scatter plot_____________________________________________________________________ 17
Exemple : scatter plot simple ___________________________________________________________ 17
Comparer plusieurs ensembles de données ___________________________________________________ 18
Couleurs des points _____________________________________________________________________ 18
Exemple : choisir une couleur fixe _______________________________________________________ 18
Exemple : une couleur différente pour chaque point _________________________________________ 18
Colormaps - une palette de couleurs graduée _________________________________________________ 19
Exemple avec colormap _______________________________________________________________ 19
Taille des points________________________________________________________________________ 20
Exemple : tailles personnalisées _________________________________________________________ 20
Matplotlib – Diagrammes en barres (Bar Charts) _____________________________________________ 20
Créer un diagramme en barres_____________________________________________________________ 20
Exemple : 4 barres simples _____________________________________________________________ 20
Exemple avec catégories personnalisées _____________________________________________________ 20
Diagrammes horizontaux_________________________________________________________________ 21
Couleur des barres ______________________________________________________________________ 21
Largeur et Hauteur des barres _____________________________________________________________ 21
Matplotlib – Histogrammes________________________________________________________________ 22
Qu’est-ce qu’un histogramme ?____________________________________________________________ 22
Créer un histogramme avec Matplotlib ______________________________________________________ 22
Exemple : distribution de données aléatoires _______________________________________________ 22
Matplotlib – Diagrammes Circulaires (Pie Charts) ____________________________________________ 23
Qu’est-ce qu’un diagramme circulaire ? _____________________________________________________ 23
Créer un camembert simple_______________________________________________________________ 23
Ajouter des étiquettes (labels) _____________________________________________________________ 23
Modifier l’angle de départ ________________________________________________________________ 24
Mettre un secteur en évidence (explode)_____________________________________________________ 24
Ajouter une ombre ______________________________________________________________________ 24
Personnaliser les couleurs ________________________________________________________________ 24
Ajouter une légende_____________________________________________________________________ 24
Exemple complet _______________________________________________________________________ 25
Conclusion______________________________________________________________________________ 26
CHAPITRE 3 : VISUALISATION 3D ________________________________________________ 27
Approches POO vs fonctionnelle____________________________________________________________ 27
Deux façons de travailler avec MatPlotLib ___________________________________________________ 27
Approche fonctionnelle________________________________________________________________ 27
Approche orientée objet (POO) _________________________________________________________ 28
À retenir ___________________________________________________________________________ 28
Bon à savoir : Deux façons de créer un axe 3D________________________________________________ 28
Avec figure() et add_subplot() (méthode classique)__________________________________ 28
Avec subplots() (méthode recommandée) _____________________________________________ 28
À retenir ___________________________________________________________________________ 28
MatPlotLib – Graphiques 3D (Exemples pratiques)____________________________________________ 29

Exemple 1 – Nuage de points en 3D (scatter) _________________________________________________ 29
Sortie ________________________________________________________________________________ 30
Explication étape par étape : ______________________________________________________________ 30
Exemple 2 – Surface 3D (plot_surface)______________________________________________________ 30
Sortie______________________________________________________________________________ 31
Explication étape par étape :____________________________________________________________ 31
Exemple 3 – Histogramme 3D (bar3d) ______________________________________________________ 31
Sortie______________________________________________________________________________ 32
Explication étape par étape :____________________________________________________________ 32
Autres exemples________________________________________________________________________ 33
Conclusion______________________________________________________________________________ 33
CONCLUSION GÉNÉRALE_______________________________________________________ 35

Avant-propos
Ce support de cours est destiné aux étudiants du Master Intelligence Artificielle et Génie
Informatique, installé à la Faculté Polydisciplinaire de Khouribga (FPK) relevant de
l’Université Sultan Moulay Slimane de Béni Mellal (USMS). Il s’inscrit dans le cadre du
module Python pour les sciences de données, complémentaire au chapitre consacré à NumPy
et préalable à l’exploration de bibliothèques plus spécialisées comme SciPy, Pandas,
Seaborn ou scikit-learn.
L’objectif de ce document est d’introduire la bibliothèque Matplotlib, considérée comme
l’outil de référence pour la visualisation de données en Python. Si NumPy constitue le socle
pour la manipulation des données numériques, Matplotlib permet de leur donner une
représentation graphique claire et expressive, étape essentielle dans tout processus de Data
Science et d’Intelligence Artificielle.
La démarche adoptée est progressive et pédagogique : elle présente les concepts de base de la
visualisation, les illustre par des exemples pratiques et propose des cas d’utilisation concrets
pour faciliter leur compréhension. L’ambition est de permettre à l’étudiant d’acquérir non
seulement les connaissances nécessaires pour manipuler Matplotlib, mais aussi les
compétences pour analyser et communiquer efficacement des résultats à travers des graphiques
adaptés.
Ce document se veut à la fois un guide pratique et un outil de référence, contribuant à renforcer
les acquis des étudiants et à les préparer aux futures étapes de leur formation et de leur carrière
dans le domaine de la science des données et de l’ingénierie informatique.

Introduction générale
Le langage Python s’est imposé comme une référence incontournable dans la Data Science et
l’Intelligence Artificielle, grâce à sa simplicité, sa lisibilité et surtout à la richesse de son
écosystème de bibliothèques. Parmi celles-ci, Matplotlib occupe une place essentielle en tant
qu’outil de base pour la visualisation des données, permettant de transformer des informations
numériques en représentations graphiques claires, expressives et interprétables.
Dans le cadre du module Python pour les sciences de données du Master Intelligence
Artificielle et Génie Informatique, ce support consacré à Matplotlib constitue une étape clé
après l’étude de NumPy. Alors que NumPy fournit les fondations du calcul scientifique et de
la manipulation de données numériques, Matplotlib permet de franchir une étape indispensable
: donner une dimension visuelle aux résultats. Cette compétence est cruciale, non seulement
pour l’analyse exploratoire, mais aussi pour la communication des résultats dans des projets de
Data Science et d’Intelligence Artificielle.
L’objectif de ce support est double :
• initier l’étudiant aux concepts fondamentaux de la visualisation en Python avec
Matplotlib,
• développer sa capacité à créer, personnaliser et interpréter différents types de graphiques
adaptés à divers contextes d’analyse.
Au fil des chapitres, l’étudiant découvrira progressivement :
• Chapitre 1 : Fondamentaux de MatPlotLib – présentation de la bibliothèque, de son
installation et de son sous-module Pyplot ; apprentissage des bases du traçage de
courbes, de l’utilisation des marqueurs, des styles de lignes, de la personnalisation des
axes et des titres, ainsi que de la création de figures multiples (subplots).
• Chapitre 2 : Types de graphiques spécialisés – approfondissement avec la réalisation
de visualisations adaptées à différents contextes : nuages de points (scatter plots),
diagrammes en barres, histogrammes et diagrammes circulaires (pie charts), avec un
accent particulier sur la personnalisation des couleurs, tailles et légendes.
• Chapitre 3 : Visualisation 3D – introduction aux représentations tridimensionnelles,
distinction entre les approches fonctionnelle et orientée objet, puis mise en pratique à
travers différents exemples (nuages de points 3D, surfaces, histogrammes 3D),
permettant d’explorer des données dans un espace à trois dimensions.
Ce parcours progressif permettra à l’étudiant de maîtriser non seulement les fondements de
Matplotlib, mais aussi d’acquérir une vision pratique et globale de la place de la visualisation
de données dans la chaîne de traitement en Data Science et en Intelligence Artificielle.

Chapitre 1 : Fondamentaux de MatPlotLib
Dans ce premier chapitre, nous allons découvrir les bases de MatPlotLib, la bibliothèque de
référence pour la visualisation en Python. L’objectif est de se familiariser avec son installation,
son importation, et surtout avec son sous-module Pyplot, qui fournit la majorité des fonctions
nécessaires au traçage de graphiques.
Nous apprendrons à tracer nos premiers graphiques avec plot(), à utiliser des markers pour
représenter des points, à personnaliser les lignes (couleur, style, largeur) et à ajouter
des titres, labels et grilles. Enfin, nous verrons comment organiser plusieurs
graphiques dans une même figure grâce aux subplots.
Ces éléments constituent le socle indispensable pour progresser vers des visualisations plus
spécialisées.
Introduction à Matplotlib
Qu’est-ce que Matplotlib ?
Matplotlib est une bibliothèque de bas niveau en Python, dédiée au tracé de graphiques et
utilisée comme un outil essentiel de visualisation.
• Créée par John D. Hunter, elle est aujourd’hui open source et libre d’utilisation.
• Elle est principalement écrite en Python, mais certaines parties sont développées
en C, Objective-C et JavaScript pour garantir une meilleure compatibilité
multiplateforme.
👉 Le code source officiel de Matplotlib est disponible sur GitHub :
https://github.com/matplotlib/matplotlib
Installation de Matplotlib
Si Python et pip sont déjà installés sur votre système, l’installation est très simple :
pip install matplotlib
⚠ Si cette commande échoue, vous pouvez utiliser une distribution Python qui inclut déjà
Matplotlib (par ex. Anaconda, Spyder, etc.).
Importer Matplotlib
Une fois installé, on peut importer la bibliothèque avec :

import matplotlib
Pour vérifier la version installée :
import matplotlib
print(matplotlib.__version__)
Pyplot
La plupart des fonctionnalités de Matplotlib se trouvent dans le sous-module pyplot,
généralement importé sous l’alias plt :
import matplotlib.pyplot as plt
Ainsi, toutes les fonctions de Pyplot pourront être appelées avec :
plt.nom_de_fonction()
Exemple simple : tracer une droite
Traçons une ligne reliant le point (0,0) au point (6,25) :
import numpy as np
xpoints = np.array([0, 6])
ypoints = np.array([0, 25])
plt.plot(xpoints, ypoints)
plt.show()
👉 Cet exemple montre comment créer un premier graphique avec plot() et l’afficher grâce
à show().
Le traçage (Plotting) dans Matplotlib
• La fonction plot() est utilisée pour tracer des points ou des lignes dans un
diagramme.
• Paramètre 1 : tableau des valeurs de l’axe x.
• Paramètre 2 : tableau des valeurs de l’axe y.
Exemple : Tracer une ligne entre (-1,3) et (8,-10) :
import numpy as np
xpoints = np.array([-1, 8])
ypoints = np.array([3, -10])
plt.show()
• L’axe x correspond à l’horizontale.
• L’axe y correspond à la verticale.

Tracer uniquement des points (Markers)
Pour afficher seulement des points, on peut utiliser la notation 'o' :
xpoints = np.array([-1, 8])
ypoints = np.array([3, -10])
plt.plot(xpoints, ypoints, 'o')
plt.show()
Plusieurs points
On peut tracer plusieurs points successifs :
xpoints = np.array([1, 2, 6, 8])
ypoints = np.array([3, 8, 1, 10])
plt.show()
Sortie :
plt.plot(xpoints, ypoints) plt.plot(xpoints, ypoints, 'o')
Valeurs par défaut pour l’axe X
Si on ne précise pas les x-points, Matplotlib attribue automatiquement les valeurs 0, 1, 2,
3, ….
ypoints = np.array([3, 8, 1, 10, 5, 7])
plt.plot(ypoints)
plt.show()
Ici, les valeurs de x générées automatiquement sont [0, 1, 2, 3, 4, 5].
Matplotlib – Les Markers (Marqueurs)
Qu’est-ce qu’un Marker ?
Un marker est un symbole utilisé pour mettre en évidence les points dans un graphique.
Dans Matplotlib, on peut ajouter un marker à chaque point grâce au paramètre marker.

Exemple simple :
Tracer des points représentés par des cercles :
import numpy as np
plt.plot(ypoints, marker='o')
plt.show()
Changer le style du marker, par exemple une étoile :
plt.plot(ypoints, marker='*')
plt.show()
marker='o' marker='*'
Tableau des Markers disponibles
Marker Description Marker Description
'o' Cercle 'X' X (rempli)
'*' Étoile '+' Plus
'.' Point 'P' Plus (rempli)
',' Pixel 's' Carré
'x' X 'D' Losange
'd' Losange (fin) 'p' Pentagone
'H' Hexagone 'h' Hexagone
'^' Triangle haut 'v' Triangle bas
'<' Triangle gauche '>' Triangle droite
'1' Tri bas '2' Tri haut
'3' Tri gauche '4' Tri droite
`' '` Barre verticale '_'
Notation raccourcie (fmt)
On peut utiliser une notation compacte appelée fmt :
plt.plot(ypoints, 'o:r')
plt.show()

Ici :
• 'o' → marker cercle,
• ':' → ligne pointillée,
• 'r' → couleur rouge.
Types de lignes possibles
Syntaxe Description
'-' Ligne continue
':' Ligne pointillée
'--' Ligne en tirets
'-. ' Ligne tirets + points
Si on omet le style de ligne, seuls les markers sont tracés.
Couleurs abrégées
Syntaxe Couleur
'r' Rouge
'g' Vert
'b' Bleu
'c' Cyan
'm' Magenta
'y' Jaune
'k' Noir
'w' Blanc
Personnalisation des Markers
Taille (markersize ou ms)
plt.plot(ypoints, marker='o', ms=20)
plt.show()
Couleur des bords (markeredgecolor ou mec)
plt.plot(ypoints, marker='o', ms=20, mec='r')
plt.show()
Couleur de l’intérieur (markerfacecolor ou mfc)
plt.plot(ypoints, marker='o', ms=20, mfc='r')
plt.show()
Bord + intérieur
plt.plot(ypoints, marker='o', ms=20, mec='r', mfc='y')
plt.show()

Couleurs avancées
• Avec un code hexadécimal :
plt.plot(ypoints, marker='o', ms=20, mec='#4CAF50', mfc='#4CAF50')
plt.show()
• Avec un nom de couleur (parmi les 140 disponibles) :
plt.plot(ypoints, marker='o', ms=20, mec='hotpink', mfc='hotpink')
plt.show()
Matplotlib – Les Lignes et la Mise en Forme des Graphiques
Linestyle (Style de ligne)
On peut changer le style de la ligne tracée avec l’argument linestyle (ou sa version
courte ls).
Exemple 1 : ligne pointillée
import numpy as np
plt.plot(ypoints,
linestyle='dotted') # ou ls=':'
plt.show()
Exemple 2 : ligne en tirets
plt.plot(ypoints,
linestyle='dashed') # ou ls='--'
plt.show()
Principaux styles de ligne
Nom Abréviation
'solid' (défaut) '-'
'dotted' ':'
'dashed' '--'
'dashdot' '-. '
None (sans ligne) '' ou ' '

Couleur de la ligne
On peut définir la couleur avec l’argument color (ou c).
Exemple : ligne rouge
plt.plot(ypoints, color='r')
plt.show()
Exemple : couleur en hexadécimal
plt.plot(ypoints, c='#4CAF50')
plt.show()
Exemple : nom de couleur
plt.plot(ypoints, c='hotpink')
plt.show()
Largeur de la ligne
L’argument linewidth (ou lw) permet de modifier l’épaisseur.
Exemple : ligne épaisse
plt.plot(ypoints, linewidth=5)
plt.show()
Tracer plusieurs lignes
Exemple : deux lignes avec deux appels plot()
X = np.array([1, 2, 3, 4])
Y1 = np.array([3, 8, 1, 10])
Y2 = np.array([10, 20, 30, 40])
plt.plot(X, Y1, c='b', ls=':', marker='o',
ms=10, mec='r', mfc='y')
plt.plot(X, Y2, c='r', ls=':', marker='o',
ms=10, mec='b', mfc='#4CAF50')
plt.show()
Exemple : deux lignes dans le même plot()
X1 = np.array([1, 5, 10, 30])
Y1 = np.array([10, 15, 35, 25])
X2 = np.array([10, 20, 30, 40])
Y2 = np.array([25, 75, 50, 30])
plt.plot(X1, Y1, X2, Y2, c='b', ls=':',
marker='o', ms=10, mec='r',
mfc='y')
plt.show()
Labels et Titre
On ajoute des labels avec xlabel() et ylabel(), et un titre avec title().

X1 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
Y1 = np.array([2, 1, 4, 3, 6, 5, 8, 7, 10])
plt.plot(X1, Y1, c='r', ls='-.',
marker='o', ms=10, mec='r',
mfc='y')
plt.xlabel('Axe des X')
plt.ylabel('Axe des Y')
plt.title('Mon premier graphique')
plt.show()
Personnaliser les polices avec fontdict
X1 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
Y1 = np.array([2, 1, 4, 3, 6, 5, 8, 7, 10])
plt.plot(X1, Y1, c='r', ls='-.', marker='o', ms=10, mec='r', mfc='y')
font1 = {'family':'serif', 'color':'blue', 'size':20}
font2 = {'family':'serif',
'color':'darkred', 'size':15}
plt.title('Mon premier graphique',
fontdict=font1)
plt.xlabel('Axe des X', fontdict=font2)
plt.ylabel('Axe des Y', fontdict=font2)
plt.show()
Position du titre
Par défaut : center, mais on peut utiliser loc='left' ou loc='right'.
plt.title("Sports Watch Data", loc='left')
Ajouter une Grille
On ajoute des lignes de grille avec grid().
X1 = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9])
Y1 = np.array([2, 1, 4, 3, 6, 5, 8, 7, 10])
plt.plot(X1, Y1, c='r', ls='-.', marker='o', ms=10, mec='r', mfc='y')
font1 = {'family':'serif', 'color':'blue',
'size':20}
font2 = {'family':'serif',
'color':'darkred', 'size':15}
plt.title('Mon premier graphique',
fontdict=font1)
plt.xlabel('Axe des X', fontdict=font2)
plt.ylabel('Axe des Y', fontdict=font2)

plt.grid(True)
plt.grid(color='g', linestyle='--', linewidth=0.5)
plt.show()
• grid(axis='x') → grille uniquement verticale.
• grid(axis='y') → grille uniquement horizontale.
On peut aussi personnaliser le style :
plt.grid(color='green', linestyle='--', linewidth=0.5)
Subplots (plusieurs graphiques dans une même figure)
La fonction subplot() permet d’afficher plusieurs graphiques dans la même figure.
Exemple : 2 graphiques côte à côte
X = np.arange(0, 2*np.pi, 0.1)
Y1 = np.sin(X)
Y2 = np.cos(X)
# 1 ligne, 2 colonnes, 1er fig.
plt.subplot(1, 2, 1)
plt.plot(X, Y1, c='r', ls='-.')
# 1 ligne, 2 colonnes, 2ème fig.
plt.plot(X, Y2, c='g', ls='--')
plt.show()
Exemple : 2 graphiques l’un au-dessus de l’autre
Y1 = np.sin(X)
Y2 = np.cos(X)
# 2 lignes, 1 colonne, 1er fig.
plt.plot(X, Y1, c='r', ls='-.')
# 2 ligneS, 1 colonne, 2ème fig.
plt.plot(X, Y2, c='g', ls='--')
plt.show()
Exemple : 6 graphiques (2 lignes & 3 colones)
for i in range(1, 7):
plt.subplot(2, 3, i)
plt.plot([0,1,2,3],[i, -i*2, i*3, -i*4])
plt.show()

Titres dans Subplots
• title() → ajoute un titre à un seul graphique.
• suptitle() → ajoute un titre global à toute la figure.
Y1 = np.sin(X)
Y2 = np.cos(X)
plt.plot(X, Y1)
plt.title("Fonction Sinus")
plt.plot(X, Y2)
plt.title("Fonction Cosinus")
plt.suptitle("Fonctions
Périodiques")
plt.show()
Conclusion
Dans ce chapitre, nous avons appris à installer et importer MatPlotLib, à utiliser Pyplot pour
tracer nos premiers graphiques, et à personnaliser les markers, les lignes, les titres et
les axes. Nous avons également découvert l’intérêt des subplots pour comparer plusieurs
représentations dans une même figure.
Ces bases constituent un point de départ solide pour la suite. Dans le prochain chapitre, nous
allons explorer des types de graphiques spécialisés (scatter plots, bar charts,
histogrammes, pie charts) qui répondent à des besoins spécifiques d’analyse et de
communication des données.

Chapitre 2 : Types de graphiques spécialisés
Après avoir acquis les fondamentaux du traçage avec MatPlotLib, il est temps d’aller plus
loin et d’explorer des graphiques plus adaptés à des contextes particuliers d’analyse.
Dans ce chapitre, nous allons découvrir plusieurs types de représentations :
• le scatter plot (nuage de points), utile pour visualiser des relations ou des
regroupements,
• le bar chart (diagramme en barres), idéal pour comparer des catégories,
• l’histogramme, qui permet de représenter des distributions de fréquences,
• le pie chart (camembert), pratique pour mettre en évidence des proportions.
Nous apprendrons à personnaliser ces graphiques à travers les couleurs, les tailles,
les légendes et les colormaps, afin de rendre nos visualisations à la fois plus lisibles et plus
expressives.
Matplotlib – Scatter Plots (Nuages de points)
Créer un scatter plot
Avec Pyplot, on utilise la fonction scatter() pour représenter un nuage de points.
Chaque observation est représentée par un point sur le graphique.
• On a besoin de deux tableaux de même longueur :
o un pour les valeurs sur l’axe x (abscisses),
o un pour les valeurs sur l’axe y (ordonnées).
Exemple : scatter plot simple
X = np.random.rand(100)
Y = np.random.rand(100)
plt.scatter(X, Y)
plt.show()

Ce code génère un graphique de nuage de points avec 100 points placés aléatoirement. Le
résultat est un graphique avec des points dispersés aléatoirement dans un carré de 0 à 1 sur les
deux axes.
Comparer plusieurs ensembles de données
On peut afficher deux nuages de points sur un même graphique.
# Jour 1
x1 = np.random.randint(100,
size=(10))
y1 = np.random.randint(100,
size=(10))
plt.scatter(x1, y1)
# Jour 2
size=(20))
size=(20))
plt.scatter(x2, y2)
# Jour 3
x3 = np.random.randint(100, size=(5))
y3 = np.random.randint(100, size=(5))
plt.scatter(x3, y3)
plt.show()
Par défaut, Matplotlib attribue automatiquement des couleurs différentes (bleu et orange).
Couleurs des points
Exemple : choisir une couleur fixe
plt.scatter(x1, y1, color='hotpink')
plt.scatter(x2, y2, color='#88c999')
plt.show()
Exemple : une couleur différente pour chaque point
colors = np.array(["red","green","blue","yellow","pink", "black",
"orange", "purple",
"beige", "brown", "gray",
"cyan", "magenta"])
size=(13))
size=(13))
plt.scatter(x1, y1, c=colors)
plt.show()

Colormaps - une palette de couleurs graduée
Un colormap est une palette de couleurs graduée de 0 à 100 (Exemple : 'viridis' va du violet
au jaune).
Exemple avec colormap
colors = np.array([0,10,20,30,40,45,50,55,60,70,80,90,100])
plt.scatter(x1, y1, c=colors, cmap='viridis')
plt.colorbar() # ajoute une échelle de couleurs
plt.show()
On peut choisir parmi de nombreux colormaps intégrés : viridis, plasma, coolwarm,
autumn, jet, etc.
plasma coolwarm
autumn jet

Taille des points
Avec le paramètre s, on peut définir la taille de chaque point. Comme pour les couleurs, on
peut utiliser un tableau.
Exemple : tailles personnalisées
sizes = np.array([20, 50, 100, 200,
500, 1000, 60, 90, 10, 300,
600, 800, 75])
colors = np.array([0, 10, 20, 30, 40,
45, 50, 55, 60, 70, 80, 90,
100])
plt.scatter(x1, y1, s=sizes, c=colors)
plt.show()
Matplotlib – Diagrammes en barres (Bar Charts)
Créer un diagramme en barres
La fonction bar() permet de tracer un diagramme en barres verticales.
• Le premier argument représente les catégories (axe X).
• Le second argument représente leurs valeurs (axe Y).
Exemple : 4 barres simples
import numpy as np
X = np.array(['A', 'B', 'C', 'D', 'E'])
Y = np.array([3, 8, 1, 10, 5])
plt.bar(X, Y)
plt.show()
Exemple avec catégories personnalisées
x = ["APPLES", "BANANAS"]
y = [400, 350]
plt.bar(x, y)
plt.show()

Diagrammes horizontaux
Pour afficher les barres horizontalement, on utilise barh().
import numpy as np
X = np.array(['A', 'B', 'C', 'D', 'E'])
Y = np.array([3, 8, 1, 10, 5])
plt.barh(X, Y)
plt.show()
Couleur des barres
On peut personnaliser la couleur avec l’argument color.
Exemple : barres rouges
plt.bar(x, y, color="red")
plt.show()
Exemple : couleur par nom
plt.bar(x, y, color="hotpink")
plt.show()
Exemple : couleur hexadécimale
plt.bar(x, y, color="#4CAF50")
plt.show()
Largeur et Hauteur des barres
• Pour les barres verticales (bar()), on utilise width.
• Pour les barres horizontales (barh()), on utilise height.
• La valeur par défaut est 0.8.
Exemple : barres verticales très fines
plt.bar(x, y, width=0.1)
plt.show()
Exemple : barres horizontales très fines
plt.barh(x, y, height=0.1)
plt.show()
Voici un exemple qui utilise toutes ces propretés :

import numpy as np
X = np.array(["Apple", "Banana", "Orange",
"Mango", "Pear", "Kiwi"])
IG = np.array([38, 62, 43, 60, 42, 53])
colors = np.array(["green",
"black","pink", "red","yellow","blue"])
plt.bar(X, IG, color=colors, width=0.4)
plt.xlabel("Fruits")
plt.ylabel("Indices Glycémiques")
plt.title("Indices Glycémiques of Fruits")
plt.show()
Matplotlib – Histogrammes
Qu’est-ce qu’un histogramme ?
Un histogramme est un graphique qui représente la distribution de fréquences.
• L’axe X est découpé en intervalles (ou classes).
• L’axe Y indique le nombre d’observations dans chaque intervalle.
👉 Exemple : si vous mesurez la taille de 250 personnes, l’histogramme permet de voir combien
de personnes se trouvent dans les tranches [160–165 cm], [165–170 cm], etc.
Ainsi, vous pouvez lire rapidement combien de personnes appartiennent à chaque groupe.
Créer un histogramme avec Matplotlib
On utilise la fonction hist().
• Elle prend en entrée un tableau de valeurs numériques.
• Elle calcule automatiquement les fréquences et trace le graphique.
Exemple : distribution de données aléatoires
Ici, on génère avec NumPy un tableau de 250 valeurs :
• moyenne centrée autour de 170 cm,
• écart-type de 10 cm.

import numpy as np
# Générer 250 valeurs avec
distribution normale
x = np.random.normal(170, 10, 250)
# Créer l’histogramme
plt.hist(x)
plt.show()
Cet histogramme représente une distribution normale (en cloche) des tailles.
Matplotlib – Diagrammes Circulaires (Pie Charts)
Qu’est-ce qu’un diagramme circulaire ?
Un diagramme circulaire (ou camembert) est un graphique qui permet de représenter
la répartition d’un tout en différentes parts.
Chaque secteur (wedge) correspond à une proportion calculée selon la formule :
𝑝𝑎𝑟𝑡 =
𝑉𝑎𝑙𝑒𝑢𝑟
𝑡𝑜𝑡𝑎𝑙 𝑑𝑒𝑠 𝑣𝑎𝑙𝑒𝑢𝑟𝑠
C’est donc un outil utile pour comparer des catégories entre elles.
Créer un camembert simple
La fonction pie() est utilisée :
import numpy as np
y = np.array([35, 25, 25, 15])
plt.pie(y)
plt.show()
👉 Ici, le tableau [35, 25, 25, 15] est réparti en 4 parts. La taille de chaque secteur est
proportionnelle à sa valeur.
Ajouter des étiquettes (labels)
Il est courant de nommer chaque secteur pour une meilleure compréhension.

import numpy as np
y = np.array([35, 25, 25, 15])
mylabels = ["Apples", "Bananas", "Cherries",
"Dates"]
plt.pie(y, labels=mylabels)
plt.show()
Modifier l’angle de départ
Par défaut, le premier secteur commence à l’axe des abscisses (0°). On peut changer cela
avec startangle.
plt.pie(y, labels=mylabels, startangle=90)
plt.show()
Mettre un secteur en évidence (explode)
L’argument explode permet de "décoller" une part du cercle.
myexplode = [0.2, 0, 0, 0] # Décaler uniquement "Pommes"
plt.pie(y, labels=mylabels, explode=myexplode)
plt.show()
Ajouter une ombre
plt.pie(y, labels=mylabels, explode=myexplode, shadow=True)
plt.show()
Personnaliser les couleurs
Vous pouvez utiliser :
• des noms de couleurs ("red", "hotpink")
• des codes hexadécimaux ("#4CAF50")
• ou des abréviations ('r' pour rouge, 'g' pour vert, 'b' pour bleu, etc.).
mycolors = ["black", "hotpink", "b", "#4CAF50"]
plt.pie(y, labels=mylabels, colors=mycolors)
plt.show()
Ajouter une légende
plt.pie(y, labels=mylabels)
plt.legend(title="Quatre fruits :")
plt.show()

Exemple complet
Voici un exemple complet qui illustre l’ensemble des paramètres de personnalisation d’un
camembert dans Matplotlib.
Nous combinons ici plusieurs options :
• startangle pour modifier l’angle de départ (non utilisé ici mais facilement
ajoutable),
• explode pour décaler légèrement chaque secteur,
• colors pour définir manuellement les couleurs des parts,
• shadow pour ajouter une ombre,
• et legend pour afficher une légende claire en haut à gauche du graphique.
import numpy as np
y = np.array([35, 25, 25, 15])
mylabels = ["Apples", "Bananas", "Cherries", "Dates"]
myexplode = [0.1, 0.1, 0.1, 0.1] # Décaler uniquement "Pommes"
mycolors = ["green", "hotpink", "b", "#FFAF00"]
plt.pie(y, labels=mylabels, explode=myexplode, colors=mycolors,
shadow=True)
plt.legend(title="Quatre fruits :", loc="upper left")
plt.show()
Sortie :

Conclusion
Dans ce chapitre, nous avons vu comment créer et personnaliser différents graphiques
spécialisés : scatter plots, bar charts, histogrammes et pie charts. Chacun de ces
outils nous permet de représenter les données selon une perspective particulière, qu’il s’agisse
d’analyser des relations, de comparer des catégories, de visualiser une distribution ou de
montrer une répartition en pourcentages.
Ces techniques enrichissent considérablement nos capacités de visualisation et constituent un
pont naturel vers des représentations plus avancées. Dans le chapitre suivant, nous allons
franchir une nouvelle étape avec la visualisation en 3D, qui permet d’explorer et de représenter
des données dans un espace tridimensionnel.

Chapitre 3 : Visualisation 3D
Jusqu’ici, nos représentations étaient limitées à deux dimensions (2D). Cependant, dans de
nombreux cas, les données que nous analysons comportent trois variables ou plus, et il devient
alors nécessaire de passer à une visualisation en 3D.
Dans ce chapitre, nous allons découvrir comment utiliser le module mpl_toolkits.mplot3d de
MatPlotLib pour créer des graphiques tridimensionnels. Nous commencerons par distinguer
l’approche fonctionnelle et l’approche orientée objet (POO), puis nous apprendrons à générer
différents types de graphiques 3D :
• un scatter plot 3D (nuage de points),
• une surface 3D représentant une fonction mathématique,
• un histogramme 3D (bar3d) pour comparer des volumes.
Nous verrons enfin d’autres possibilités offertes par MatPlotLib en 3D, et comment elles
ouvrent la voie à des visualisations plus complexes et plus expressives.
Approches POO vs fonctionnelle
Jusqu’ici, nous avons appris à utiliser MatPlotLib en 2 dimensions (2D) : tracer des courbes,
des histogrammes, des camemberts, etc. Mais dans de nombreux cas, les données ou les
fonctions que l’on souhaite représenter ont trois dimensions.
Par exemple :
• les coordonnées spatiales d’un objet (X, Y, Z),
• un nuage de points dans un problème de machine learning,
• la représentation d’une fonction de deux variables f(x,y)f(x,y) sous forme de surface.
Pour ce type de visualisation, MatPlotLib propose un module spécial :
from mpl_toolkits.mplot3d import Axes3D
Ce module permet de créer un objet appelé Axes3D, qui gère les trois axes (X, Y et Z).
Deux façons de travailler avec MatPlotLib
Avant d’aller plus loin, il est important de comprendre qu’il existe deux approches pour tracer
des graphiques :
Approche fonctionnelle
• On appelle directement les fonctions de pyplot (plt.plot(), plt.bar(), etc.).
• Exemple :
• import matplotlib.pyplot as plt

• plt.plot([1, 2, 3], [4, 5, 6])
• plt.show()
• Simple, rapide, adaptée aux graphiques 2D.
Approche orientée objet (POO)
• On crée nous-mêmes les objets Figure et Axes, puis on appelle leurs méthodes.
• Exemple en 2D :
• fig, ax = plt.subplots()
• ax.plot([1, 2, 3], [4, 5, 6])
• plt.show()
À retenir
👉 En 2D, les deux approches fonctionnent.
👉 En 3D, il faut obligatoirement utiliser l’approche POO, car les graphiques 3D nécessitent la
création d’un objet Axes3D.
Bon à savoir : Deux façons de créer un axe 3D
En MatPlotLib, il existe deux méthodes équivalentes pour créer un axe 3D.
Avec figure() et add_subplot() (méthode classique)
from mpl_toolkits.mplot3d import Axes3D
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
• On crée d’abord une figure vide (plt.figure()).
• Puis on ajoute un axe avec add_subplot().
• L’argument 111 signifie : 1 ligne, 1 colonne, 1er axe.
• Cette méthode est flexible si l’on veut plusieurs axes positionnés dans une même
figure.
Avec subplots() (méthode recommandée)
fig, ax = plt.subplots(subplot_kw={"projection": "3d"})
• Ici, la fonction plt.subplots() crée en une seule ligne la figure et l’axe.
• L’argument subplot_kw={"projection": "3d"} précise que l’axe doit être en 3D.
• Cette écriture est plus moderne et plus concise, conseillée par la documentation
officielle.
À retenir
• Pour un seul graphique, utilisez plutôt subplots() : plus simple et lisible.

• Pour organiser plusieurs graphiques dans une figure,
utilisez figure() + add_subplot() : plus flexible.
Voici un tableau comparatif entre add_subplot() et subplots()
Méthode Exemple de code Points forts Quand l’utiliser ?
figure()
+
add_subplot()
fig = plt.figure()
ax = fig.add_subplot(111,
projection='3d')
Très flexible : permet
d’ajouter plusieurs
axes dans des
positions précises
Quand on veut
organiser plusieurs
graphiques dans la
même figure
subplots() fig, ax =
plt.subplots(subplot_kw={
"projection": "3d"})
Simple, moderne,
lisible. Crée figure +
axe en une seule ligne
Quand on a besoin
d’un seul graphique
(cas le plus courant)
MatPlotLib – Graphiques 3D (Exemples pratiques)
Dans cette partie, nous allons apprendre à tracer des graphiques en 3D avec MatPlotLib.
Comme expliqué dans l’introduction, nous avons deux façons de créer un axe 3D :
• la méthode classique avec figure() et add_subplot(),
• la méthode plus moderne avec subplots() (recommandée par la documentation
officielle).
• 👉 Dans la suite de ce support, nous allons adopter la version officielle
avec subplots(), car elle est plus simple et plus lisible.
Exemple 1 – Nuage de points en 3D (scatter)
Un nuage de points en 3D permet de représenter des données qui ont trois coordonnées (X, Y
et Z). Chaque point est placé dans l’espace selon ses trois valeurs, et on peut lui attribuer une
couleur et une transparence.
import numpy as np
# Génération aléatoire de 5 points
X = np.random.rand(5)
Y = np.random.rand(5)
Z = np.random.rand(5)
colors = ["red", "green", "yellow", "blue", " black"]
sizes = [100, 100, 100, 100, 100]
# Création de la figure et de l'axe 3D avec subplots
# Tracer le nuage de points
ax.scatter(X, Y, Z, c=colors, s=sizes, alpha=0.5)
plt.show()

Sortie
Explication étape par étape :
• Créer les données : X, Y, Z contiennent chacun 5 valeurs aléatoires entre 0 et 1.
• Définir les couleurs : on affecte une couleur différente à chaque point.
• Créer l’axe 3D : fig, ax = plt.subplots(subplot_kw={"projection":
"3d"}).
• Tracer les points : ax.scatter(X, Y, Z, c=colors, alpha=0.5).
o c → couleur des points.
o s → taille des points.
o alpha → transparence (ici 0.5 = 50%).
NB : Ce type de graphique est très utile pour visualiser la répartition de données dans un
espace 3D, par exemple pour voir si des points forment des regroupements (clusters).
Exemple 2 – Surface 3D (plot_surface)
On peut aussi représenter une fonction mathématique de deux variables f(x,y)f(x,y) sous
forme de surface.
Ici, nous allons tracer :
𝑓(𝑥, 𝑦) = sin(𝑥) ∗ cos (𝑥 + 𝑦)
import numpy as np
# Définition des valeurs de x et y
Y = np.arange(0, 2*np.pi, 0.1)
# Création d'une grille (plan de points)
X, Y = np.meshgrid(X, Y)
# Calcul de la fonction sur chaque point (x, y)
Z = np.sin(X) * np.cos(X + Y)

# Création de la figure et de l'axe 3D
fig, ax = plt.subplots(subplot_kw={"projection": "3d"}, figsize=(10, 10))
# Tracer la surface
ax.plot_surface(X, Y, Z, cmap="viridis")
plt.show()
Sortie
• Définir les axes X et Y : ici, de 0 à 2π2π avec un pas de 0.1.
• Créer une grille (meshgrid) : np.meshgrid(X, Y) génère toutes les combinaisons
possibles de (x, y).
• Définir la fonction : on calcule Z pour chaque couple (X, Y).
• Créer la figure et l’axe 3D : comme précédemment, avec subplots().
• Tracer la surface : ax.plot_surface(X, Y, Z, cmap="viridis").
o cmap applique un colormap (ici “viridis”) pour colorer la surface.
Ce type de graphique est idéal pour visualiser la forme d’une fonction ou pour observer une
surface d’erreur en optimisation.
Exemple 3 – Histogramme 3D (bar3d)
La fonction bar3d() permet de tracer des barres en 3 dimensions, un peu comme un
histogramme mais étendu dans l’espace 3D.
Chaque barre est définie par :
• sa base (coordonnées x, y, z),
• ses dimensions (largeur dx, profondeur dy, hauteur dz).
import numpy as np

# Style optionnel (pour un rendu plus propre)
plt.style.use('_mpl-gallery')
# Définition des positions des barres
x = [1, 1, 2, 2]
y = [1, 2, 1, 2]
z = [0, 0, 0, 0] # toutes les barres commencent au niveau 0 (axe Z)
# Dimensions des barres
dx = np.ones_like(x) * 0.5 # largeur des barres (axe X)
dy = np.ones_like(y) * 0.5 # profondeur des barres (axe Y)
dz = [2, 3, 1, 4] # hauteurs des barres (axe Z)
# Création de la figure et de l'axe 3D
# Tracer les barres en 3D
ax.bar3d(x, y, z, dx, dy, dz)
# Optionnel : supprimer les étiquettes des axes pour plus de lisibilité
ax.set(xticklabels=[], yticklabels=[], zticklabels=[])
plt.show()
Sortie
• Définir la base des barres :
o (x, y, z) indique la position de départ de chaque barre.
o Ici, toutes commencent à z=0.
• Définir les dimensions :
o dx = largeur selon l’axe X,
o dy = profondeur selon l’axe Y,
o dz = hauteur selon l’axe Z (comme la valeur d’un histogramme).
• Créer la figure et l’axe 3D :

fig, ax = plt.subplots(subplot_kw={"projection": "3d"}).
• Tracer les barres :
ax.bar3d(x, y, z, dx, dy, dz).
Ce type de graphique est utile pour représenter des comptages ou des volumes dans un espace
3D.
Par exemple, on peut l’utiliser pour visualiser des données statistiques réparties sur deux
variables (axe X et axe Y) et leur valeur (axe Z).
Autres exemples
En plus des exemples que nous avons détaillés (nuage de points scatter, surface
3D plot_surface et histogramme 3D bar3d), MatPlotLib propose plusieurs autres types de
graphiques en 3D. Voici une présentation rapide :
• bar3d(x, y, z, dx, dy, dz) : permet de tracer des barres en 3D, comme un
histogramme étendu dans l’espace.
• fill_between(x1, y1, z1, x2, y2, z2) : sert à remplir l’espace entre deux
surfaces ou deux courbes en 3D.
• plot(xs, ys, zs) : trace une courbe en 3D reliant une suite de points.
• quiver(X, Y, Z, U, V, W) : dessine des flèches 3D, souvent utilisées pour
représenter des champs vectoriels.
• scatter(xs, ys, zs) : trace un nuage de points en 3D, utile pour visualiser la
répartition de données.
• stem(x, y, z) : représente des valeurs en 3D sous forme de tiges verticales.
• plot_surface(X, Y, Z) : trace une surface continue en 3D, définie par une
fonction de deux variables.
• plot_trisurf(x, y, z) : permet de représenter une surface 3D construite à partir de
points non structurés (triangulation).
• voxels([x, y, z], filled) : affiche des volumes 3D en forme de cubes (voxels),
utiles en imagerie ou en simulation.
• plot_wireframe(X, Y, Z) : trace une surface sous forme de maillage, en reliant
les points par des lignes.
NB : Comme tu peux le voir, MatPlotLib propose une grande variété de diagrammes en 3D,
chacun adapté à un besoin particulier.
Pour découvrir ces fonctionnalités en détail, vous êtes invités à consulter la documentation
officielle de MatPlotLib : https://matplotlib.org/stable/plot_types/3D/index.html.
Conclusion
Dans ce chapitre, nous avons découvert la visualisation 3D avec MatPlotLib : nuages de
points, surfaces continues et histogrammes en trois dimensions. Nous avons également vu que
l’approche POO est indispensable pour manipuler des axes 3D et que MatPlotLib offre une

grande variété d’outils (plot_surface, bar3d, quiver, voxels, etc.) pour représenter les
données dans l’espace.
Ces compétences constituent une étape avancée dans la maîtrise de MatPlotLib. Elles préparent
l’étudiant à l’utilisation de bibliothèques complémentaires comme Seaborn (visualisations
statistiques avancées) et Pandas (intégration de la visualisation aux structures de données), qui
feront l’objet des prochains chapitres du module Python pour les sciences de données.

Conclusion générale
Ce support de cours a permis d’explorer les fonctionnalités essentielles de Matplotlib, depuis
les bases du tracé de graphiques avec Pyplot jusqu’aux représentations plus spécialisées
comme les nuages de points, les diagrammes en barres, les histogrammes, les camemberts, ainsi
que les visualisations en trois dimensions. L’étudiant a ainsi pu constater que Matplotlib ne
se limite pas à un simple outil de traçage, mais constitue une boîte à outils fondamentale pour
la communication visuelle des données en Data Science.
Grâce aux notions acquises, il est désormais possible de :
• créer et personnaliser différents types de graphiques,
• manipuler les couleurs, styles, polices et légendes pour adapter les visualisations aux
besoins d’analyse,
• utiliser efficacement les subplots pour comparer plusieurs jeux de données,
• représenter des informations dans un espace tridimensionnel.
Ces compétences constituent un socle indispensable pour aborder les prochaines étapes du
module Python pour les sciences de données, notamment :
• Seaborn, qui repose sur Matplotlib pour produire des visualisations statistiques
avancées,
• Pandas, qui intègre des fonctions de visualisation basées sur Matplotlib,
• ainsi que les bibliothèques de Machine Learning comme scikit-learn, où la
représentation graphique des données et des résultats joue un rôle central.
En conclusion, la maîtrise de Matplotlib place l’étudiant dans une position solide pour
progresser dans le domaine de la Data Science et de l’Intelligence Artificielle, en lui offrant les
compétences nécessaires pour transformer des données brutes en informations visuelles
claires, interprétables et communicables.

Introduction complète à MatPlotLib : Fondamentaux, Graphiques 2D et Visualisation 3D en Python

Contenu connexe

Similaire à Introduction complète à MatPlotLib : Fondamentaux, Graphiques 2D et Visualisation 3D en Python

Plus de Youssouf EL ALLIOUI

Dernier

Introduction complète à MatPlotLib : Fondamentaux, Graphiques 2D et Visualisation 3D en Python