Le module matplotlib

Matplotlib est une bibliothèque du langage de programmation Python destinée à tracer et visualiser des données sous formes de graphiques. 

Cette page "Découverte de Matplotlib" n'est pas un document exaustif montrant toutes les possibilités de la bibliothèque, mais permet à travers diverses expériences de découvrir rapidement et de manière intéractive les principes de base de la manipulation d'objet dans une fenêtre pyplot.

La console intéractive de Python est IPython, disponible dans le répertoire d'EduPython après son installation.

Tout en lisant les exemples ci-dessous, expérimentez les différents programmes dans IPython afin de vous faire une idée des possibilités graphiques de matplotlib.

Sommaire :

Importation du module matplotlib et utilisation de la fonction plot

Dessin de formes géométriques et configuration des axes

Utilisation de la fonction pyplot.Polygon pour tracer un polygone

Comment modifier les paramètres d'une forme géométrique une fois qu'elle est tracée dans la fenêtre pyplot ?

Affichage d'une image dans une fenêtre Pyplot

Comment sauvegarder les figures dans une image ?

Le mode pylab

Remarques concernant les différents types de fenêtres graphiques

Retour en haut de la page

Importation du module matplotlib et utilisation de la fonction plot

Pour obtenir une fenêtre graphique intéractive sous IPython il faut lancer les 2 lignes suivantes dans la console IPython :

import matplotlib.pyplot as plt
plt.ion()

Ou bien en une seule ligne :

import matplotlib.pyplot as plt;plt.ion()

Dans IPython la commande Ctrl-R permet de retrouver facilement une ligne dans l'historique : Ctrl-R + impo pour retrouver la ligne import matplotlib.pyplot as plt;plt.ion()

Remarque : plt.ion() active le mode intéractif. Le mode intéractif fonctionne très bien dans IPython, mais pas avec la console de base d'EduPython : la fenêtre graphique est morte (comme pour la tortue) avec la console de base d'EduPython ! D'où l'intérêt d'utiliser la console intéractive IPython (IPython signifie Intéractive Python).

Ensuite les instructions tapées dans IPython feront évoluer la fenêtre graphique.

Exemple à tester ligne à ligne dans la console IPython tout en observant la fenêtre graphique :

plt.text(0.5,0.5,'Bonjour !')
plt.title('Test de matplotlib')
y=[0.4,0.8,0.2,0.6]
x=[0,0.2,0.6,1]
plt.plot(x,y)

Voici le résultat final (dans une fenêtre graphique de type tk) :

Effaçons tout le contenu de la fenêtre graphique sans la fermer :

plt.clf()

Voyons en détail le rôle de la fonction plot() du module matplotlib.pyplot :

Le mot anglais plot signifie tracer point par point en français. La fonction plot() du module Pyplot permet de tracer une courbe à partir d'une liste de points, et en reliant chaque point par un segment de droite. Pour cela la fonction plot() a besoin de 2 listes : une liste représentant la valeur des abscisses de chaque point, et une seconde liste représentant la valeur des ordonnées de chaque point.

Exemple : nous disposons de 8 points de coordonnées connues et nous voulons tracer une courbe reliant ces 8 points. Voici les coordonnées de chacun des points :

(1;-3)
(2;-1)
(4;0)
(5;4)
(6;7)
(8;3)
(9;10)
(11;2)

Pour tracer cette courbe on commence par créer une liste x contenant toutes les abscisses (et seulement les abscisses) de chacun des 8 points :

x=[1,2,4,5,6,8,9,11]

On crée une seconde liste y contenant cette fois toutes les valeurs des ordonnées des 8 points :

y=[-3,-1,0,4,7,3,10,2]

Puis on appelle la fonction plot() en lui passant en paramètre les 2 listes :

plt.plot(x,y)

Voici le résultat dans la fenêtre graphique Pyplot (les 8 points indiqués sont reliés par des segments de droite) :

Pour mettre en valeur les 8 points de la courbes on peut passer en 3ème paramètre à la fonction plot() la chaîne de caractère 'o' :

plt.plot(x,y,'o')

Voici le résultat dans la fenêtre graphique Pyplot (les 8 points sont mis en valeur par des petits ronds) :

Effaçons la courbe sans effacer le repère :

plt.cla()

On obtient alors un repère vide :

Pour dessiner seulement les 8 points dans le repère sans les relier par des segments de droite il faut préciser 'o' en 3ème paramètre à plot() :

plt.plot(x,y,'o')

Cette fois on obtient la représentation graphique des 8 points sans les segments les joignant :

Mais on remarque que le point de coorcdonnées (9;10) sort du repère car la limite sur l'axe des ordonnées est 10. Pour que ce point soit dans le repère nous allons imposer l'échelle des ordonnées pour que l'axe aille de -4 à 12 grâce à la fonction ylim :

plt.ylim(-4,12)

Maintenant l'axe des ordonnées va de -4 à 12 et nos 8 poins sont tous entièrement dans le repère :

Et si on veut à nouveau joindre les 8 points par des segments de droite on relance plt.plot(x,y) (sans le 3ème paramètre) :

Effaçons tout le contenu de la fenêtre graphique sans la fermer :

plt.clf()

La fonction plot() peut également tracer une courbe à partir d'une seule liste de valeur. Dans ce cas la liste représente les ordonnées des points, et les abscisses seront alors les indices des valeurs dans la liste (donc des valeurs entières commençant à 0). Tapons par exemple :

plt.plot([16,8,4,2,1])

Il s'agit d'une liste de 5 points dont les coordonnées seront :

(0;16)
(1;8)
(2;4)
(3;2)
(4;1)

Les abscisses (en rouge ci-dessus) correspondent aux indices dans la liste unique passée en paramètre à plot().

Voici le résultat obtenu dans la fenêtre graphique Pyplot :

Dessinons les 5 points en rouge pour bien les voir ('o' pour des ronds et 'r' pour la couleur rouge) :

plt.plot([16,8,4,2,1],'or')

Voici le résultat obtenu dans la fenêtre graphique Pyplot :

L'échelle des abscisses qui va de 0 à 4 est trop juste. Modifions-la grâce à la fonction xlim pour qu'elle aille de -0.5 à 4.5 :

plt.xlim(-0.5,4.5)

Voici le résultat obtenu dans la fenêtre graphique Pyplot :

L'échelle des ordonnées qui va de 0 à 16 est également trop juste. Modifions-la grâce à la fonction ylim pour qu'elle aille de 0 à 18 :

plt.ylim(0,18)

Nous obtenons alors nos 5 points parfaitement visibles dans une repère ajusté sur mesure :

Fermons entièrement la fenêtre graphique Pyplot :

plt.close()

Voilà vous savez tout sur l'utilisation rapide de la fonction plot() pour tracer une courbe à partir d'une série de point.

A retenir :

• la fonction plot de pyplot permet de tracer une courbe à partir d'une série de points
• la fonction plot attend en paramètre 1 ou 2 listes
• plot(x,y) avec 2 listes : la liste x contient les abscisses et la liste y contient les ordonnées
• plot(y) avec 1 seule liste : la liste y contient les ordonnées et les abscisses sont les indices dans la liste y
• plot(x,y) relie les points par des segments de droite
• plot(x,y,'o') dessine les points dans le repère sans les relier par des segments
• pour tout savoir sur la fonction plot tapez plt.plot? dans la console IPython

Retour en haut de la page

Dessin de formes géométriques et configuration des axes

Voyons maintenant comment tracer des formes géométriques dans la fenêtre graphique Pyplot.

Voici un exemple de dessin de figures géométriques à tester en tapant le code ligne à ligne dans la console IPython tout en observant l'évolution de la fenêtre graphique Pyplot :

In [1]: import matplotlib.pyplot as plt;plt.ion()
In [2]: fig=plt.figure()
In [3]: ax=fig.add_subplot(1,1,1)
In [4]: rect=plt.Rectangle((0.2,0.75),0.4,0.15,color='k',alpha=0.3)
In [5]: cercle=plt.Circle((0.7,0.2),0.15,color='b',alpha=0.4)
In [6]: ax.add_patch(rect)
Out[6]: <matplotlib.patches.Rectangle at 0x2ddec50>
In [7]: ax.add_patch(cercle)
Out[7]: <matplotlib.patches.Circle at 0x2ddeb30>
In [8]: plt.show()

Et voici le résultat final de cette figure contenant 2 formes géométriques (un rectangle et un cercle) :

Mais on remarque que le cercle est de forme ovale car le repère n'est pas orthonormé. Cela vient du fait que le repère est rectangulaire alors que les échelles sont les mêmes en abscisses comme en ordonnées (de 0 à 1 dans les deux cas). Pour qu'une unité sur l'axe des abscisses corresponde exactement à la même longueur que sur l'axe des ordonnées (repère orthonormé) il faut lancer la commande plt.axis('equal') :

plt.axis('equal')

Maintenant le cercle est bien rond (car nous avons un repère orthonormé), mais le rectangle est à la limite du repère :

Modifions l'échelle des ordonnées pour que l'axe aille de 0 à 1 grâce à ylim :

plt.ylim(0,1)

On voit bien le rectangle entièrement, le repère est bien resté orthonormé (le cercle est en forme de rond), mais le cercle est à son tour à la limite du repère :

Comment faire pour que les 2 formes géomètriques soient à l'intérieur du repère ? Pour celà nous allons modifier les 2 axes à la fois grâce à la fonction axis de Pyplot. Il faut alors lui passer en paramètre une liste à 4 éléments représentant les valeurs limites de chaque axe.

On veut l'axe des abscisses qui va de 0 à 1 et l'axe des ordonnées qui va également de 0 à 1. Pour cela on lance :

plt.axis([0,1,0,1])

Cette fois les 2 formes géométriques sont dans le repère (et non à la limite) et le repère est resté orthonormé (le cercle est bien en forme de rond et pas ovale) :

Pour tout savoir sur la fonction axis de Pyplot, tapez plt.axis? dans la console IPython.

Nous venons de voir les bases pour dessiner des formes géométriques dans une fenêtre graphique Pyplot, ainsi que les fonctions permettant de modifier l'échelle sur les deux axes du repère.

Voici les fonctions de base à connaître pour agir sur la fenêtre graphique Pyplot :

plt.draw() ouvre physiquement la fenêtre pyplot
plt.close() ferme physiquement la fenêtre pyplot

plt.show() met à jour le contenu de la fenêtre pyplot
plt.clf() efface tout le contenu de la fenêtre pyplot
plt.cla() efface seulement la figure sans effacer le repère

plt.xlim(2,7) modifie l'échelle de l'axe des abscisses
plt.ylim(-1,9) modifie l'échelle de l'axe des ordonnées

plt.axis('off') efface les axes
plt.axis('on') affiche les axes
plt.axis('equal') configure un repère orthonormé
plt.axis([0,1,0,1]) modifie l'échelle des 2 axes

A utiliser toujours après avoir importé pyplot en mode intéractif : import matplotlib.pyplot as plt;plt.ion()

Une fois ouverte, la fenêtre pyplot peut contenir :

• des courbes (plot)
• des figures géométriques (patch)
• des images surfaciques (plt.imshow, plt.pcolor, etc.)

Nous venons de voir rapidement qu'une fenêtre graphique Pyplot peut contenir :

• du texte
• des courbes
• des formes géométriques
• un titre

A retenir :

Pour obtenir des informations complémentaires sur la syntaxe exacte d'une quelconque de ces fonctions il faut taper son nom suivi immédiatement d'un point d'interrogation dans la console IPython. Par exemple pour obtenir l'aide de la fonction text de Pyplot on tape plt.text? dans la console IPyhton

Retour en haut de la page

Utilisation de la fonction pyplot.Polygon pour tracer un polygone

Voici un exemple qui trace un triangle en utilisant la fonction plt.Polygon :

import matplotlib.pyplot as plt
fig=plt.figure()
ax=fig.add_subplot(1,1,1)
ax.add_patch(plt.Polygon([(0.2,0.6),(0.6,0.2),(0.2,0.2)],True))
plt.show()

La figure alors obtenue est la suivante :

Remarque : la fonction plt.Polygon attend en premier paramètre une liste de tuples (nombres entre parenthèses et séparés par une virgule), représentant chacun un point.

Si le second paramètre vaut True, le polygone sera automatiquement fermé par le trait extérieur, s'il vaut False le polygone restera ouvert.

Mais seul le premier paramètre est obligatoire (la liste de tuples). Par exemple pour tracer un triangle on passe en paramètre une liste de 3 tuples représentant les coordonnées des 3 sommets du triangle :

ax.add_patch(plt.Polygon([(0.2,0.8),(0.6,0.2),(0.8,0.6)]))

Pour obtenir de l'aide sur l'utilisation avancée des paramètres utilisable avec Polygon il faut taper help(plt.Polygon) dans IPython (q pour quitter l'aide) ou plt.Polygon? pour une aide plus rapide. On obtient entre autre :

Methods defined here:

__init__(self, xy, closed=True, **kwargs)
*xy* is a numpy array with shape Nx2.

"*xy* is a numpy array with shape Nx2" peut être traduit par "xy est une liste de tuples représentant les points"

Pour le remplissage par hachures :

ax.add_patch(plt.Polygon([(0.2,0.8),(0.6,0.2),(0.8,0.6)],hatch='o'))
ax.add_patch(plt.Polygon([(0.2,0.8),(0.6,0.2),(0.8,0.6)],hatch='|'))
ax.add_patch(plt.Polygon([(0.2,0.8),(0.6,0.2),(0.8,0.6)],hatch='-'))

Pour les couleurs :

ax.add_patch(plt.Polygon([(0.2,0.8),(0.6,0.2),(0.8,0.6)],color='#FF0000')) ax.add_patch(plt.Polygon([(0.2,0.8),(0.6,0.2),(0.8,0.6)],ec='#FF0000'))
ax.add_patch(plt.Polygon([(0.2,0.8),(0.6,0.2),(0.8,0.6)],fc='#FF0000'))

fc=couleur du fond du polygone
ec=couleur des hachures et du trait extérieur
color=même couleur pour le fond et les traits

Exemple d'application : un triangle rouge avec des hachures horizontales vertes :

ax.add_patch(plt.Polygon([(0.2,0.8),(0.6,0.2),(0.8,0.6)],hatch='-',ec='#00FF00',fc='#FF0000'))

Voici le résultat :

Configuration des axes, du cadre, du repère et des graduations :

# pas de cadre
ax.set_frame_on(False)
# pas de graduations d'axes
ax.xaxis.set_visible(False)
ax.yaxis.set_visible(False)
# pas de graduation en haut ou en bas :
ax.xaxis.tick_bottom()
ax.xaxis.tick_top()
# pas de graduation à droite ou à gauche :
ax.yaxis.tick_right()
ax.yaxis.tick_left()

On obtient alors seulement la forme géomètrique sans les axes ni le repère :

Pour les figures géométriques (patch) le paramètre zorder permet de définir la position du calque.

zorder = l'ordre en terme de profondeur. Les valeurs les plus élevées sont celles qui sont les plus devant (au premier plan). La valeur par défaut est 1. On peut donner des valeurs non entières, ou même négatives.

Exemple pour ajouter un cercle jaune en arrière plan on lui définit un zorder valant 0 :

ax.add_patch(plt.Circle((0.4,0.8),0.2,zorder=0,color='#FFFF00'))

Comme le zorder du triangle vaut 1, il est supérieur au zorder du cercle qui vaut 0, et le triangle est donc devant le cercle.

Voici le résultat :

A retenir :

• la fonction Polygon de pyplot permet de tracer toutes sortes de polygones (avec un nombre quelconque de sommets, ouverts ou fermés)
• pour toutes les formes géométriques (Rectangle, Circle, Polygon) il est possible de configurer une couleur pour le fond et une autre couleur pour les hachures
• pour toutes les formes géométriques (Rectangle, Circle, Polygon) il est possible de configurer le zorder définissant le plan sur lequel est dessiné la forme (premier plan, arrière plan, etc.)
• dans la fenêtre pyplot il est possible d'effacer le repère, le cadre, les axes et les graduations afin de n'afficher que la figure géométrique

Retour en haut de la page

Comment modifier les paramètres d'une forme géométrique une fois qu'elle est tracée dans la fenêtre pyplot ?

Remarque : un copier/coller de plusieurs lignes dans IPython fonctionne très bien.

On part du programme suivant (à exécuter dans IPython) :

import matplotlib.pyplot as plt
plt.ion()
fig=plt.figure()
ax=fig.add_subplot(1,1,1)
cercle=plt.Circle((0.4,0.8),0.2)
triangle=plt.Polygon([(0.2,0.8),(0.6,0.2),(0.8,0.6)])
ax.add_patch(cercle)
ax.add_patch(triangle)
plt.show()

Résultat obtenu dans la fenêtre graphique de type tk :

Une fois le cercle tracé (de couleur bleu par défaut) on peut modifier ses paramètres grâce aux méthodes set_xxxxx de l'objet cercle. Exemples :

On configure la couleur rouge :

cercle.set_color('#FF0000')

Puis on redessine le graphique :

plt.show()

Résultat obtenu dans la fenêtre graphique de type tk :

Modification du rayon :

cercle.set_radius(0.1);plt.show()

Remarque : un point virgule permet d'écrire plusieurs instructions Python sur une seule ligne

Résultat obtenu dans la fenêtre graphique de type tk :

Remplit le cercle d'étoiles turquoises :

cercle.set_ec('#00FFFF');cercle.set_hatch('*');plt.show()

Résultat obtenu dans la fenêtre graphique de type tk :

Fait disparaître le cercle :

cercle.set_visible(False);plt.show()

Résultat obtenu dans la fenêtre graphique de type tk :

Fait apparaître le cercle :

cercle.set_visible(True);plt.show()

Résultat obtenu dans la fenêtre graphique de type tk :

Demande le centre du cercle :

cercle.center

Modifie la position du cercle (coordonnées du centre) :

cercle.center=(0.8,0.3);plt.show()

Résultat obtenu dans la fenêtre graphique de type tk :

Demande les sommets du triangle :

triangle.xy

Modifie les 3 sommets du triangle :

triangle.xy=[(0.2,0.6),(0.4,0.2),(0.6,0.8)];plt.show()

Résultat obtenu dans la fenêtre graphique de type tk :

Déplaçons le cercle pour qu'il soit superposé au triangle. On constate que le triangle est toujours devant le cercle :

cercle.center=(0.4,0.4);plt.show()

Résultat obtenu dans la fenêtre graphique de type tk :

Demande le zorder (position du calque en profondeur) de chacune des formes :

cercle.get_zorder()
triangle.get_zorder()

Le zorder par défaut est de 1 pour chaque forme, mais comme le triangle a été dessiné après le cercle il est au premier plan.

Fait passer le cercle devant le triangle en augmentant sont zorder (ordre selon l'axe z) :

cercle.set_zorder(2);plt.show()

Résultat obtenu dans la fenêtre graphique de type tk :

Efface définitivement le cercle :

cercle.remove();plt.show()

Résultat obtenu dans la fenêtre graphique de type tk :

Remarque : cette fois le cercle est définitivement supprimé de la figure et la commande cercle.set_visible(True);plt.show() ne le fera pas ré-apparaître.

A retenir :

• les formes géométriques (Rectangle, Circle, Polygon) disposent de propriétés consultables pour obtenir des informations et modifiables pour les faire évoluer (position, couleur, zorder, etc.)
• pour obtenir les différentes propriétés d'une forme géométrique (Rectangle, Circle, Polygon) il faut utiliser la fonction help dans la console IPython. Exemple : help(plt.Circle) (taper q pour quitter l'aide)
• pour obtenir une aide plus rapide on peut également taper le nom de l'objet suivi d'un point d'interrogation. Exemple : plt.Rectangle? pour voir rapidement les paramètres de l'objet Rectangle

Retour en haut de la page

Affichage d'une image dans une fenêtre Pyplot :

Voyons maintenant comment afficher une image dans une fenêtre graphique Pyplot. La fonction imshow() de Pyplot permet de lire, de décoder puis d'afficher directement un fichier image au format .png.

Voici une image au format PNG enregistrée sous le nom image.png :

image.png

Cliquez ici pour télécharger l'image de la girafe sous le nom image.png

Remarque : le fichier image.png doit être enregistré dans le répertoire courant d'IPython. Pour savoir quel est le répertoire courant de Python il faut utiliser la fonction getcwd() du module os de Python :

import os
os.getcwd()

Pour modifier le répertoire courant de Python il faut utiliser la fonction chdir() du module os de Python :

import os
os.chdir("c:\travail\python")

Voici le code source qui permet d'afficher l'image image.png (enregistrée dans le répertoire courant d'IPython) dans une fenpetre Pyplot grâce à la fonction imshow() :

import matplotlib.pyplot as plt
plt.ion()
img=plt.imread("image.png")
plt.imshow(img)

Et voici le résultat dans une fenêtre Pyplot de type tk :

Pour connaître la résolution de l'image il faut utiliser la propriété shape de l'objet img :

In [16]: img.shape
Out[16]: (387, 290, 4)

On en déduit que la résolution de l'image de la girafe est 290x387 pixels. On peut remarquer que les axes du repère sont naturellement gradués selon la résolution (de 0 à 289 en abscisses et de 0 à 386 en ordonnées) et que l'origine de l'image (point de coordonnées (0,0)) est le coin en haut à gauche de l'image.

La fonction axis de Pyplot permet de connaître l'échelle appliquée sur les axes :

In [17]: plt.axis()
Out[17]: (-0.5, 289.5, 386.5, -0.5)

Et la fonction axis permet également d'afficher (plt.axis('on')) ou d'effacer (plt.axis('off')) les axes dans le repère de la fenêtre Pyplot.

Supprimons l'affiche des axes autour de l'image :

plt.axis('off')

On obtient alors seulement l'image (sans les axes ni les graduations) dans la fenêtre Pyplot :

Effaçons le graphe pyplot puis insérons-y une liste de valeur à la place de l'image :

plt.clf()
tab=[list(range(10)),list(range(10))]
plt.imshow(tab)

Voici le résultat dans la fenêtre Pyplot :

Créons une image de 4x4 pixels (16 pixels en tout) tous de couleur rouge :

plt.clf()
tab=[[],[],[],[]]
tab[0]=[[1.,0.,0.,1.],[1.,0.,0.,1.],[1.,0.,0.,1.],[1.,0.,0.,1.]]
tab[1]=[[1.,0.,0.,1.],[1.,0.,0.,1.],[1.,0.,0.,1.],[1.,0.,0.,1.]]
tab[2]=[[1.,0.,0.,1.],[1.,0.,0.,1.],[1.,0.,0.,1.],[1.,0.,0.,1.]]
tab[3]=[[1.,0.,0.,1.],[1.,0.,0.,1.],[1.,0.,0.,1.],[1.,0.,0.,1.]]
plt.imshow(tab)

Voici le résultat dans la fenêtre Pyplot :

Configurons en noir le premier pixel :

tab[0][0][0]=0
plt.imshow(tab)

Voici le résultat dans la fenêtre Pyplot :

Configurons en vert le premier pixel :

tab[0][0][1]=1
plt.imshow(tab)

Voici le résultat dans la fenêtre Pyplot :

Configurons en bleu le premier pixel :

# rouge :
tab[0][0][0]=0
# vert :
tab[0][0][1]=0
# bleu :
tab[0][0][2]=1
plt.imshow(tab)

Voici le résultat dans la fenêtre Pyplot :

Configurons en jaune le pixel de coordonnées [2][3] :

# rouge :
tab[2][3][0]=1
# vert :
tab[2][3][1]=1
# bleu :
tab[2][3][2]=0
plt.imshow(tab)

Voici le résultat dans la fenêtre Pyplot :

Modifions la "brillance" (4ème valeur dans le tableau après RVB qui vaut 1 par défaut) du pixel jaune [2][3] :

Configurons la brillance à 0 :

tab[2][3][3]=0
plt.imshow(tab)

Voici le résultat dans la fenêtre Pyplot :

Configurons la brillance à 0.5 :

tab[2][3][3]=0.5
plt.imshow(tab)

Voici le résultat dans la fenêtre Pyplot :

Configurons la brillance à 0.1 :

tab[2][3][3]=0.1
plt.imshow(tab)

Voici le résultat dans la fenêtre Pyplot :

Remettons la brillance à sa valeur par défaut, c'est-à-dire 1 :

tab[2][3][3]=1
plt.imshow(tab)

Voici le résultat dans la fenêtre Pyplot (on retrouve l'image d'origine) :

A retenir : chaque pixel de l'image est piloté par un tableau à 3 dimensions contenant 4 valeurs par pixel. Le pixel de coordonnées (x,y) sera configuré par :

• tab[x][y][0] pour configurer sa couleur rouge (valeur comprise entre 0 et 1)
• tab[x][y][1] pour configurer sa couleur verte (valeur comprise entre 0 et 1)
• tab[x][y][2] pour configurer sa couleur bleu (valeur comprise entre 0 et 1)
• tab[x][y][3] pour configurer sa brillance (valeur comprise entre 0 et 1)

Exemple d'application : dessiner une mire de couleur où chaque pixel aura une valeur différente en fonction de ses scoordonnées.

Voici un exemple de programme qui remplit le tableau tab avec une couleur différente par pixel :

tab=[[],[],[],[]]
tab[0]=[[0.,0.,0.,1.],[0.,0.,0.,1.],[0.,0.,0.,1.],[0.,0.,0.,1.]]
tab[1]=[[0.,0.,0.,1.],[0.,0.,0.,1.],[0.,0.,0.,1.],[0.,0.,0.,1.]]
tab[2]=[[0.,0.,0.,1.],[0.,0.,0.,1.],[0.,0.,0.,1.],[0.,0.,0.,1.]]
tab[3]=[[0.,0.,0.,1.],[0.,0.,0.,1.],[0.,0.,0.,1.],[0.,0.,0.,1.]]

for x in range(4):
        for y in range(4):
                tab[x][y][0]=x/3
                tab[x][y][1]=y/3
                tab[x][y][2]=(x+y)/6

plt.imshow(tab)

Et voici le résultat graphique de cette mire de couleur :

Cette image a toujours une résolution de 4x4 pixels (soit 16 pixels seulement en tout). En modifiant le programme précédent on peut créer des mires de couleur de résolution supérieure et de complexité quelconque en modifiant la formule donnant la couleur à un pixel en fonction de ses coordonnées.

Exemple : le programme suivant crée une mire de couleur d'une résolution de 128x128 pixels (soit 16384 pixels en tout) :

resolution=128
tab=[]

# crée le tableau à 3 dimensions de taille 128*x128x4 contenant seulement des pixels noirs :
for x in range(resolution):
        sous_tableau=[]
        for y in range(resolution):
                sous_tableau.append([0.,0.,0.,1.])
        tab.append(sous_tableau)

# configure une couleur différente pour chacun des 16384 pixels en fonction de sa position x y :
for x in range(resolution):
        for y in range(resolution):
                tab[x][y][0]=x/(resolution-1)
                tab[x][y][1]=y/(resolution-1)
                tab[x][y][2]=(x*y)/((resolution-1)**2)

plt.imshow(tab)

Et voici le résultat graphique de cette nouvelle mire de couleur :

A retenir :

• la fonction imshow de pyplot permet d'afficher une image dans la fenêtre graphique
• l'image peut provenir d'un fichier enregistré dans le répertoire courant de Python
• mais l'image peut également être dessinée pixel par pixel en remplissant un tableau à 3 dimensions indiquant la couleur de chaque pixel
• pour obtenir toute la syntaxe de la fonction imshow consultez l'aide dans la console IPython : help(plt.imshow) (taper q pour quitter l'aide) ou plt.imshow?

Retour en haut de la page

Comment sauvegarder les figures dans une image ?

Une fois la fenêtre pyplot remplie de graphiques, formes géométriques, textes ou formules LaTex il est très simple de la sauvegarder dans une image .png grâce à la méthode savefig :

plt.savefig('mon_image.png')

Il est alors très facile de créer toute une série d'images.

Affichage de texte :

import matplotlib.pyplot as plt
plt.ion()
plt.subplot(1,1,1)
plt.title("Mon graphe")
plt.text(0.5,0.5,"Bonjour")
plt.text(0.1, 0.8, r'graphe de f(x) = $\sqrt{x}$',fontsize = 20, color = 'red', backgroundcolor = 'yellow')
plt.text(0.2,0.2,r'$I=\int_0^\pi \frac{x\cdot\sin(x)}{\ 1+\cos^2(x)\ }\cdot dx$',fontsize = 30)

Résultat obtenu dans la fenêtre graphique de type tk :

Création d'une image contenant seulement une formule LaTex :

import matplotlib.pyplot as plt
figure = plt.figure(1, figsize=(5, 3))
plt.ion()
plt.subplot(1,1,1)
plt.axis('off')
plt.text(0.1,0.4,r'$I=\int_0^\pi \frac{x\cdot\sin(x)}{\ 1+\cos^2(x)\ }\cdot dx$',fontsize = 30)
plt.savefig('image.png', transparent=True, dpi=72)

Résultat obtenu dans la fenêtre graphique de type tk :

Et voici l'image créée et enregistrée sous le nom image.png :

Pour tout savoir sur le langage de description LaTex permettant de composer toutes sortes de formules mathématiques consultez cet article.

Remarques : le fichier image.png qui a été créé est enregistré dans le répertoire courant d'IPython. Pour savoir quel est le répertoire courant de Python il faut utiliser la fonction getcwd() du module os de Python :

import os
os.getcwd()

De plus l'image image.png possède la figure dessinée (ici une formule mathématique) avec un fond transparent.

A retenir :

• la figure graphique dessinée dans une fenêtre Pyplot peut contenir une grande diversité d'éléments : courbes, formes géométrique, texte, formule mathématiques écrite en langage LaTex, etc.
• une fois la figure graphique complète, il est très facile de l'enregistrer dans un fichier image grâce à la fonction savefig de pyplot
• pour connaître toutes les possibilités de la fonction savefig consultez l'aide dans la console IPython : help(plt.savefig) (taper q pour quitter l'aide) ou plt.savefig?
• dans la fenêtre graphique Pyplot le bouton Save the figure permet également d'enregistrer rapidement la figure dans un fichier image

Retour en haut de la page

Le mode pylab

Dans IPython le mode pylab permet d'avoir un environnement scientifique de développement de type Matlab afin de tracer rapidement des courbes.

On dispose en un premier temps d'une seule fenêtre graphique contenant une seule courbe (sans gérer les graphes multiples).

Ouvrir IPython puis lancer la commande magique %pylab qt :

%pylab qt

(taper %pyl<tab> comme raccourcis)

Le mode pylab charge à la fois les modules NumPy et matplotlib.pyplot

Numpy est chargé dans le nom np alors que pyplot est dans l'espace de nom courant sans devoir préfixer les fonctions (exemple : plot est utilisable sans préfixe)

Voici comment tracer une courbe :

x=np.arange(0,20,0.1)
y=sin(x)
plot(x,y)

x est un tableau Numpy (de type ndarray), y est un autre tableau calculé point par point à partir de x, et plot affiche tous les points d'abscisse dans x et d'ordonnée dans y.

Et voici le résultat dans une fenêtre graphique de type qt :

La fenêtre graphique (la "figure") est contrôlable directement par les commandes suivantes à utiliser sans préfixe :

close() : ferme la fenêtre
draw() : ouvre la fenêtre (qui est alors vide)
show() : actualise le contenu de la fenêtre
grid() : affiche ou efface le cadrillage dans le repère
plot(x,y) : retrace la courbe

La fonction plot() peut recevoir un troisième paramètre indiquant la forme et la couleur de la courbe. Exemples :

plot(x,y,'r') trace une courbe en rouge :

plot(x,y,'o') trace une courbe non continue avec des points :

plot(x,y,'+g') trace une courbe non continue avec des signes plus (+) et de couleur verte (g) :

Pour obtenir toutes la syntaxe du troisième paramètre de la fonction plot() consultez l'aide en tapant help(plot) (q pour quitter l'aide) ou plot? dans IPython.

En lançant plusieurs fois la fonction plot() il est possible de tracer plusieurs courbes dans un même repère. Exemple :

x=np.arange(0,20,0.1)
y1=10*sin(x+20)
y2=x*sin(x)
y3=20*sin(x)/(x+1)
plot(x,y1)
plot(x,y2)
plot(x,y3)

Et voici le résultat :

Ajoutons un titre à la figure, ainsi qu'une étiquette sur chacun des axes :

title("Démonstration de Matplotlib")
xlabel("Axe des abscisses")
ylabel("Axe des ordonnées")

Et voici le résultat :

Ajoutons un texte en couleur directement sur la figure en un point de coordonnées précises pour commenter chacune des courbes :

text(1.8,7,'courbe rouge',color='red')
text(7,10,'courbe bleue',color='blue')
text(13.5,-18,'courbe verte',color='green')

Et voici le résultat :

Fermons la fenêtre Pyplot :

close()

Retraçons 2 courbes dans la même fenêtre mais en ajoutant cette fois une légende pour les identifier :

x=np.arange(0,20,0.1)
plot(x, np.sin(x), '-g', label='sin(x)')
plot(x, np.cos(x), ':b', label='cos(x)')
legend();

Voici le résultat dans la fenêtre graphique Pyplot de type qt :

Jusqu'à présent l'échelle utilisée sur les axes a toujours été automatique : c'est Python qui choisit les intervalles de valeurs utilisés sur chacun des axes. Mais il est possible d'imposer une échelle particulière pour chaque axe.

Configurons l'axe des ordonnées entre -2 et 2 grâce à ylim :

ylim(-2,2)

Voici le résultat dans la fenêtre graphique Pyplot de type qt :

Configurons maintenant l'axe des abscisses entre -5 et 25 grâce à xlim :

xlim(-5,25)

Voici le résultat dans la fenêtre graphique Pyplot de type qt :

Grâce à la fonction axis de pyplot il est possible de configurer d'un coup les échelles des 2 axes à la fois :

axis([-1, 11, -1.5, 1.5])

Voici le résultat dans la fenêtre graphique Pyplot de type qt :

La fonction axis peut recevoir plusieurs paramètres. Par exemple pour retrouver l'échelle automatique sur les axes :

axis('auto')

Voici le résultat dans la fenêtre graphique Pyplot de type qt :

Autre exemple des possibilités de la fonction axis permettant d'obtenir un repère orthonormé :

axis('equal')

Voici le résultat dans la fenêtre graphique Pyplot de type qt :

Pour connaître toutes les possibilités de la fonction axis() consultez l'aide en tapant help(axis) (q pour quitter l'aide) ou axis? dans IPython.

A retenir :

• la commande magique %pylab qt (à taper dans la console IPython) permet de charger automatiquement les modules matplotlib.pyplot et Numpy tout en utilisant une fenêtre graphique intéractive de type qt
• il est possible de tracer plusieurs courbes dans la même fenêtre et de choisir leur couleur
• on peut ajouter une légende dans la figure grâce à legend afin d'identifier chaque courbe
• il est possible d'afficher une étiquette sur les axes grâce à xlabel et ylabel
• il est possible de modifier séparément l'échelle des axes grâce à xlim et ylim
• il est possible de modifier automatiquement l'échelle des axes grâce à axis

Retour en haut de la page

Remarques concernant les différents types de fenêtres graphiques

Sous Windows il existe 2 types de fenêtres graphiques : tk et qt

%pylab (sans paramètre) ou %pylab tk lance une fenêtre de type tk (type par défaut)

Voici à quoi ressemble une fenêtre de type tk :

une fenêtre tk possède 7 boutons de configuration

%pylab qt utilise une fenêtre graphique de type qt (plus de choix de configuration)

Voici à quoi ressemble un fenêtre de type qt :

une fenêtre qt possède 8 boutons de configuration

L'avantage d'une fenêtre de type qt c'est qu'elle dispose d'un bouton supléménetaire nommé "Edit curves line and axes parameters" et permettant de modifier de manière intéractive les paramètres de la courbe tracée dans le repère Pyplot (couleur, type de trait, échelle des axes, etc.) :

En raison de ce bouton supléménetaire nommé "Edit curves line and axes parameters" une fenêtre de type qt est donc plus performante qu'une fenêtre de type tk car elle propose beaucoup d'options de configuration intéractives suplémentaires.

MAIS ATTENTION : le mode pylab qt d'IPython est totalement incompatible avec la tortue.

La tortue étant de type tk, si sa fenêtre est ouverte alors seul le mode tk de pylab fonctionne.

Soit on importe le module tutle et on utilise seulement la fenêtre de la tortue en mode interactif : from turtle import * (il s'agit forcément d'une fenêtre tk)

Soit on bascule IPython en mode pylab qt (%pylab qt) et on trace des courbe à la manière Matlab dans une une fenêtre de type qt.

Mais une fois un des modes activé on ne peut pas utiliser l'autre mode dans la même session d'IPython.

Si on veut à la fois la tortue et pylab, la solution consiste à ouvrir 2 consoles IPython : dans une on charge le module tutle, et dans l'autre le mode pylab (ou à utiliser pylab en mode tk).

Pour plus d'informations sur pylab consultez l'aide dans IPython en tapant help(pylab) (q pour quitter l'aide) ou pylab?.

Pour aller plus loin dans la découverte de matplotlib cliquez ici et expérimenter les différents exemples

Retour en haut de la page

python.gecif.net