Cours_D3SI_S5_Python for DS_MatPlotLib.pdf

Matplotlib : Introduction
Tracé avec Matplotlib
Python pour la science des données
Youness MADANI
Université Sultan Moulay Slimane
Faculté Polydisciplinaire
Licence d’excellence
Data Science et Sécurité des Systèmes d’Information
27 février 2024
1/78 Youness MADANI Cours : Module- Python - Datascience

Outline
1 Matplotlib : Introduction
2 Tracé avec Matplotlib

DataFrames
Matplotlib est une bibliothèque de visualisation de données en Python
largement utilisée et appréciée dans le domaine de la science des données, de
l’apprentissage automatique, de la recherche scientifique et d’autres domaines
connexes.
Cette bibliothèque permet de créer une variété de graphiques et de
visualisations de manière efficace et personnalisable.
Matplotlib est construite sur des tableaux NumPy ou des séries pandas et
comprend plusieurs types de graphiques tels que les graphiques en ligne, à
barres, d’histogramme, etc.
Matplotlib ouvre littéralement un tout nouveau monde de possibilités pour vous.
Surtout lorsqu’il est utilisé avec la bibliothèque Numpy ou Pandas, nous pouvons
réaliser des choses inimaginables.

DataFrames
Pour installer Matplotlib, vous pouvez utiliser la commande pip dans votre
terminal ou invite de commandes. Assurez-vous d’avoir Python installé sur votre
système avant de procéder à l’installation de Matplotlib.
Cela téléchargera et installera la dernière version stable de Matplotlib depuis le
référentiel Python Package Index (PyPI).
Si vous utilisez Anaconda, l’installation de Matplotlib est généralement simple.
Vous pouvez utiliser le gestionnaire de paquets conda, qui est intégré à
Anaconda, pour installer la bibliothèque.
Après l’installation, vous pouvez commencer à utiliser Matplotlib dans vos scripts
Python en important la bibliothèque dans votre code :
1 import matplotlib.pyplot as plt
La plupart des utilitaires Matplotlib se trouvent dans le sous-module pyplot et
sont généralement importés sous l’alias plt.

DataFrames
Matplotlib propose une grande variété de graphiques. Les graphiques aident à
comprendre les tendances et les motifs, et à établir des corrélations.
Ce sont généralement des instruments pour raisonner sur des informations
quantitatives.
Chaque 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 :bar().
histogrammes :hist().
diagrammes circulaires :pie().
La boı̂te à moustaches, également appelée boxplot : boxplot()

DataFrames
Diagrammes en ligne ou en courbes
Matplotlib offre la possibilité de créer des diagrammes en ligne ou en courbes à
l’aide de la fonction plot().
Ces types de diagrammes sont particulièrement utiles pour représenter la relation
entre deux ensembles de données continus.
Par défaut, la fonction plot() trace une ligne de point à point.
La fonction prend des paramètres pour spécifier les points dans le diagramme.
Le paramètre 1 est un tableau contenant les points sur l’axe des x.
Le paramètre 2 est un tableau contenant les points sur l’axe des y.
Si nous devons tracer une ligne de (2, 4) à (9, 11), nous devons passer deux
tableaux [2, 9] et [4, 11] à la fonction plot.
2 import numpy as np
3 xpoints = np.array([2, 9])
4 ypoints = np.array([4, 11])
5 plt.plot(xpoints, ypoints)
6 plt.show()

DataFrames
Diagrammes en ligne ou en courbes
La fonction show() dans Matplotlib est utilisée pour afficher les graphiques ou les
figures créées.
Lorsque vous créez un ou plusieurs graphiques à l’aide de Matplotlib, ces
graphiques ne sont pas automatiquement affichés à l’écran. Vous devez
explicitement appeler la fonction show() pour les rendre visibles.
Notez que lorsque vous utilisez Matplotlib dans un environnement interactif, tel
que un Jupyter notebook, l’appel à show() n’est parfois pas nécessaire, car le
graphique peut être affiché automatiquement. Cependant, il est une bonne
pratique d’inclure show() pour garantir la cohérence dans différents contextes
d’utilisation de Matplotlib.

DataFrames
Diagrammes en ligne ou en courbes : Tracé sans ligne
Pour tracer uniquement les marqueurs, vous pouvez utiliser la notation de chaı̂ne
raccourcie avec le paramètre ’o’, qui signifie ’rings’ ou anneaux.
Matplotlib offre plusieurs valeurs permettant de spécifier différents styles de
marqueurs pour les points dans un graphique. Voici quelques-unes des valeurs
couramment utilisées :
’o’ : Cercle
’s’ : Carré
’D’ : Losange
ˆ : Triangle pointant vers le haut
’v’ : Triangle pointant vers le bas
’<’ : Triangle pointant vers la gauche
’>’ : Triangle pointant vers la droite
’p’ : Pentagone
’h’ : Hexagone
’*’ : Étoile
’+’ : Plus
’x’ : Croix
’.’ : Point

DataFrames
Diagrammes en ligne ou en courbes : Tracé sans ligne
3 xpoints = np.array([2, 9])
4 ypoints = np.array([4, 11])
5 plt.plot(xpoints, ypoints, ’o’)
6 plt.show()

DataFrames
Diagrammes en ligne ou en courbes : Multiples points
Vous pouvez tracer autant de points que vous le souhaitez, assurez-vous
simplement d’avoir le même nombre de points dans les deux axes.
Tracez une ligne dans un diagramme depuis la position (2, 4) jusqu’à (3, 7), puis
jusqu’à (5, 0) et enfin jusqu’à la position (8, 10).
3 xpoints = np.array([2, 3, 5, 8])
4 ypoints = np.array([4, 7, 0, 10])
5 plt.plot(xpoints, ypoints)
6 plt.show()

DataFrames
Diagrammes en ligne ou en courbes : Multiples points

DataFrames
Diagrammes en ligne ou en courbes : Points X par défaut
Si nous ne spécifions pas les points sur l’axe des x, ils prendront les valeurs par
défaut 0, 1, 2, 3, etc., en fonction de la longueur des points sur l’axe des y.
Chaque point sera donc associé à un indice, qui sera utilisé comme valeur de
l’axe des x.
3 ypoints = np.array([4, 7, 0, 10])
4 plt.plot(ypoints)
5 plt.show()
Les points sur l’axe des x dans l’exemple ci-dessus sont [0, 1, 2, 3].

DataFrames
Diagrammes en ligne ou en courbes : Marqueur
Matplotlib offre une variété de marqueurs que vous pouvez utiliser pour
représenter les points sur vos graphiques.
Vous pouvez spécifier le style de marqueur en utilisant le paramètre marker dans
la fonction plot.
3 X = np.array([1, 6, 3, 4, 2])
4 Y = np.array([5, 8, 2, 5, 4])
5 plt.plot(X, Y, marker = ’o’)
6 plt.show()

DataFrames
Diagrammes en ligne ou en courbes : Le paramètre linestyle
Le paramètre linestyle dans la fonction plot de Matplotlib est utilisé pour
spécifier le style de la ligne reliant les points.
Vous pouvez choisir parmi différentes options pour définir le style de la ligne.
vous pouvez utiliser le mot-clé argument linestyle, ou l’alias ls, pour modifier le
style de la ligne tracée
Voici quelques valeurs courantes pour le paramètre linestyle :
’-’ ou la valeur solid : Ligne pleine (par défaut)
’- -’ ou la valeur dashed : Ligne en tirets
’ :’ ou la valeur dotted : Ligne en pointillés
’-.’ ou la valeur dashdot : Combinaison de lignes en tirets et points
3 X = np.array([1, 6, 3, 4, 2])
4 Y = np.array([5, 8, 2, 5, 4])
5 plt.plot(X, Y, marker = ’o’,
linestyle=’:’)
6 plt.show()

DataFrames
Diagrammes en ligne ou en courbes : Le paramètre color
Le paramètre color (ou l’alias c) dans la fonction plot() de Matplotlib est utilisé
pour spécifier la couleur de la ligne reliant les points. Vous pouvez choisir la
couleur en utilisant une chaı̂ne de caractères avec le nom de la couleur (par
exemple, ’red’, ’blue’, ’green’, etc.), ou en utilisant un code hexadécimal (par
exemple, ’#FF5733’).
vous pouvez spécifier la couleur en utilisant une lettre pour représenter des
couleurs de base dans la fonction plot :
Par exemple, ’b’ : bleu, ’g’ : vert, ’r’ : rouge, ’c’ : cyan, ’m’ : magenta, ’y’ :
jaune, ’k’ : noir, ’w’ : blanc.
3 X = np.array([1, 6, 3, 4, 2])
4 Y = np.array([5, 8, 2, 5, 4])
5 plt.plot(X, Y, marker = ’o’,
linestyle=’:’, color=’#FF0000’)
6 plt.show()

DataFrames
Diagrammes en ligne ou en courbes : Formater les chaı̂nes fmt
Dans Matplotlib, il existe une notation de chaı̂ne raccourcie pour spécifier
simultanément la couleur, le style de ligne et le style de marqueur.
La syntaxe de la chaı̂ne fmt est une combinaison de codes de couleur, de styles
de ligne et de styles de marqueur.
fmt = ’[color][marker][line]’
Si vous excluez la valeur de la ligne dans le paramètre fmt, aucune ligne ne
sera tracée.
3 # Utilisation de la chaı̂ne fmt
4 X = np.array([1, 2, 3, 4, 5])
5 Y = np.array([2, 4, 6, 8, 10])
6 plt.plot(X, Y, ’rX-.’)
7 plt.show()

DataFrames
Diagrammes en ligne ou en courbes : Taille du marqueur
Pour spécifier la taille du marqueur dans la fonction plot de Matplotlib, vous
pouvez utiliser le paramètre markersize ou son alias ms.
Ce paramètre vous permet de définir la taille des marqueurs en points(pt).
Dans le contexte de la bibliothèque Matplotlib, l’unité de mesure pour la taille des
marqueurs est le point (pt). Un point est une unité de mesure typiquement utilisée
en imprimerie et en conception graphique. En termes simples, 1 point est
équivalent à environ 1/72 de pouce.
3 X = np.array([1, 2, 3, 2, 5])
4 Y = np.array([2, 4, 6, 7, 10])
5 plt.plot(X, Y, marker=’o’, ms=20,
color=’green’)
6 plt.show()

DataFrames
Diagrammes en ligne ou en courbes : Couleur du marqueur
La couleur du marqueur dans la fonction plot de Matplotlib peut être spécifiée en
utilisant le paramètre markeredgecolor ou mec pour définir la couleur du bord du
marqueur et markerfacecolor ou mfc pour définir la couleur de remplissage du
marqueur. Vous pouvez également utiliser le paramètre markeredgewidth pour
définir la largeur du bord du marqueur.
3 X = np.array([1, 2, 3, 2, 5])
4 Y = np.array([2, 4, 6, 7, 10])
5 plt.plot(X, Y, marker=’o’, ms=20,
markeredgecolor=’r’,
markerfacecolor=’g’,markeredgewidth=2)
6 plt.show()
Vous pouvez également utiliser des valeurs de couleur hexadécimale
#rrggbb. ex : #FF0000 pour la couleur rouge

DataFrames
Diagrammes en ligne ou en courbes : La largeur de la ligne
La largeur de la ligne dans la fonction plot de Matplotlib peut être spécifiée à l’aide
du paramètre linewidth ou de son alias lw.
Ce paramètre permet de définir l’épaisseur de la ligne reliant les points du
graphique.
La valeur est un nombre décimal, en points.
3 X = np.array([1, 2, 3, 2, 5])
4 Y = np.array([2, 4, 6, 7, 10])
5 plt.plot(X, Y, lw=8)
6 plt.show()

DataFrames
Diagrammes en ligne ou en courbes : Plusieurs lignes
Pour tracer plusieurs lignes avec la fonction plot de Matplotlib, vous pouvez
simplement appeler cette fonction plusieurs fois avec différentes données pour les
axes x et y.
Chaque appel à plot ajoutera une nouvelle ligne au graphique.
3 Y1 = np.array([1, 2, 3, 2, 5])
4 Y2 = np.array([2, 4, 6, 7, 10])
5 plt.plot(Y1, ’ro--’)
6 plt.plot(Y2, ’gx:’)
7 plt.show()
Dans les exemples ci-dessus, nous avons seulement spécifié les points sur l’axe
des y, ce qui signifie que les points sur l’axe des x ont reçu les valeurs par défaut
(0, 1, 2, 3, 4).

DataFrames
Diagrammes en ligne ou en courbes : Plusieurs lignes
Vous pouvez également tracer plusieurs lignes en ajoutant les points pour les
axes x et y de chaque ligne dans la même fonction plt.plot().
3 X1 = np.array([0, 1, 2, 3])
4 Y1 = np.array([3, 8, 1, 10])
5 X2 = np.array([0, 1, 2, 3])
6 Y2 = np.array([6, 2, 7, 11])
7 plt.plot(X1, Y1, X2, Y2)
8 plt.show()

DataFrames
Diagrammes en ligne ou en courbes : Étiquettes et titre
Matplotlib permet d’ajouter des étiquettes aux axes, une légende et un titre à vos
graphiques pour améliorer leur lisibilité et leur compréhension.
Étiquettes des axes : Utilisez plt.xlabel() et plt.ylabel() pour ajouter des
étiquettes à l’axe des x et des y, respectivement.
Titre du graphique : Utilisez plt.title() pour ajouter un titre à votre graphique.
Légende : Utilisez plt.legend() pour ajouter une légende à votre graphique.
Vous pouvez également spécifier les labels des lignes en utilisant l’argument label
dans la fonction plot.

DataFrames
Diagrammes en ligne ou en courbes : Étiquettes et titre
3 Age = np.array([22, 25, 30, 35, 40])
4 Salaire = np.array([5000, 7500.25, 8000,
9000.50, 12000])
5 plt.plot(Age, Salaire, label = "Ligne 1")
6 plt.title("La relation entre le salaire
et l’age")
7 plt.xlabel("Age")
8 plt.ylabel("Salaire")
9 plt.legend()
10 plt.show()

DataFrames
Diagrammes en ligne ou en courbes : Définir les propriétés de police pour le titre
et les étiquettes
Vous pouvez définir les propriétés de police (taille, style, poids, etc.) pour le titre,
les étiquettes des axes et d’autres éléments du texte dans votre graphique en
utilisant les paramètres de police de Matplotlib.
Utilisez le paramètre fontdict des fonctions title, xlable et ylabel pour spécifier
les propriétés de police du titre.
Utilisez le paramètre prop de la fonction legend pour spécifier les propriétés de
police de la légende.
La propriété fontfamily : ’sans-serif’, ’serif’, ’Arial’, ’Times New Roman’, ’Courier
New’, etc.
La propriété fontweight dans Matplotlib est utilisée pour spécifier le poids de la
police, c’est-à-dire l’épaisseur des caractères : ’normal’, ’bold’, ’light’, ’heavy’, etc.
vous pouvez spécifier la couleur du texte de la légende en utilisant le paramètre
labelcolor directement dans la fonction legend.

DataFrames
et les étiquettes
3 Age = np.array([22, 25, 30, 35, 40])
4 Salaire = np.array([5000, 7500.25, 8000, 9000.50, 12000])
6 plt.title("La relation entre le salaire et l’age",fontdict={’fontfamily’ : ’serif’
,’fontsize’: 16, ’fontweight’: ’bold’, ’color’: ’red’})
7 plt.xlabel("Age", fontdict={’fontfamily’ : ’serif’ ,’fontsize’: 14, ’fontweight’:
’bold’, ’color’: ’blue’})
8 plt.ylabel("Salaire", fontdict={’fontfamily’ : ’Times New Roman’ ,’fontsize’: 14,
’fontweight’: ’bold’, ’color’: ’green’})
9 plt.legend(prop={’family’ : ’Arial’ ,’size’: 14, ’weight’: ’light’}, labelcolor
=’purple’)
10 plt.show()

DataFrames
et les étiquettes

DataFrames
Diagrammes en ligne ou en courbes : positionner le titre
Pour positionner le titre de manière plus précise, vous pouvez utiliser loc et pad
directement dans la fonction title.
Le paramètre pad dans la fonction title est utilisé pour spécifier l’espacement
(padding) entre le titre et le reste du graphique. Il contrôle la distance entre le
titre et les axes du graphique.
Le paramètre pad accepte une valeur numérique qui détermine la distance en
points (1 point = 1/72 pouce) entre le titre et le reste du graphique.
Pour le titre (fonction title) les valeurs possible pour le paramètre loc sont :
’center’, ’left’, ’right’.

DataFrames
Diagrammes en ligne ou en courbes : positionner le titre
3 Age = np.array([22, 25, 30, 35, 40])
4 Salaire = np.array([5000, 7500.25, 8000,
9000.50, 12000])
et l’age", loc=’left’, pad=20)
7 plt.xlabel("Age")
9 plt.legend()
10 plt.show()

DataFrames
Diagrammes en ligne ou en courbes : positionner les étiquettes
Pour les étiquettes des axes dans Matplotlib, nous pouvons utiliser le paramètre
loc avec les valeurs suivantes :
Pour l’axe des x : ’left’, ’center’, ’right’
Pour l’axe des y : ’bottom’, ’center’, ’top’
vous pouvez utiliser le paramètre labelpad pour ajuster l’espacement entre les
étiquettes et les axes.
3 Age = np.array([22, 25, 30, 35, 40])
4 Salaire = np.array([5000, 7500.25, 8000,
9000.50, 12000])
et l’age", loc=’center’)
7 plt.xlabel("Age", loc=’right’,
labelpad=15)
8 plt.ylabel("Salaire", loc=’top’,
labelpad=15)
9 plt.legend()
10 plt.show()

DataFrames
Diagrammes en ligne ou en courbes : positionner la légende
Pour positionner la légende dans Matplotlib, vous pouvez utiliser le paramètre loc
dans la fonction legend.
Le paramètre loc accepte les valeurs suivantes : ’upper right’, ’upper left’,
’lower left’, ’lower right’, ’right’, ’center left’, ’center right’, ’lower center’,
’upper center’, ’center’.
loc = ’best’ : détermine automatiquement le meilleur endroit pour afficher la
légende.
borderpad = 1.5 : l’espacement relatif autour des labels (1 est le défaut).
fancybox = True : arrondit les bords de l’encadré de la légende.
facecolor = ’#F59D8B’ : la couleur de fond de la légende.
edgecolor = ’black’ : la couleur de l’encadré de la légende.

DataFrames
Diagrammes en ligne ou en courbes : positionner la légende
2 Age = np.array([22, 25, 30, 35, 40])
3 Salaire = np.array([5000, 7500.25, 8000,
9000.50, 12000])
et l’age")
6 plt.xlabel("Age")
8 plt.legend(loc= ’lower right’, labelcolor
= ’green’, borderpad = 2, fancybox =
True, facecolor = ’#F59D8B’,
edgecolor = ’black’)
9 plt.show()

DataFrames
Diagrammes en ligne ou en courbes : Ajout de lignes de grille
Pour ajouter des lignes de grille dans un graphique Matplotlib, vous pouvez utiliser
la fonction grid.
3 Age = np.array([22, 25, 30, 35, 40])
4 Salaire = np.array([5000, 7500.25, 8000,
9000.50, 12000])
5 plt.plot(Age, Salaire, ’o--’ ,label =
"Ligne 1")
et l’age")
7 plt.xlabel("Age")
= ’green’, facecolor = ’#F59D8B’,
10 plt.grid()
11 plt.show()

DataFrames
La fonction grid de Matplotlib prend plusieurs paramètres qui vous permettent de
personnaliser l’apparence des lignes de grille.
visible (booléen) : Active ou désactive les lignes de grille. Par exemple,
plt.grid(True) active les lignes de grille.
which (str) : Spécifie quelles lignes de grille doivent être affichées. Les options
courantes incluent :
’major’ : Lignes de grille majeures (par défaut).
’minor’ : Lignes de grille mineures.
’both’ : À la fois majeures et mineures.
axis (str) : Spécifie l’axe sur lequel afficher les lignes de grille. Les options
courantes incluent :
’both’ : À la fois sur l’axe des x et l’axe des y (par défaut).
’x’ : Uniquement sur l’axe des x.
’y’ : Uniquement sur l’axe des y.
color : Spécifie la couleur des lignes de grille. Vous pouvez utiliser des noms de
couleur (par exemple, ’red’, ’blue’) ou des codes hexadécimaux (par exemple,
’#FF0000’).
linestyle : Spécifie le style de ligne des lignes de grille.
linewidth : Spécifie la largeur de ligne des lignes de grille.

DataFrames
3 Age = np.array([22, 25, 30, 35, 40])
4 Salaire = np.array([5000, 7500.25, 8000,
9000.50, 12000])
5 plt.plot(Age, Salaire, ’o--’ ,label =
"Ligne 1")
et l’age")
7 plt.xlabel("Age")
= ’green’, facecolor = ’#F59D8B’,
10 plt.grid(visible=True,
axis=’x’,color=’red’, linestyle=’:’,
linewidth=2)
11 plt.show()

DataFrames
Diagrammes en ligne ou en courbes : Les marqueurs sur les axes
xtick : Les marqueurs sur l’axe horizontal (axe des x).
ytick : Les marqueurs sur l’axe vertical (axe des y).
Les termes xtick et ytick se réfèrent aux marqueurs (ou graduations) sur les axes
x et y, respectivement, dans un graphique. Ces marqueurs représentent les
positions le long de chaque axe où des étiquettes ou des lignes de grille peuvent
être placées.
Matplotlib offre des fonctions pour personnaliser les marqueurs et les étiquettes
sur les axes. Par exemple, plt.xticks()et plt.yticks() sont des fonctions qui vous
permettent de définir les positions et les étiquettes des marqueurs sur les axes x
et y, respectivement.

DataFrames
3 x = np.linspace(0, 2 * np.pi, 100)
4 y = np.sin(x)
5 plt.plot(x, y)
6 # Personnalisation des marqueurs et des é
tiquettes sur l’axe des x
7 plt.xticks([0, np.pi, 2 * np.pi], [’0’,
’$pi$’, ’$2pi$’])
8 # Personnalisation des marqueurs et des é
tiquettes sur l’axe des y
9 plt.yticks([-1, 0, 1], [’-1’, ’0’, ’1’])
10 plt.show()

DataFrames
Sous-graphiques (subplots)
Les sous-graphiques (subplots) dans Matplotlib sont utilisés pour créer plusieurs
graphiques dans une figure. Cela vous permet de diviser votre fenêtre graphique
en une grille et de tracer différentes visualisations dans chaque cellule de la grille.
La fonction subplot dans Matplotlib est utilisée pour créer des tracés multiples (ou
sous-graphiques) dans une seule figure. Elle permet de diviser une figure en une
grille de sous-graphiques et de spécifier où placer chaque sous-graphique.
La syntaxe de base de la fonction subplot est la suivante :
plt.subplot(nrows, ncols, index)
nrows : Nombre de lignes dans la grille.
ncols : Nombre de colonnes dans la grille.
index : Indice du sous-graphique à créer (commençant à 1).
La disposition est organisée en lignes et colonnes, représentées par le premier
et le deuxième argument.
Le troisième argument représente l’index du graphique actuel.
La fonction tight layout est utilisée pour ajuster automatiquement les
espacements entre les sous-graphiques afin de les rendre plus lisibles.

DataFrames
3 x = np.linspace(0, 10, 100)
4 y1 = np.sin(x)
5 y2 = np.cos(x)
6
7 # Créer le premier sous-graphique (1
ligne, 2 colonnes, premier
sous-graphique)
8 plt.subplot(1, 2, 1) #ou plt.subplot(121)
9 plt.plot(x, y1)
10 plt.title(’Sin(x)’)
11 # Créer le deuxième sous-graphique (1
ligne, 2 colonnes, deuxième
sous-graphique)
12 plt.subplot(1, 2, 2) #ou plt.subplot(122)
13 plt.plot(x, y2)
14 plt.title(’Cos(x)’)
15 # Ajuster automatiquement les espacements
16 plt.tight_layout()
17
18 # Afficher la figure
19 plt.show()

DataFrames
si nous voulons une figure avec 2 lignes et 1 colonne (ce qui signifie que les
deux graphiques seront affichés l’un au-dessus de l’autre au lieu d’être côte à
côte), nous pouvons écrire la syntaxe comme ceci :
3 x = np.linspace(0, 10, 100)
4 y1 = np.sin(x)
5 y2 = np.cos(x)
6 # Créer le premier sous-graphique (1
ligne, 2 colonnes, premier
sous-graphique)
7 plt.subplot(2, 1, 1)
8 plt.plot(x, y1)
10 # Créer le deuxième sous-graphique (1
ligne, 2 colonnes, deuxième
sous-graphique)
12 plt.plot(x, y2)
14 # Ajuster automatiquement les espacements
17 plt.show()

DataFrames
Vous pouvez dessiner autant de graphiques que vous le souhaitez sur une seule
figure, il suffit de décrire le nombre de lignes, de colonnes et l’index du graphique.
3 x = np.array([0, 1, 2, 3])
4 y = np.array([3, 8, 1, 10])
6 plt.plot(x,y)
7 x = np.array([0, 1, 2, 3])
8 y = np.array([10, 20, 30, 40])
10 plt.plot(x,y)
11 x = np.array([0, 1, 2, 3])
12 y = np.array([3, 8, 1, 10])
14 plt.plot(x,y)
15 x = np.array([0, 1, 2, 3])
16 y = np.array([10, 20, 30, 40])
18 plt.plot(x,y)
20 plt.show()

DataFrames
Vous pouvez ajouter un titre à l’ensemble de la figure en utilisant la fonction
suptitle() dans Matplotlib.
Cela est particulièrement utile lorsque vous avez plusieurs sous-graphiques dans
une figure et que vous souhaitez ajouter un titre global à l’ensemble de la
visualisation.
1 x = np.linspace(0, 10, 100)
2 y1 = np.sin(x)
3 y2 = np.cos(x)
4
6 plt.plot(x, y1)
8
10 plt.plot(x, y2)
12
13 plt.suptitle(’Fonctions : sin(x) et
cos(x)’)
16 plt.show()

DataFrames
Création de nuages de points(Scatter)
Pour créer un nuage de points (scatter plot) dans Matplotlib, vous pouvez utiliser
la fonction scatter().
Un nuage de points est un type de graphique qui affiche des points individuels sur
un plan, avec une coordonnée pour chaque variable.
La fonction scatter() trace un point pour chaque observation. Elle a besoin de
deux tableaux de même longueur, l’un pour les valeurs de l’axe des x et l’autre
pour les valeurs sur l’axe des y.
3 x = np.random.rand(50)
4 y = np.random.rand(50)
5 # Créer un nuage de points
6 plt.scatter(x, y, label="Points")
7 plt.show()

DataFrames
Création de nuages de points(Scatter) : Deux graphiques
Les deux graphiques sont tracés avec deux couleurs différentes, par défaut bleu
et orange.
2 import pandas as pd
3 df=pd.read_csv(’Clients.csv’)
4 X = df[’Age’]
5 Y = df[’Salaire’]
6 Z = df[’Poids’]
8 plt.scatter(X, Y, label="Age/Salaire")
9 plt.scatter(Z, Y, label="Poids/Salaire")
10 plt.legend()
11 plt.show()

DataFrames
Vous pouvez définir votre propre couleur pour chaque graphique avec l’argument
color ou c :
3 df=pd.read_csv(’Clients.csv’)
4 X = df[’Age’]
6 Z = df[’Poids’]
8 plt.scatter(X, Y, color=’red’,
label="Age/Salaire")
9 plt.scatter(Z, Y, c=’#00FF00’,
label="Poids/Salaire")
10 plt.legend()
11 plt.show()

DataFrames
Colorer chaque point : Vous pouvez même définir une couleur spécifique pour
chaque point en utilisant un tableau de couleurs comme valeur pour l’argument c.
3 x = np.array([5,7,8,7,2,17,2,9,4,11,12,
4 9,6])
5 y =
np.array([99,86,87,88,111,86,103,87,94,
6 78,77,85,86])
7 colors =
np.array(["red","green","blue","yellow"
8 ,"pink","black","orange","purple","beige","brown",
9 "gray","cyan","magenta"])
10 plt.scatter(x, y, color=colors)
11 plt.show()

DataFrames
La colormap (ou carte de couleurs) est une manière de représenter des
informations supplémentaires dans un nuage de points en associant une couleur
à une valeur spécifique.
Une colormap est comme une liste de couleurs, où chaque couleur a une valeur
qui va de 0 à 100.
Vous pouvez spécifier la colormap avec l’argument de mot-clé cmap avec la
valeur de la colormap. Dans l’exemple ci-dessous nous avons utilisé ’viridis’ qui
est l’une des colormaps intégrées disponibles dans Matplotlib.
De plus, vous devez créer un tableau avec des valeurs (de 0 à 100), une valeur
pour chaque point dans le graphique de nuage de points.
Vous pouvez inclure la colormap dans le dessin en incluant l’instruction
plt.colorbar().
3 x = np.array([5,7,8,7,2,17,2,9,4,11,12,9,6])
4 y = np.array([99,86,87,88,111,86,103,87,94,78,77,85,86])
5 colors = np.array([0, 10, 20, 30, 40, 45, 50, 55, 60, 70, 80, 90, 100])
6 plt.scatter(x, y, c=colors, cmap=’viridis’)
7 plt.colorbar()
8 plt.show()

DataFrames

DataFrames
Matplotlib propose plusieurs colormaps prédéfinies, telles que ’viridis’, ’plasma’,
’inferno’, ’magma’, ’cividis’, ’coolwarm’, ’jet’, etc. Vous pouvez choisir une
colormap en fonction de vos préférences visuelles et de la signification de vos
données.
3 x =
np.array([5,7,8,7,2,17,2,9,4,11,12,9,6])
4 y =
np.array([99,86,87,88,111,86,103,87,94,78,77,85,86])
5 colors = np.array([0, 10, 20, 30, 40, 45,
50, 55, 60, 70, 80, 90, 100])
6 plt.scatter(x, y, c=colors,
cmap=’inferno’)
7 plt.colorbar()
8 plt.show()

DataFrames
Création de nuages de points(Scatter) : Taille
Dans un nuage de points (scatter plot) avec Matplotlib, l’argument s est utilisé
pour spécifier la taille des marqueurs.
Vous pouvez utiliser cet argument pour contrôler la taille relative des points dans
le nuage.
Tout comme pour les couleurs, assurez-vous que le tableau des tailles a la même
longueur que les tableaux des axes x et y.
Vous pouvez spécifier la même taille pour tous les points en passant un scalaire à
l’argument s (size) dans la fonction scatter. Si vous utilisez un nombre (scalaire)
comme valeur pour s, tous les points auront la même taille.
4 df=pd.read_csv(’Clients2.csv’)
5 X = df[’Age’]
7 sizes = np.array([20,50,100,200,500,400,60,90,10,300,600,800])
8 plt.scatter(X, Y, color=’red’, s=sizes)
9 plt.show()

DataFrames
Création de nuages de points(Scatter) : Taille

DataFrames
Création de nuages de points(Scatter) : Paramètre Alpha
Vous pouvez ajuster la transparence des points avec l’argument alpha.
L’argument alpha prend des valeurs dans l’intervalle [0, 1], où 0 signifie
complètement transparent et 1 signifie complètement opaque.
5 X = df[’Age’]
7 # Les points sont semi-transparents
(alpha=0.5)
8 plt.scatter(X, Y, s=200, alpha=0.5)
9 plt.show()

DataFrames
Création de nuages de points(Scatter) : Combiner couleur, taille et alpha
Vous pouvez combiner une colormap avec différentes tailles de points. Cela est
mieux visualisé si les points sont transparents.
chaque point du nuage a une couleur, une taille de marqueur et une transparence
spécifiques, créant ainsi une visualisation plus riche et complexe.
5 X = df[’Age’]
7 colors = np.random.randint(100, size=(12))
8 sizes = 10 * np.random.randint(100,
size=(12))
9 plt.scatter(X, Y, c=colors, s=sizes,
alpha=0.5, cmap=’nipy_spectral’)
10 plt.colorbar()
11 plt.show()

DataFrames
diagrammes en barres
Matplotlib permet de créer facilement des diagrammes en barres à l’aide de la
fonction bar ou barh pour les diagrammes en barres horizontaux.
La fonction bar() prend des arguments qui décrivent la disposition des barres.
Les catégories et leurs valeurs sont représentées par le premier et le deuxième
argument sous forme de tableaux.
3
4 Module = np.array(["Algèbre", "Python",
"Machine Learning", "Statistique"])
5 Note = np.array([13, 18, 11.5, 16.75])
6
7 plt.bar(Module,Note)
8 plt.show()

DataFrames
Barres horizontales : Si vous voulez que les barres soient affichées
horizontalement plutôt que verticalement, utilisez la fonction barh().
3
5 Note = np.array([13, 18, 11.5, 16.75])
6
7 plt.barh(Module,Note)
8 plt.show()

DataFrames
Les fonctions bar() et barh() prennent l’argument color pour définir la couleur des
barres.
La fonction bar() prend l’argument width pour définir la largeur des barres.
Pour des barres horizontales, utilisez height au lieu de width.
La fonction barh() prend l’argument height pour définir la hauteur des barres.
La valeur par défaut des arguments width et height est : 0.8
3
5 Note = np.array([13, 18, 11.5, 16.75])
6
7 plt.bar(Module, Note, color= ’#854002’,
width=0.1)
8 plt.show()

DataFrames
Des arguments que vous pouvez utiliser avec la fonction bar() :
bottom (scalar or array-like, optional) : La position basse des barres. La valeur
par défaut est None.
edgecolor : La couleur du bord des barres. La valeur par défaut est None.
linewidth : L’épaisseur du bord des barres. La valeur par défaut est None.
3
5 Note = np.array([13, 18, 11.5, 16.75])
6 Note_TP = np.array([11, 12, 10, 13])
7
8 plt.bar(Module, Note, color= ’green’,
linewidth=3, edgecolor=’black’,
label=’Note’)
9 plt.bar(Module, Note_TP, color= ’blue’,
linewidth=3, edgecolor=’red’,
label=’Note_TP’, bottom=Note)
10 plt.legend()
11 plt.show()
bottom=Note spécifie que les barres de Note TP seront empilées sur les barres

DataFrames
Pour créer un diagramme en barres avec une couleur spécifique pour chaque
barre, vous pouvez utiliser le paramètre color avec une liste de couleurs.
Pour ajouter une légende en dehors du tracé, vous pouvez utiliser la fonction
legend avec le paramètre bbox to anchor pour spécifier la position de la légende
par rapport à la figure.
bbox to anchor=(1.05, 1) spécifie la position de la légende en dehors du tracé.
Les valeurs (1.05, 1) signifient que la légende sera positionnée à 5% à droite et
100% vers le haut par rapport à la largeur et la hauteur de la figure.
3 Note = np.array([13, 18, 11.5, 16.75])
4 c=[’red’, ’blue’, ’yellow’, ’black’]
5 plt.bar(Module, Note, color= c,
label=["Algèbre", "Python", "Machine
Learning", "Statistique"])
6 plt.title(’Diagramme en Barres avec
Couleur pour Chaque Barre’)
7 plt.xlabel(’Modules’)
8 plt.ylabel(’Notes’)
9 plt.legend(bbox_to_anchor=(1.05, 1))
10 plt.show()

DataFrames
diagrammes en barres : ajouter les valeurs numériques au-dessus de chaque
barre
vous pouvez utiliser la fonction text() de Matplotlib pour placer le texte à la
position souhaitée.
La fonction text() de Matplotlib est utilisée pour ajouter du texte à une figure.
Elle prend en charge le placement de texte à des positions spécifiques dans la
figure, ce qui est utile pour annoter des graphiques ou des diagrammes.
3 Module = np.array(["Algèbre", "Python", "Machine Learning", "Statistique"])
4 Note = np.array([13, 18, 11.5, 16.75])
5 c=[’red’, ’blue’, ’yellow’, ’black’]
6 plt.bar(Module, Note, color= c, label=["Algèbre", "Python", "Machine Learning",
"Statistique"])
7 # Ajouter les valeurs numériques au-dessus de chaque barre
8 for i, v in enumerate(Note):
9 plt.text(i, v + 0.2, str(v), ha=’center’)
10 plt.title(’Diagramme en Barres avec Couleur pour Chaque Barre’)
11 plt.xlabel(’Modules’)
12 plt.ylabel(’Notes’)
13 plt.legend(bbox_to_anchor=(1.05, 1))
14 plt.show()

DataFrames
barre
for i, v in enumerate(Note) : : Cette ligne utilise enumerate pour obtenir à la fois
l’index (i) et la valeur (v) de chaque élément dans la liste Notes.
plt.text(i, v + 0.1, str(v), ha=’center’) : Cette ligne utilise la fonction text() de
Matplotlib pour ajouter du texte à la figure. Les paramètres sont les suivants :
i : L’index de l’élément dans la liste Notes, utilisé comme position horizontale pour
le texte. v + 0.2 : La valeur de l’élément dans la liste Notes augmentée de 0.2,
utilisée comme position verticale pour le texte. Cela garantit que le texte est
légèrement au-dessus de la barre correspondante.
str(v) : La valeur elle-même, convertie en chaı̂ne de caractères pour être affichée
comme texte.
ha=’center’ : Alignement horizontal du texte centré par rapport à la position
spécifiée.

DataFrames
barre

DataFrames
Histogrammes
Un histogramme est une représentation graphique de la distribution des données.
Il permet de visualiser la fréquence des occurrences de différentes valeurs dans
un ensemble de données.
L’axe horizontal de l’histogramme représente les différentes catégories ou plages
de valeurs, et l’axe vertical représente le nombre d’occurrences (fréquence) dans
chaque catégorie.
Voici comment fonctionne la création d’un histogramme :
• Les données sont divisées en intervalles appelés ”bacs” ou ”bins”. Ces bacs couvrent la
plage des valeurs des données et sont généralement de largeur égale.
• Le nombre d’occurrences (fréquence) de données dans chaque bac est compté.
• Des barres rectangulaires sont tracées pour représenter visuellement la fréquence des
données dans chaque bac. La hauteur de chaque barre est proportionnelle au nombre
d’occurrences dans le bac.
Les histogrammes sont largement utilisés dans la statistique descriptive pour
explorer la distribution des données, identifier les tendances, les modes, les
valeurs aberrantes, etc.
Ils sont également utiles pour comprendre la forme de la distribution, qu’il s’agisse
d’une distribution normale, asymétrique, bimodale, etc.

DataFrames
Histogrammes
En Matplotlib, nous utilisons la fonction hist() pour créer des histogrammes.
La fonction hist() utilisera un tableau de nombres pour créer un histogramme, le
tableau est envoyé à la fonction en tant qu’argument.
3 #Une distribution normale des données
4 #Nous utilisons NumPy pour générer de
manière aléatoire un tableau avec
250 valeurs,
5 # où les valeurs se concentreront autour
de 170, et l’écart type est de 10.
6 x = np.random.normal(170, 10, 250)
7 plt.hist(x)
8 plt.show()

DataFrames
Histogrammes
La fonction hist() de Matplotlib accepte plusieurs arguments qui permettent de
personnaliser l’aspect de l’histogramme.
x : Les données que vous souhaitez représenter dans l’histogramme.
bins : Le nombre de bacs (intervalles) dans lesquels les données seront regroupées.
range : La plage des valeurs à considérer dans l’histogramme.
density : Si True, l’histogramme représente une densité de probabilité (l’intégrale de
l’histogramme est égale à 1).
color : La couleur de remplissage des barres de l’histogramme.
edgecolor : La couleur des bords des barres de l’histogramme.
alpha : La transparence des barres de l’histogramme (entre 0 et 1).
label : Une étiquette pour l’histogramme, utile pour la création d’une légende.
cumulative : Si True, l’histogramme représente une distribution cumulative.
orientation : L’orientation de l’histogramme, ’horizontal’ ou ’vertical’.
8

DataFrames
Histogrammes
3 x = np.random.normal(170, 10, 250)
4 plt.hist(x, bins=6, density=True,
color=’green’, edgecolor=’black’,
alpha=0.4, label=’Distribution
Normale’)
5 plt.legend()
6 plt.show()

DataFrames
Diagrammes circulaires : Pie Charts
Les diagrammes circulaires, aussi appelés diagrammes en secteurs ou
camemberts, sont des représentations graphiques qui affichent la répartition des
valeurs dans un ensemble de données sous forme de portions d’un cercle.
Chaque portion, ou secteur, du cercle représente une catégorie ou une classe de
données, et la taille de chaque secteur est proportionnelle à la valeur qu’il
représente.
Matplotlib offre la fonction pie pour créer des diagrammes circulaires.
3 labels = [’Catégorie 1’, ’Catégorie 2’,
’Catégorie 3’, ’Catégorie 4’]
4 sizes = [25, 30, 20, 25]
5 plt.pie(sizes, labels=labels)
6 plt.show()

DataFrames
Par défaut, le tracé de la première portion commence à l’axe des x( (0 degrés) ) et
se déplace dans le sens contraire des aiguilles d’une montre.
Cela peut être modifié en ajustant le paramètre startangle de la fonction pie. La
valeur par défaut de startangle est 0, mais en changeant cette valeur, vous
pouvez faire tourner le diagramme circulaire. Par exemple, si vous souhaitez que
le premier secteur commence à l’axe des y (90 degrés), vous pouvez définir
startangle=90.
La taille de chaque portion est déterminée en comparant la valeur avec toutes les
autres valeurs, en utilisant la formule suivante : La valeur divisée par la somme de
toutes les valeurs : x/sum(x).

DataFrames
Étiquettes : Ajoutez des étiquettes au diagramme circulaire avec le paramètre
labels.
Ce paramètre prend un tableau d’étiquettes, où chaque élément correspond à une
étiquette pour la portion respective dans le diagramme circulaire.
3 eff_fil = np.array([15, 25, 30, 20])
4 fil = [’MIP’, ’D3SI’, ’SVI’, ’BCG’]
5 plt.pie(eff_fil, startangle=90,
labels=fil)
6 plt.show()

DataFrames
Éclatement : Peut-être que vous voulez mettre en évidence l’une des portions.
Le paramètre explode de la fonction pie permet de mettre en évidence une ou
plusieurs portions du diagramme circulaire en les éloignant du centre.
Chaque valeur dans le tableau explode représente la distance par rapport au
centre du cercle pour la portion correspondante, et ces valeurs sont spécifiées en
pourcentage du rayon du cercle.
3 eff_fil = np.array([15, 25, 30, 20])
5 dist = [0.3, 0, 0, 0.1]
labels=fil, explode=dist)
7 plt.show()

DataFrames
Ombre : Ajoutez une ombre au graphique circulaire en définissant le paramètre
shadow sur True.
vous pouvez définir la couleur de chaque secteur du diagramme circulaire en
utilisant le paramètre colors. Ce paramètre prend un tableau d’éléments, où
chaque élément représente la couleur associée à une portion du diagramme
circulaire.
Légende Pour ajouter une liste d’explications pour chaque secteur, utilisez la
fonction legend().
Pour ajouter un en-tête à la légende, ajoutez le paramètre title à la fonction
legend().

DataFrames
3 eff_fil = np.array([15, 25, 30, 20])
5 dist = [0.3, 0, 0, 0.1]
6 C = [’cyan’, ’yellow’, ’blue’, ’green’]
labels=fil, explode=dist,
shadow=True, colors=C)
8 plt.legend(title=’Filières : ’,
loc=’lower right’)
9 plt.show()

DataFrames
Le paramètre autopct dans la fonction pie de Matplotlib permet d’afficher les
pourcentages associés à chaque portion du diagramme circulaire. Il sert à
annoter chaque secteur avec sa valeur en pourcentage.
Dans l’exemple ci-dessous, autopct=’%1.1f%%’ spécifie le format des
pourcentages à afficher. %1.1f signifie un format avec une décimale, et %% est
utilisé pour afficher le symbole de pourcentage.
3 eff_fil = np.array([15, 25, 30, 20])
labels=fil, autopct=’%1.1f%%’)
loc=’lower right’)
7 plt.show()

DataFrames
Le paramètre wedgeprops dans la fonction pie de Matplotlib est utilisé pour
définir les propriétés du coin (wedge) qui représente chaque portion du
diagramme circulaire. Ce paramètre vous permet de spécifier des propriétés telles
que la couleur du bord, l’épaisseur de la ligne, etc.
3 eff_fil = np.array([15, 25, 30, 20])
5 # Définir les propriétés (wedge)
6 wedgeprops = {’linewidth’: 3,
’edgecolor’: ’black’}
labels=fil, autopct=’%1.1f%%’,
wedgeprops=wedgeprops)
loc=’best’)
9 plt.show()

DataFrames
Diagrammes circulaires : Figure
Dans Matplotlib, une figure est la fenêtre graphique sur laquelle vous pouvez créer
des tracés, des graphiques ou d’autres représentations visuelles des données.
Une figure agit comme un conteneur de niveau supérieur pour les éléments de
tracé, tels que les axes, les étiquettes, les titres, etc.
En d’autres termes, la figure est la toile sur laquelle vous allez dessiner vos
graphiques. Chaque figure peut contenir un ou plusieurs axes (systèmes de
coordonnées), et ces axes sont utilisés pour tracer des données.
Pour créer une figure avec Matplotlib, vous pouvez utiliser la fonction plt.figure().
plt.figure() crée une nouvelle figure vide et renvoie un objet de la classe Figure.
Vous pouvez ensuite ajouter des axes (systèmes de coordonnées) à cette figure
et tracer des graphiques à l’intérieur des axes.
Si vous souhaitez spécifier la taille de la figure, vous pouvez utiliser le paramètre
figsize pour définir les dimensions en pouces.
En général, vous ajouterez ensuite des axes à la figure en utilisant la méthode
add subplot() ou la fonction subplots() pour créer une grille d’axes, puis vous
tracerez des données à l’intérieur de ces axes.

DataFrames
Diagrammes circulaires : Axes
Dans Matplotlib, un axe (ou subplot) est un système de coordonnées à l’intérieur
d’une figure.
Il permet de tracer des graphiques et de positionner des éléments tels que des
lignes, des points, des barres, des histogrammes, etc. Les axes sont les zones
spécifiques où les données sont effectivement tracées.
Une figure peut contenir un ou plusieurs axes. Chaque axe a ses propres échelles
x et y, ses étiquettes, son titre, etc. Les axes permettent d’organiser et de
représenter les données de manière structurée. Vous pouvez créer des
sous-tracés (axes) dans une figure pour afficher plusieurs graphiques sur la
même fenêtre.
Pour définir des axes dans Matplotlib, vous pouvez utiliser la fonction
plt.subplots() ou plt.figure() avec la méthode add subplot()
la classe Axes est la classe qui représente un axe (subplot) au sein d’une figure.
Un objet Axes est une zone rectangulaire dans laquelle les données sont tracées.
Les instances de la classe Axes sont généralement créées à l’intérieur d’une
figure en utilisant des méthodes telles que add subplot() ou subplots().

DataFrames
Diagrammes circulaires : Figure et Axes
Exemple 1 : Utilisation de plt.figure pour tracer trois graphiques
3 x = np.linspace(0, 2*np.pi, 100)
4 y1 = np.sin(x)
5 y2 = np.cos(x)
6 y3 = np.tan(x)
7 fig = plt.figure(figsize=(10, 4))# Créer une figure
8 ax1 = fig.add_subplot(1, 3, 1)# Tracer le premier graphique
9 ax1.plot(x, y1, label=’sin(x)’)
10 ax1.set_title(’Graphique 1’)
11 ax1.legend()
12 ax2 = fig.add_subplot(1, 3, 2)# Tracer le deuxième graphique
13 ax2.plot(x, y2, label=’cos(x)’, color=’orange’)
15 ax2.legend()
16 ax3 = fig.add_subplot(1, 3, 3)# Tracer le troisième graphique
17 ax3.plot(x, y3, label=’tan(x)’, color=’green’)
19 ax3.legend()
20 fig.tight_layout()
22 plt.show()

DataFrames
Exemple 1 : Utilisation de plt.figure pour tracer trois graphiques

DataFrames
Exemple 2 : Utilisation de plt.subplots pour tracer trois graphiques avec des axes
3 x = np.linspace(0, 2*np.pi, 100)
4 y1 = np.sin(x)
5 y2 = np.cos(x)
6 y3 = np.tan(x)
7 # Créer une figure avec trois axes
8 fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(12, 4))
9 ax1.plot(x, y1, label=’sin(x)’)# Tracer le premier graphique
11 ax1.legend()
12 ax2.plot(x, y2, label=’cos(x)’, color=’orange’)# Tracer le deuxième graphique
14 ax2.legend()
15 ax3.plot(x, y3, label=’tan(x)’, color=’green’)# Tracer le troisième graphique
17 ax3.legend()
18 # Ajouter un titre à la figure
19 plt.suptitle(’Tracé de trois graphiques’)
20 # Ajuster l’espace entre les graphiques
23 plt.show()

DataFrames
Exemple 2 : Utilisation de plt.subplots pour tracer trois graphiques avec des axes

Cours_D3SI_S5_Python for DS_MatPlotLib.pdf

More Related Content

What's hot

Similar to Cours_D3SI_S5_Python for DS_MatPlotLib.pdf

Cours_D3SI_S5_Python for DS_MatPlotLib.pdf