pyplot et généralités

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) :

• from matplotlib import pyplot : pour importer le module.
• pour tracer un graphe avec des valeurs de x et des valeurs de y en reliant les points dans l'ordre de la liste : pyplot.plot([1, 2, 3, 6], [1, 4, 9, 36])
• pyplot.show() : montre le graphe courant. Si beaucoup de graphes à visualiser les uns derrière les autres, on peut faire :

  pyplot.gcf().set_size_inches(12, 12)
  for ...
    pyplot.show()
    pyplot.clf()
      

• on peut indiquer le symbole et la couleur : pyplot.plot(x, y, 'bo') : bleu et avec des ronds.
• on peut aussi indiquer tous les paramètres avec des tags séparés : pyplot.plot(x, y, color = 'green', linestyle = 'dashed', linewidth = 2, marker = 'o', markerfacecolor = 'blue', markersize = 5) : symboles ronds en bleu avec une taille de 5 et traits pointillés en vert.
• pyplot.plot(x, y, label = 'A') : permet de mettre un label sur la courbe !!!
• on peut tracer plusieurs courbes sur le même graphe : pyplot.plot(x, y, 'r+', y, y, 'bo')
• si on a un objet AxesSubplot, on peut tracer dessus un graphe en faisant : axes.plot(...)

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()

Propriétés par défaut :

• on peut les fixer dans un fichier matplotlibrc dans le directory courant, ou sinon dans ~/.matplotlib/matplotlibrc
• exemple de contenu de fichier :

  lines.linestyle   : -
  lines.color       : blue
  font.family       : sans-serif
  font.style        : normal
      

• on peut aussi les mettre dynamiquement avec : pyplot.rcParams['lines.linewidth'] = 2 (valeurs stockées dans un dictionnaire rcParams).

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
• 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 :

• ne pas utiliser pyplot, car il conserve des références sur les figures ouvertes, risque de fuite mémoire !
• utiliser Figure() :

  import matplotlib.figure
  fig = matplotlib.figure.Figure()
  ax = fig.subplots()
  ax.plot([1, 2, 1])
  fig.savefig('myImage.png')