Tutoriel Python : réaliser des tracés avec matplotlib

Table des matières

Introduction :

Afin de réaliser des calculs numériques complexes et les représenter sous de différentes représentations visuelles, Python contient les modules matplotlib et numpy qui représentent un ensemble de fonctions réalisant des tracés, ainsi que des options de personnalisation liées à ces derniers.

On introduira dans ce tutoriel le procédé d’utilisation du module matplotlib et ses fonctions permettant de réaliser de différents tracés.

Initiation à matplotlib :

Etant une bibliothèque massive de fonctions, il est indispensable d’importer les modules et les fonctions de matplotlib pour l’utiliser, et pour ce faire, il suffit d’écrire l’instruction suivante :

# on importe les modules numpy et matplotlib :
import numpy as np
import matplotlib.pyplot as plt
# les abréviations 'np' et 'plt' servent à appeler les modules sous un nom plus court.

Ainsi, si vous êtes familiarisés avec la syntaxe du langage Matlab, Python vous propose le module pylab, ayant comme syntaxe :

from pylab import *

Création et affichage d’un tracé :

Pour créer un tracé en utilisant la bibliothèque matplotlib sur Python, on utilise la fonction plot() en y intégrant comme arguments les listes des abscisses et des ordonnées de votre tracé tel que plt.plot(, ).

Pour afficher le résultat du tracé créé, on utilise la fonction show(), qui permet réaliser le tracé des instructions qui le précèdent.

Exemple :

Syntaxe :

import numpy as np
import matplotlib.pyplot as plt
plt.plot([5, 6, 9, 3, 4],[7, 9, 8, 2, 1])
plt.show()

Résultat d’exécution :

Tracé d’une fonction :

Comme il est mentionné dans la partie précédente, le concept de créer un tracé sur Python se présente sous la forme de plusieurs points reliés entre eux.

Alors, pour pouvoir appliquer ce concept sur des fonctions, on appelle la fonction linspace() qui sert à définir l’intervalle des valeurs des abscisses qu’on veut afficher, ainsi que le nombre de points créés. Sa syntaxe s’écrit sous la forme np.linspace(, , ).

Exemple :

Syntaxe :

import numpy as np
import matplotlib.pyplot as plt
# on crée 5 points :
x = np.linspace(-1, 10, 5)
y = x**3 + 2*x**2 -300
plt.plot(x,y)
plt.show()
# on crée 100 points :
x = np.linspace(-1, 10, 100)
y = x**3 + 2*x**2 -300
plt.plot(x,y)
plt.show()

Résultat d’exécution :

Exercice d’application :

Créez un tracé simple de la fonction cos(4x) + sin(5x+2) avec x appartient à l’intervalle [1, 3].

Solution :

Syntaxe :

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(1, 3, 50)
y = np.cos(4*x) + np.sin(5*x + 2)
plt.plot(x,y)
plt.show()

Résultat d’exécution :

Tracés de plusieurs fonctions :

Pour représenter plusieurs fonctions sur le même graphe, il suffit de réutiliser la fonction plot pour créer plusieurs tracés, et par la suite les afficher après leurs définition avec la fonction show().

Exemple :

Syntaxe :

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(10, 20, 2)
y1 = x + 10
y2 = 4*x
plt.plot(x, y1)
plt.plot(x, y2)
plt.show()

Résultat d’exécution :

Personnalisation de l’interface du tracé :

Définir un titre :

On utilise la fonction title() pour définir un titre au tracé tel que plt.title().

Exemple :

Syntaxe :

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(1, 5, 50)
y = np.exp(x)
plt.title("la fonction exponentielle")
plt.plot(x,y)
plt.show()

Résultat d’exécution :

Définir une légende :

Afin d’ajouter une légende de tracé, on peut d’une part définir son nom comme argument de la fonction plot() tel que plt.plot(, , label = ), ainsi, on utilise la fonction legend() pour l’afficher tel que plt.legend().

D’une autre part, on peut utiliser directement la fonction legend() pour définir un caractère comme légende illustrant le tracé tel que plt.legend().

Exemple 1 :

Syntaxe :

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(1, 5, 50)
y = np.exp(x)
plt.plot(x,y, label = 'fct exponentielle')
plt.legend()
plt.show()

Résultat d’exécution :

Exemple 2 :

Syntaxe :

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(1, 5, 50)
y = np.exp(x)
plt.plot(x,y)
plt.legend("a")
plt.show()

Résultat d’exécution :

Définir un sous-titre des axes :

On utilise la fonction xlabel() pour définir un sous-titre d’axe des abscisses et la fonction ylabel() pour définir un sous-titre d’axe des ordonnées, tout en introduisant le sous-titre souhaité comme argument de la fonction.

Exemple :

Syntaxe :

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(10, 20, 10)
y = x**2
plt.plot(x,y)
plt.xlabel("axe des abscisses")
plt.ylabel("axe des ordonnées")
plt.show()

Résultat d’exécution :

Limiter les bornes des axes :

Afin de définir un intervalle des axes sur lequel on souhaite afficher le tracé, on utilise la fonction xlim() pour définir l’intervalle d’axe des abscisses tel que plt.xlim(, ) et ylim() pour définir l’intervalle d’axe des ordonnées tel que plt.ylim(, ).

Exemple :

Syntaxe :

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(10, 20, 2)
y = 30*x
plt.plot(x,y)
plt.xlim(13,15)
plt.ylim(400,480)
plt.show()

Résultat d’exécution :

Affichage de la grille :

Pour afficher une grille servant comme référence pour simplifier la visualisation du résultat, on utilise la fonction grid() tel que plt.grid().

Exemple :

Syntaxe :

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(10, 20, 2)
y = 5*x + 6
plt.plot(x,y)
plt.grid()
plt.show()

Résultat d’exécution :

Résumé des options de personnalisation de l’interface de la courbe :

On résume dans l’exemple suivant les notions introduit dans cette partie :

Syntaxe :

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(10, 20, 2)
y = 5*x + 6
# Insérer une légende :
plt.plot(x, y, label = "Légende de la courbe")
plt.legend()
# limiter les bornes d'affichage selon les axes :
plt.xlim(13, 18)
plt.ylim(70, 100)
# Insérer des sous-titres aux axes :
plt.xlabel("axe des abscisses")
plt.ylabel("axe des ordonnées")
# Insérer un titre :
plt.title("Titre")
# Afficher la grille :
plt.grid()
# Afficher la courbe :
plt.show()

Résultat d’exécution :

Personnalisation du tracé :

Définir la couleur du tracé :

On peut changer la couleur d’une courbe en intégrant comme argument à la fonction plot() un des caractères suivants : « r » pour la couleur rouge, « y » pour la couleur jaune, « k » pour la couleur noire, « g » pour la couleur verte, « w » pour la couleur blanche, « b » pour la couleur bleu, « m » pour la couleur magenta, « c » pour la couleur cyan.

Exemple :

Syntaxe :

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(10, 20, 2)
y1 = 2*x + 10
y2 = 3*x
plt.plot(x, y1, 'y')
plt.plot(x, y2, 'r')
plt.show()

Résultat d’exécution :

Définir le style des points du tracé :

Pour définir le style des points du tracé, on intègre comme argument à la fonction plot() un des caractères suivants : « . », « , », « o », « v », «

Exemple :

Syntaxe :

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(-5, 5, 100)
y1 = np.cos(x)
y2 = np.sin(x)
plt.plot(x, y1, "x")
plt.plot(x, y2, '.')
plt.show()

Résultat d’exécution :

Définir la largeur de ligne du tracé :

On peut définir la largeur d’une ligne afin d’améliorer sa visibilité en insérant comme argument à la fonction plot() l’option linewidth en lui attribuant la valeur souhaitée de la largeur de la courbe en pixels.

Exemple :

Syntaxe :

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(-5, 5, 100)
y1 = np.cos(x)
y2 = np.sin(x)
plt.plot(x, y1, linewidth = 10)
plt.plot(x, y2, linewidth = 2)
plt.show()

Résultat d’exécution :

Ajouter des textes au tracé :

Afin de bien présenter ou expliquer une courbe, une partie d’une courbe ou un point de la courbe, il est possible d’ajouter des textes sur le tracé en utilisant la fonction text() tel que plt.text(, , ).

Exemple :

Syntaxe :

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(-2, 7, 100)
y1 = 2*np.cos(x)
y2 = np.sin(x)
plt.plot(x, y1)
plt.plot(x, y2)
plt.text(0, 2, "le maximum de la fonction 2cos(x)")
plt.text(2, 1, "le maximum de la fonction sin(x)")
plt.show()

Résultat d’exécution :

Exercices d’application :

Exercice 1 :

On souhaite comparer les gains de deux magasins durant 10 ans en les illustrant sous forme d’une courbe. En ayant les données en ordre de chaque année depuis 2010 à 2020, tracez en utilisant matplotlib sur Python les gains de chaque magasin sur le même graphe.

Les gains du magasin 1 : 70719, 43747, 56860, 66905, 50591, 67210, 47882, 76576, 56627, 79337.

Les gains du magasin 2 : 73589, 72720, 90760, 89543, 89477, 92325, 80173, 75448, 69521, 86187.

Solution de l’exercice 1 :

Syntaxe :

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(2010, 2020, 10)
m1 = [70719, 43747, 56860, 66905, 50591, 67210, 47882, 76576, 56627, 79337]
m2 = [73589, 72720, 90760, 89543, 89477, 92325, 80173, 75448, 69521, 86187]
# Création des courbes des gains des deux magasins :
plt.plot(x, m1, label = "les gains du magasin 1")
plt.plot(x, m2, label = "les gains du magasin 1")
plt.legend()
# Ajout des sous-titres représentant les axes :
plt.xlabel("Les années")
plt.ylabel("Les gains")
# Ajout d'un titre :
plt.title("La comparaison des gains entre le magasin 1 et le magasin 2")
# Affichage des courbes :
plt.show()

Résultat d’exécution :

Exercice 2 :

On souhaite représenter les trois fonctions suivantes en définissant x sur un intervalle de [0, 10] :

f(x) = 3x + 5cos(3x)
g(x) = tan (x + 2)
z(x) = e^3x+3

Solution de l’exercice 2 :

Syntaxe :

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(0, 10, 500)
# Création du tracé de la fonction f(x) :
f = 3*x + 5*np.cos(3*x)
plt.plot(x, f, label = "f(x)")
plt.legend()
plt.title("la fonction f(x)")
plt.show()
# Création du tracé de la fonction g(x) :
g = np.tan(x + 2)
plt.plot(x, g, label = "g(x)")
plt.legend()
plt.title("la fonction g(x)")
plt.show()
# Création du tracé de la fonction z(x) :
z = np.exp(3*x + 3)
plt.plot(x, z, label = "z(x)")
plt.legend()
plt.title("la fonction z(x)")
plt.show()

Résultat d’exécution :

Conclusion :

Afin de réaliser des calculs scientifiques et statistiques complexes et les représenter visuellement sous forme de diagrammes et graphes, il est recommandé de travailler les fonctions de la bibliothèque matplotlib et numpy sur Python.

Etant une bibliothèque immense de plus de 70000 lignes de code, on vous a présenter sur ce tutoriel juste les bases de la création d’un tracé.

Merci pour votre attention !

Article publié le 18 Octobre 2020par Ismail BOUZIANE