Importation du module : from matplotlib import pyplot.
La taille par défaut d'une graphe est 6.4 x 4.8 (en inches) et 640 x 480 en pixels
Pour tracer un graphe x-y avec les points reliés (pour un nuage de points, utiliser plutôt scatter) :
Pour tracer un graphe d'une liste de valeurs en fonction du numéro d'ordre :
pyplot.plot([1, 2, 4, 4, 2, 1], color = 'red', linestyle = 'dashed', linewidth = 2,
markerfacecolor = 'blue', markersize = 5)
pyplot.ylim(0, 5)
pyplot.title('Un exemple')
On peut aussi tracer seulement les points, non reliés :
pyplot.plot([1, 3, 2, 3], [4, 8, 5, 4], linestyle = 'none', marker = 'o', c = 'lime',
markersize = 10)
pyplot.xlim(0, 4)
pyplot.ylim(0, 10)
pyplot.title('Avec des points seulement')
Si on veut mettre des etiquettes tous les n valeurs :
import math
val = [math.log(i + 1) for i in range(100)]
labels = ['lab' + str(i) for i in range(100)]
tickLabels = [labels[i] for i in range(100) if (i % 10) == 0]
pyplot.plot(val, linestyle = 'none', marker = '+')
pyplot.gca().get_xaxis().set_ticks([i for i in range(len(val)) if i % 10 == 0])
pyplot.gca().get_xaxis().set_ticklabels(tickLabels, fontsize = 8, rotation = 90)
Remplissage de la zone entre 2 courbes :
x = range(10); y1 = range(10)
y2 = [x ** 2 for x in range(10)]
pyplot.fill_between(x, y1, y2, color = 'yellow')
Manipulation d'un graphe :
- on peut récupérer les limites des axes par : ax.get_xlim(), ax.get_ylim()
- on peut fixer les limites des axes par : ax.set_xlim(), ax.set_ylim()
- on peut récupérer le titre d'un axe par : ax.get_title()
- on peut fixer le titre d'un axe par : ax.set_title()
Sauvegarde de l'image dans un fichier :
- pyplot.savefig('image.png'); pyplot.close().
- pyplot.savefig('image.png', dpi = 300) : fixe la résolution.
- pyplot.savefig('image.png', transparent = True) : fond transparent.
- pyplot.savefig('image, format = 'pdf') : indique le format. Les formats supportés sont : png, pdf, eps, svg, sinon le format est deviné d'après l'extension du fichier.
- on peut très bien sauvegarder une image avec pyplot.savefig, puis changer les limites du graphe avec pyplot.xlim/ylim et resauvegarder la nouvelle image avec pyplot.savefig : ça permet ainsi par exemple de sauvegarder un zoom de l'image !
- attention, quand on génère un svg, par défaut, le texte est transformé en paths (i.e. en dessin). Si on veut garder le texte comme texte, faire avant : pyplot.rcParams['svg.fonttype'] = 'none'
Si on veut faire des graphes indépendamment d'un environnement X : faire :
import matplotlib
matplotlib.use('agg')
avant d'importer pyplot. Cela permet de fixer le backend par défaut (on peut voir le backend par défaut en faisant :
matplotlib.get_backend()). Il faut que l'instruction matplotlib.use soit appelée avant toute tentative d'utilisation de pyplot.
Réinitalisation / effaçage :
- pyplot.close() : ferme la figure et libère toutes les ressources liées à cette figure (à faire après sauvegarde de l'image dans un fichier, pas avant !)
- pyplot.clf() : efface la figure courante. Utile si beaucoup de graphes
- pyplot.cla() : efface le graphe courant.
Pour fixer la taille d'une figure :
- on peut fixer la taille par défaut de toutes les figures : pyplot.rcParams['figure.figsize'] = [7, 7]
- on peut fixer la taille d'une figure en inch par : pyplot.figure(figsize = (10, 10)) ou après création de celle-ci par pyplot.gcf().set_size_inches(10, 10).
- pour fixer la taille en pixel, il faut tenir compte du nombre de dots per inch, dpi :
- matplotlib.rcParams['savefig.dpi'] vaut maintenant 'figure'. Il valait avant 100
- on peut setter ce paramètre : matplotlib.rcParams['savefig.dpi'] = 100
- pyplot.figure(figsize = (100 / pyplot.rcParams['savefig.dpi'], 80 / pyplot.rcParams['savefig.dpi'])); ...; pyplot.savefig('myFile.png') : on utilise le nombre de dpi paramétré par défaut.
- pyplot.figure(figsize = (100 / 72.0, 80 / 72.0)); ...; pyplot.savefig('myFile.png', dpi = 72)
Pour indiquer une propriété :
- on peut donner directement la propriété : pyplot.plot([1, 2, 3, 4], [1, 4, 9, 16], linewidth = 4).
- on peut récupérer l'objet line renvoyé par plot (c'est une liste qui est renvoyée) et lui appliquer la propriété : line, = pyplot.plot([1, 2, 3, 4], [1, 4, 9, 16]); line.set_linewidth(4).
- on peut récupérer la liste d'objet renvoyée par plot et utiliser setp : lines = pyplot.plot([1, 2, 3, 4], [1, 4, 9, 16]); pyplot.setp(lines, linewidth = 4).
- on peut même aussi faire ça : lines = pyplot.plot([1, 2, 3, 4], [1, 4, 9, 16]); pyplot.setp(lines, 'linewidth', 4).
Graduations des axes :
- pyplot.xlim(0, 100) : graduation entre 0 et 100.
- pyplot.xlim(xmin = 0) : pour changer seulement le minimum (pareil avec pyplot.xlim(xmax = 0))
- pyplot.xscale('log') : pour utiliser une échelle logarithmique sur l'axe des x.
Figure et axe courants :
- on peut avoir la figure courante sur laquelle les propriétés s'appliquent par : pyplot.gcf()
- pour avoir les axes courants : pyplot.gca()
- pour fixer l'axe sur lequel on veut travailler : pyplot.sca(ax)
- pyplot.clf() : efface la figure courante.
- pyplot.cla() : efface le graphe courant.
- on peut avoir la liste des graphes de la figure courante par : pyplot.gcf().get_axes()
Traçage de lignes en dehors de la plage graduée :
- xlims = pyplot.xlim(); ylims = pyplot.ylim() : récupération des plages
- pyplot.plot([x1, x2], [y1, y2], color = 'black', clip_on = False, zorder = 10) : traçage d'un trait visible au-dessus
- pyplot.xlim(xlims); pyplot.ylim(ylims) : on fait en sorte que pyplot.plot ne modifie pas les bornes.
Ajout des titres et différents labels dans une figure :
- pyplot.xlabel('axes des x') : label de l'axe des x.
- on peut donner des propriétés : pyplot.xlabel('toto', color = 'green', fontsize = 16)
- pyplot.ylabel('axes des y', fontsize = 14, color = 'red') : label de l'axe des y.
- pyplot.title('titre') : titre.
- pyplot.title('my title', fontsize = 10, horizontalalignment = 'left', loc = 'left') : avec des propriétés
- pyplot.title(myTitle, pad = 10) : rajoute 10 points entre le titre et la figure (le titre remonte)
- pyplot.text(2, 4, r'$ rac{\mu}{\sigma} = 100$', size = 'xx-large') : texte, avec ici du latex (le 'r' indique que la string est "raw", il ne faut pas interpréter les backslahes).
- pyplot.grid(True) : affiche une grille.
- pyplot.gca().set_axisbelow(True) : pour avoir la grille derrière (zorder ne marche pas)
- pour effectuer une annotation : pyplot.annotate('my text', xy = (3, 8), xytext = (2, 12), arrowprops = {'facecolor': 'black', 'shrink': 0.1}) (xy indique où se trouve le point à annoter, xytext indique où démarre le texte, et arrowprops sont les propriétés de la flèche d'annotation.
Exemple :
pyplot.scatter([x / 2.0 for x in range(10)], [(x / 2.0) ** 2 for x in range(10)],
color = 'blue', marker = 'D', s = 30)
pyplot.xlabel('coordonnee X')
pyplot.ylabel('coordonnee Y')
pyplot.title('mon titre')
pyplot.text(0, 20, 'parabole')
pyplot.annotate('annotation', xy = (0, 0), xytext = (1, 10),
arrowprops = {'facecolor': 'red', 'shrink': 0.1})
pyplot.grid()
Pour changer le cycle des couleurs par défaut : pyplot.rcParams['axes.prop_cycle'] = plt.cycler(color=['orange', 'blue', 'green', 'red', 'purple', 'brown', 'pink', 'gray', 'olive', 'cyan'])
couleurs et symboles des graphes :
- pour préciser la couleur et le style : plot(x, y, 'bo') : bleu et avec des ronds.
- symboles :
- '-' ou 'solid' : ligne continue
- '--' ou 'dashed' : traits
- '-.' ou 'dashdot' : trait - point
- ':' ou 'dotted' : pointillé
- '.' : point marker
- ',' : pixel marker
- 'o' : circle marker
- 'v' : triangle_down marker
- '^' : triangle_up marker
- '<' : triangle_left marker
- '>' : triangle_right marker
- '1' : tri_down marker
- '2' : tri_up marker
- '3' : tri_left marker
- '4' : tri_right marker
- 's' : square marker
- 'p' : pentagon marker
- '*' : star marker
- 'h' : hexagon1 marker
- 'H' : hexagon2 marker
- '+' : plus marker
- 'x' : x marker
- 'D' : diamond marker
- 'd' : thin_diamond marker
- '|' : vline marker
- '_' : hline marker
- filled markers :
- 's' : carré
- 'o' : rond
- '>', '<', '^', 'v' : triangles avec différentes orientations
- 'X' : croix épaisse
- 'P' : plus épais
- 'd' : losange
- '*' : étoile
- unfilled markers :
- '+' : plus
- '.' : petit rond
- 'x' : croix
- pour faire des symboles ouverts (centre non coloré) : marker = 'o', markerfacecolor = 'none', markeredgecolor = 'red'
- couleurs : on peut utiliser des abbréviations :
- 'b' : blue
- 'g' : green
- 'r' : red
- 'c' : cyan
- 'm' : magenta
- 'y' : yellow
- 'k' : black
- 'w' : white
- on peut aussi utiliser comme couleurs : 'green', '#008000', (0, 1, 0, 1) (avec alpha)
Axes :
- pyplot.axis([0, 5, 0, 20]) : l'axe des x va de 0 à 5 et l'axe des y va de 0 à 20.
Traçage de droites horizontales ou verticales :
- pyplot.axhline(y = 3) : drote horizontale.
- pyplot.axvline(x = 4) : droite verticale.
- on peut tracer la doite sur une partie seulement en donnant les bornes entre 0 et 1 : pyplot.axvline(x = 4, ymin = 0, ymax = 0.8)
- paramètres des droites :
- color : la couleur
- alpha : le niveau de transparence, entre 0 et 1.
- linestyle : le style : '-', '--', '-.', ':', ''. On peut aussi donner l'offset (ici 0), la longueur du trait (ici 5) et la longueur de l'espace (ici 0) : (0, (5, 1))
exemple :
pyplot.plot([1, 2, 4, 6, 7, 8, 10, 15])
pyplot.axhline(y = 3, xmin = 0, xmax = 1, color = 'red', alpha = 0.5, linestyle = ':', linewidth = 2)
pyplot.axvline(x = 4, ymin = 0, ymax = 0.8, color = 'green', alpha = 0.5, linestyle = '--', linewidth = 4)
Traçage d'une droite :
- pyplot.axline([0, 1], [2, 3]) : trace la droite passant par les 2 points
- pyplot.axline([0, 1], slope = 1) : trace la droite passant par le point et de pente 1
Traçages de rectangles :
- pyplot.axhspan(4, 6, color = 'yellow') : trace un rectangle horizontal qui fait toute la largeur.
- facecolor = 'yellow' : indique la couleur de remplissage.
- edgecolor = 'red' : indique la couleur de trait.
- alpha = 0.5 : transparence (par défaut, le rectangle est sous la courbe.
- zorder = 5 : niveau d'affichage au-dessus de ceux avec un zorder < 5
- hatch = 'x' : hachurage (possibilités : '/', '\', '|', '-', '+', 'x', 'o', 'O', '.', '*')
- xmin = 0.1 : ne commence le traçage qu'à partir de 0.1 (coordonnée entre 0 et 1)
- xmax = 0.9 : finit le traçage à 0.9 (coordonnée entre 0 et 1)
- pyplot.axvspan(4, 6, color = 'yellow') : idem que axhspan, mais avec un rectangle "vertical" (utiliser ymin et ymax si on veut limiter sa hauteur).
matrice :
- mat = [[0.5, 0.5, 1], [0, 1, 1], [0, 1, 1]]; pyplot.matshow(mat); pyplot.gray(); pyplot.show() : représentation de la matrice en niveaux de gris, par ligne ([0.5, 0.5, 1] est la première ligne représentée de gauche à droite tout en haut).
Légende :
- pyplot.legend() : affiche la légende
- pyplot.legend(loc = 'best') : affiche la légende au meilleur endroit, sinon il y a : 'best', 'upper right', 'upper left', 'lower left', 'lower right', 'right', 'center left', 'center right', 'lower center', 'upper center', 'center'
- pyplot.legend(fontsize = 10) : pour modifier après coup la taille de la police de la légende.
zorder :
- indique dans quel ordre afficher les différents éléments. Plus le zorder est élevé, plus l'élément est devant les autres
- zorder par défaut :
- 1 pour les patchs
- 2 pour les lignes
- 3 pour le texte
Menu interactif :
- pan/zoom : bouton droit pour zoomer, et maintenir touche x ou y pour contraindre sur x ou y, et control pour contraindre sur le ratio.
- shortcut : h (home), left et right arrows pour back et forward, p pour pan/zoom, s pour save, g pour la grille, L pour toggle axes des x en log/linéaire, l pour toggle axe des y en log/linéaire.
si on travaille avec matplotlib depuis plusieurs threads, utiliser un backend non interactif : import matplotlib; matplotlib.use('Agg')
pyplot.close('all') : ferme tous les graphes.
Si on a un problème de mémoire en générant des centaines ou milliers de graphes, préférer :
- créer une figure une fois pour toute : fig = pyplot.figure(figsize = (5, 7))
- utiliser la figure : ax = fig.add_subplot(1, 1, 1) et utiliser cet axis "ax".
- sauver la figure : fig.savefig('output.png')
- effacer la figure et la réutiliser : fig.clf()
- à la fin de la boucle, fermer la figure : pyplot.close(fig)
Quand on utilise matplot sur un serveur web :
