1 Introduction

1.1 Ce support de cours

Ce support de cours a pour vocation de faire une introduction rapide de la librairie matplotlib en couvrant une partie des fonctions essentielles à son utilisation. Il n’a pas pour but d’être exhaustif, ni dans le choix des fonctions, ni dans les paramètres des fonctions documentées.

Certaines méthodes peuvent être appelées depuis l’espace global plt, tel que plt.plot(). Cela s’appliquera à la figure et l’Axes courant. Il est possible de faire le même appel de façon plus ciblée ainsi : ax.plot(). Ainsi le graph sera effectué dans l’espace relatif à l’objet ax préalablement créé.

Beaucoup d’exemples donnés dans ce support sont issus de la documentation originale, avec ou sans adaptation.

Les informations originales et comlètes peuvent être trouvées en suivant les lien qui accompagnent chaque chapitre.

Pour accéder à la documentation complète de MatPlotLib, vous pouvez vous rendre sur https://matplotlib.org/3.1.1/contents.html

Certains termes sont volontairements conservés en anglais, pour aider le lecteur à faire le lien avec la fonction ou la classe à laquelle il fait référence.

1.2 Pour suivre ce cours

Tout code Python peut être écrit dans un fichier dont l’extension est .py. Ce fichier peut ensuite être exécuté.

Pour ce cours, nous allons utiliser l’outil JupyterLab que vous pouvez librement télécharger et installer sur votre machine selon cette documentation https://jupyter.org/install.html.

L’EPFL offre également un service centralisé JupyterLab ici : https://noto.epfl.ch/

JupyterLab (qui est une évolution de Jupyter Notebook) nous permet d’écrire et exécuter notre code par portions et d’en voir le résultat (en texte ou en graphique), au fur et à mesure de la rédaction.

Chaque code mentionné dans ce document assume que les 3 lignes suivantes ont été exécutées en premier :

%matplotlib inline
import numpy as np
from matplotlib import pyplot as plt

• %matplotlib est une fonction dite magique de Jupyter (parce qu’elle commence par un %) et indique à MatPlotLib d’afficher les graphiques “en ligne”. Ceci est en réalité le comportement par défaut, donc nous pourrions nous passer de cette commande.
• import numpy as np importe la librairie Numpy ; pour plus d’informations, vous pouvez consulter ce chapitre qui lui est dédié.
• from matplotlib import pyplot as plt importe la librairie MatPlotLib.

2 Exemples de graphiques réalisables avec MatPlotLib

Voici quelques illustrations pour rapidement voir ce qui est réalisable. Plus d’exemples peuvent être vus dans la galerie matlplotlib.

2.1 Simple plot

X = np.linspace(-np.pi, np.pi, 256, endpoint=True)
C, S = np.cos(X), np.sin(X)
plt.plot(X, C, label='cosinus')
plt.plot(X, S, label='sinus')

plt.title('Simple plot')
plt.legend()

plt.show()

2.2 Subplots

plt.figure(figsize=(6, 4))
plt.subplot(2, 1, 1)
plt.xticks(())
plt.yticks(())
plt.text(0.5, 0.5, 'subplot(2,1,1)', ha='center',
         va='center', size=24, alpha=.5)

plt.subplot(2, 1, 2)
plt.xticks(())
plt.yticks(())
plt.text(0.5, 0.5, 'subplot(2,1,2)', ha='center',
         va='center', size=24, alpha=.5)

plt.tight_layout()
plt.show()

2.3 Axes

plt.axes([.1, .1, .8, .8])
plt.xticks(())
plt.yticks(())
plt.text(.6, .6, 'axes([0.1, 0.1, .8, .8])',
         ha='center', va='center',
         size=20, alpha=.5)

plt.axes([.2, .2, .3, .3])
plt.xticks(())
plt.yticks(())
plt.text(.5, .5, 'axes([0.2, 0.2, .3, .3])',
         ha='center', va='center',
         size=16, alpha=.5)

plt.show()

2.4 Ticks

def tickline():
    plt.xlim(0, 10)
    plt.ylim(-1, 0)
    plt.yticks([])
    ax = plt.gca()
    ax.spines['right'].set_color('none')
    ax.spines['left'].set_color('none')
    ax.spines['top'].set_color('none')
    ax.xaxis.set_ticks_position('bottom')
    ax.spines['bottom'].set_position(('data',0))
    ax.yaxis.set_ticks_position('none')
    ax.xaxis.set_minor_locator(plt.MultipleLocator(0.1))
    ax.plot(np.arange(11), np.ones(11))
    return ax

locators = [
                'plt.NullLocator()',
                'plt.MultipleLocator(1.0)',
                'plt.FixedLocator([0, 2, 8, 9, 10])',
                'plt.IndexLocator(3, 1)',
                'plt.LinearLocator(5)',
                'plt.LogLocator(2, [1.0])',
                'plt.AutoLocator()',
            ]

n_locators = len(locators)

size = (512, 40 * n_locators)
dpi = 75.0
figsize = (size[0] / dpi, size[1] / dpi)
fig = plt.figure(figsize=figsize, dpi=dpi)

for i, locator in enumerate(locators):
    plt.subplot(n_locators, 1, i + 1)
    ax = tickline()
    ax.xaxis.set_major_locator(eval(locator))
    plt.text(5, 0.3, locator[3:], ha='center')

plt.subplots_adjust(bottom=.01, top=.99,
                    left=.01, right=.99)
plt.show()

2.5 Bar plot

plt.figure(figsize=(8, 6), dpi=80)
n = 15
X = np.arange(n)
Y1 = (1 - X / float(n)) * np.random.uniform(0.5, 1.0, n)
Y2 = (1 - X / float(n)) * np.random.uniform(0.5, 1.0, n)

plt.bar(X, +Y1, facecolor='#9999ff', edgecolor='white')
plt.bar(X, -Y2, facecolor='#ff9999', edgecolor='white')

for x, y in zip(X, Y1):
    plt.text(x, y + 0.05, '%.2f' % y,
             ha='center', va='bottom')
for x, y in zip(X, Y2):
    plt.text(x, -y - 0.10, '%.2f' % y,
             ha='center', va='bottom')

plt.ylim(-1.25, +1.25)
plt.xticks(())
plt.yticks(())
plt.show()

2.6 Scatter plot

plt.figure(figsize=(8, 8), dpi=80)
n = 1024
X = np.random.random(n) * 2.0 - 1.0
Y = np.random.random(n) * 2.0 - 1.0
T = (X**2 + Y**2)**0.5 < 1.0
#T = np.arctan2(Y, X)

#plt.axes([0.025, 0.025, 0.95, 0.95])
plt.scatter(X, Y, s=75, c=T, alpha=.5)

plt.xlim(-1.1, 1.1)
plt.xticks(())
plt.ylim(-1.1, 1.1)
plt.yticks(())

plt.show()

2.7 Contour plot

plt.figure(figsize=(8, 6), dpi=80)

def f(x, y):
    return (1 - x / 2 + x ** 5 + y ** 3) * \
           np.exp(-x ** 2 -y ** 2)

n = 256
x = np.linspace(-3, 3, n)
y = np.linspace(-3, 3, n)
X, Y = np.meshgrid(x, y)

plt.contourf(X, Y, f(X, Y), 8, alpha=.75, cmap='jet')
C = plt.contour(X, Y, f(X, Y), 8, colors='black')

2.8 Imshow

plt.figure(figsize=(12, 8), dpi=50)

def f(x, y):
    return (1 - x / 2 + x ** 5 + y ** 3) * \
           np.exp(-x ** 2 -y ** 2)

nx, ny = 40, 30
x = np.linspace(-3, 3, nx)
y = np.linspace(-3, 3, ny)
X, Y = np.meshgrid(x, y)
Z = f(X, Y)


plt.axes([0.025, 0.025, 0.95, 0.95])
plt.imshow(Z, interpolation='nearest',
           cmap=plt.cm.gist_gray, origin='lower')
plt.colorbar(shrink=0.92)

plt.xticks(())
plt.yticks(())
plt.show()

2.9 Polar

plt.figure(figsize=(8, 8), dpi=60)

ax = plt.axes([0.025, 0.025, 0.95, 0.95], polar=True)

N = 20
theta = np.arange(0, 2 * np.pi, 2 * np.pi / N)
radii = 10 * np.random.rand(N)
width = np.pi / 4 * np.random.rand(N)
bars = plt.bar(theta, radii, width=width, bottom=0.0)

for r, bar in zip(radii, bars):
    bar.set_facecolor(plt.cm.jet(r/10.))
    bar.set_alpha(0.5)

ax.set_xticklabels([])
ax.set_yticklabels([])
plt.show()

2.10 Pie chart

fig = plt.figure(figsize=(10, 10), dpi=60)
ax = plt.axes()


size = 0.3
vals = np.array([[60., 32.], [37., 40.], [29., 10.]])

cmap = plt.get_cmap("tab20c")
outer_colors = cmap(np.arange(3)*4)
inner_colors = cmap(np.array([1, 2, 5, 6, 9, 10]))

ax.pie(vals.sum(axis=1), radius=1, colors=outer_colors,
       wedgeprops=dict(width=size, edgecolor='w'))

ax.pie(vals.flatten(), radius=1-size, colors=inner_colors,
       wedgeprops=dict(width=size, edgecolor='w'))

ax.set(aspect="equal", title='Pie plot with `ax.pie`')
plt.show()

2.11 3D plot

from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure(dpi=80)
ax = Axes3D(fig)
X = np.arange(-5, 5, 0.25)
Y = np.arange(-5, 5, 0.25)
X, Y = np.meshgrid(X, Y)
R = np.sqrt(X**2 + Y**2)
Z = np.sin(R)

ax.plot_surface(X, Y, Z, rstride=1, cstride=1,
                cmap=plt.cm.hot)
ax.contourf(X, Y, Z, zdir='z', offset=-2,
            cmap=plt.cm.hot)
ax.set_zlim(-2, 2)
plt.show()

3 Glossaire

3.1 Quelques termes :

3.1.1 Figure

Objet de niveau supérieur qui contient tout ce qui peut être graphé.

3.1.2 Axes

Surface sur laquelle on peut grapher quelque chose. Il est possible de placer un Axes à n’importe quelle position.

3.1.3 Axis

Classe de base pour XAxis et YAxis qui sont les deux axes d’un graphique (abscisse et ordonnée).

3.1.4 Subplot

Moyen de diviser la surface de dessin en sous-graphes. Cela se fait verticalement ou horizontalement ou avec des combinaisons.

3.1.5 Ticks

Indicateur de position le long d’un Axis.

3.2 plt.plot() ax.plot()

Manuel Matplotlib : plt.plot()
Manuel Matplotlib : ax.plot()

plot([x], y, [fmt], *, data=None, **kwargs)
plot([x], y, [fmt], [x2], y2, [fmt2], ..., **kwargs)

Trace les lignes de y en fonction de x (ou avec des marqueurs)

• x : array des coordonnées X
  (optionnel. Si omis, alors x sera un indexe de 0..N-1)
• y : array des coordonnées Y
• label : str chaîne de légende (nécessite que la légende soit ensuite affichée avec plt.legend())
• fmt : str optionnel décrivant le formattage
• color : str optionnel décrivant la couleur. Plusieurs formats possibles décrits ici : Manuel Matplotlib : Specifying Colors

3.3 Chaîne de formatage

La chaîne de formatage consiste en un str contenant des informations sur le marqueur, la ligne et la couleur.

fmt = '[marker][line][color]'

• marker

• line

• color

3.4 plt.show()

Manuel Matplotlib : plt.show()

show()

Affiche la figure.

Dans le cas d’une exécution avec le noyau ipython (utilisé par Jupyter), l’exécution rend immédiatement la main pour une nouvelle instruction. Dans le cas contraire (script *.py), l’exécution est suspendue, tant que la figure est ouverte. Ceci permet à l’utilisateur de travailler avec cette figure, sans que l’exécution ne s’arrête immédiatement.

3.5 plt.savefig()

Manuel Matplotlib : plt.savefig()

savefig(filename, transparent=False)

Sauve la figure dans un fichier image.

• filename : str Nom du fichier dans lequel la figure doit être sauvée
• transparent : boolean (default: False) Indique si le fond doit être transparent

Utile lorsqu’on souhaite sauver une ou des figures sans interaction avec l’utilisateur dans des fichiers image. Les formats supportés peuvent dépendre

3.6 plt.title()

Manuel Matplotlib : plt.title()

plt.title(label, fontdict=None, loc='center', pad=None, **kwargs)

Ajoute un titre

• label : str
  Texte du titre
• fontdict : dict optionel, définissant l’apparence du titre
  Par défaut :
  

{
  'fontsize': rcParams['axes.titlesize'],
  'fontweight': rcParams['axes.titleweight'],
  'verticalalignment': 'baseline',
  'horizontalalignment': loc
}

• loc : str optionnel, parmi (‘center’, ‘left’, ‘right’)
  par défaut : ‘center’
  Définit l’emplacement du titre.

Il est également possible de définit le titre sur un Axes avec la méthode :

ax.set_title(label, fontdict=None, loc='center', pad=None, **kwargs)

Manuel Matplotlib : ax.set_title()

3.7 plt.legend()

Manuel Matplotlib : plt.legend()

legend(*args, **kwargs)

Place la légende sur l’axe. Il est conseillé, avant, d’avoir fourni l’argument label='inline label' pour chaque élément graphé pour lequel nous souhaitons avec une légende. Ainsi l’appel à plt.legend() peut se faire sans argument.

• loc : str parmi (‘best’, ‘upper right’, ‘upper left’, ‘lower left’, ‘lower right’, ‘right’, ‘center left’, ‘center right’, ‘lower center’, ‘upper center’, ‘center’)
  Localisation de la légende. (default : ‘best’)

3.8 plt.figure()

Manuel Matplotlib : plt.figure()

figure([num], [figsize], [dpi], [facecolor], [edgecolor], [clear])

Créée une nouvelle figure.

• num : int ou str ou None (default: None)
  • S’il n’est pas donné, alors une nouvelle figure est créée et le numéro de figure est incrémenté.
  • Sinon si num est le numéro d’une figure déjà active, alors celle-ci est rendue active et la fonction retourne une référence sur celle-ci.
  • Si num est un str, alors il définit le titre de la fenêtre contenant cette figure.
• figsize : (float, float) ou None (default: None)
  largeur et hauteur de la figure (en pouces)
• dpi : int ou None (default: None)
  Nombre de pixels par pouce
• facecolor : color (default: ‘white’)
  Couleur de fond
• edgecolor : color (default: ‘white’)
  Couleur des bords
• clear : boolean (default: False)
  Si True, alors la figure est effacée (si elle existe déjà)

Retourne l’objet d’instance de la figure.

3.9 plt.subplot()

Manuel Matplotlib : plt.subplot()

subplot(nrows, ncols, index, projection=None, polar=False)
subplot(pos, projection=None, polar=False)

Créée une nouvelle figure.

• nrows : int
  Nombre de lignes
• ncols : int Nombre de colonnes
• index : int Indexe de l’objet Axes sélectioné.
  On compte à partir de 1, de gauche à droite, puis de haut en bas.
• pos : int
  Entier qui regroupe nrows, ncols et index (sachant qu’aucun peut être plus grand que 9)
• projection : str (default: None -> ‘rectilinear’)
  Projection de l’Axes, parmi : None, ‘aitoff’, ‘hammer’, ‘lambert’, ‘mollweide’, ‘polar’ et ‘rectilinear’.
• polar : boolean (default: False)
  Raccourcis pour définir une projection de type polar.

Retourne l’objet Axes du subplot sélectionné

3.10 fig.subplots()

Manuel Matplotlib : fig.subplot()

[...] = fig.subplots(nrows, ncols, sharex=False, sharey=False)

Ajoute un jeu de subplots à la figure courante et retourne les Axes créés pour ceux-ci.

• nrows : int
  Nombre de lignes
• ncols : int
  Nombre de colonnes
• sharex : boolean
  Indique si les sous-graphs doivent partager un même axis X
• sharey : boolean
  Indique si les sous-graphs doivent partager un même axis Y

Retourne une liste des objets Axes des subplots créés sur la figure

3.11 plt.text() ax.text() figure.text()

Manuel Matplotlib : plt.text()
Manuel Matplotlib : ax.text()
Manuel Matplotlib : figure.text()

text(x, y, s, **kwargs)

Écrit le texte à l’emplacement définit

• x : int
  Coordonnée X
• y : int
  Coordonnée Y
• s : str
  Le texte
• fontsize ou size : int ou str
  Taille du texte
  str parmi (‘xx-small’, ‘x-small’, ‘small’, ‘medium’, ‘large’, ‘x-large’, ‘xx-large’)
• fontweight ou weight : int ou str “poids” du texte
  int entre 0 et 1000
  str parmi (‘ultralight’, ‘light’, ‘normal’, ‘regular’, ‘book’, ‘medium’, ‘roman’, ‘semibold’, ‘demibold’, ‘demi’, ‘bold’, ‘heavy’, ‘extra bold’, ‘black’)
• verticalalignment ou va : str
  Alignement vertical. choix parmi (‘center’, ‘top’, ‘bottom’, ‘baseline’, ‘center_baseline’)
• horizontalalignment ou ha : str
  Alignement horizontal. choix parmi (‘center’, ‘right’, ‘left’)
• rotation : float ou str
  angle de rotation en degrés ou parmi (‘vertical’, ‘horizontal’)
• alpha : float
  transparence (0.0 pour transparent, 1.0 pour opaque)

3.12 plt.tight_layout() figure.tight_layout()

Manuel Matplotlib : plt.tight_layout()
Manuel Matplotlib : figure.tight_layout()

tight_layout(pad=1.08, h_pad=None, w_pad=None, rect=None)

Ajuste les espacements entre les subplots

• pad : float (defaut: 1.08)
  espacement entre les bords de la figure et ceux des subplots (en fraction de font size)
• h_pad et w_pad : float (defaut: idem que pad)
  espacement entre les bords des différents subplots (en fraction de font size)

3.13 plt.axes()

Manuel Matplotlib : plt.axes()

axes(rect, projection=None, polar=False, **kwargs)
axes(ax)

Ajoute un Axes à la figure courante et le rend actif.

• rect : 4-tuple float (left, bottom, width, height)
  Rectangle décrivant la surface du nouvel Axes
• projection : str (default: None -> ‘rectilinear’)
  Projection de l’Axes, parmi : None, ‘aitoff’, ‘hammer’, ‘lambert’, ‘mollweide’, ‘polar’ et ‘rectilinear’.
• polar : boolean (default: False)
  Raccourcis pour définir une projection de type polar.
• ax : Axes
  Équivalent à plt.sca(ax), définit l’Axes courant à celui fourni par l’objet ax.

Retourne un objet de type Axes ou une sous-classe.

3.14 plt.gca()

Manuel Matplotlib : plt.gca()

gca()

GCA comme «Get Current Axes»
Retourne l’objet Axes courant. Utile lorsqu’on souhaite agir directement dessus.

3.15 plt.xticks() et plt.yticks() ax.set_xticks ax.set_yticks ax.set_xticklabels ax.set_yticklabels …

Manuel Matplotlib : plt.xticks()
Manuel Matplotlib : plt.yticks()

locs, labels = plt.xticks()                   # obtient la position et les labels
plt.xticks(ticks=None, labels=None, **kwargs) # définit la position et les labels

Obtient ou définit la position et les labels des ticks sur l’axe X et Y.

• ticks : array like
  Liste des positions où les ticks doivent être positionnés.
  Si vide, alors désactivation des ticks.
• labels : array like
  Liste explicite des labels à placer aux positions données.
  Si vide, alors la valeur de la position est utilisée. Note:
  • pour utiliser le formatage \(\LaTeX\) dans les labels, il vous faut entourer l’expression par le symbole $.
  • pour afficher le symbole plutôt que le texte du symbole, il vous faut le saisir selon les règles \(\LaTeX\). Une liste des symboles mathématiques est disponible ici : Wikipedia LaTeX symbols.
• kwargs :
  Les attributs de texte peuvent être ajoutés pour contrôler l’apparence des labels.

Retourne un tuple (locs, labels)

• locs : array like
  Liste des positions des ticks
• labels : array like
  Liste d’objets Text contenant les labels

L’équivalent peut être fait sur un Axes avec :

ax.set_xticks(self, ticks, minor=False)
ax.set_yticks(self, ticks, minor=False)
ax.set_xticklabels(self, labels, fontdict=None, minor=False, **kwargs)
ax.set_yticklabels(self, labels, fontdict=None, minor=False, **kwargs)

loc = ax.get_xticks(self, minor=False)
loc = ax.get_yticks(self, minor=False)
labels = ax.get_xticklabels(self, minor=False, which=None)
labels = ax.get_yticklabels(self, minor=False, which=None)

Manuel Matplotlib : ax.set_xticks()
Manuel Matplotlib : ax.set_xticklabels()
Manuel Matplotlib : ax.get_xticks()
Manuel Matplotlib : ax.get_xticklabels()

3.16 fig.autofmt_xdate()

Manuel Matplotlib : fig.autofmt_xdate()

fig.autofmt_xdate()

Lorsque l’axis des X est rempli de dates, les ticks labels se chevauchent facilement. L’appel de cette méthode formate automatiquemnt les ticks de sorte qu’ils soient inclinés à 45° et aient un bon alignement.

3.17 plt.xlim() plt.ylim() ax.xlim() ax.ylim()

Manuel Matplotlib : plt.xlim()
Manuel Matplotlib : plt.ylim()

left, right = plt.xlim()
plt.xlim(left, right)
bottom, top = plt.ylim()
plt.ylim(bottom, top)

Obtient ou définit les limites sur l’Axis X, respectivement Y

• left, right, bottom, top : valeurs limites dans les 4 extrèmes

L’équivalent peut être fait sur un Axes avec :

ax.set_xlim(left, right)
left, right = ax.get_xlim()

ax.set_ylim(bottom, top)
bottom, top = ax.get_ylim()

Manuel Matplotlib : ax.set_xlim()
Manuel Matplotlib : ax.get_xlim()
Manuel Matplotlib : ax.set_ylim()
Manuel Matplotlib : ax.get_ylim()

3.18 plt.grid() ax.grid()

Manuel Matplotlib : plt.grid()
Manuel Matplotlib : ax.grid()

grid(b=None, which='major', axis='both', **kwargs)

Active ou désactive la grille, principale ou secondaire sur l’axe désiré.

• b : boolean
  True -> active ou False -> désactive la grille
• which : str
  Parmi (‘major’, ‘minor’, ‘both’)
  Quelle grille activer/désactiver
• axis : array like
  Parmi (‘both’, ‘x’, ‘y’)
  Sur quel axe ‘activer’
• kwargs :
  Les attributs de la ligne peuvent être ajoutés pour contrôler l’apparence des grilles.
  https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.lines.Line2D.html#matplotlib.lines.Line2D

3.19 ax.set_xlabel(), ax.set_ylabel(), ax.set_zlabel()

Manuel Matplotlib : ax.set_xlabel
Manuel Matplotlib : ax.set_ylabel
Manuel Matplotlib : ax.set_zlabel

ax.set_xlabel(self, xlabel, labelpad=None, **kwargs)
ax.set_ylabel(self, ylabel, labelpad=None, **kwargs)
ax.set_zlabel(self, zlabel, labelpad=None, **kwargs)

Définit le label de l’axe X, Y, respectivement Z.

• xlabel, ylabel, zlabel : str
  Texte du label
• kwargs
  Propriétés pour définir l’apparence du texte

3.20 plt.bar() ax.bar()

Manuel Matplotlib : plt.bar()
Manuel Matplotlib : ax.bar()

bar(x, height, width=0.8, bottom=None, *, align='center', data=None, **kwargs)

Trace un graphe composé de barres verticales

• x : séquence de scalaires coordonnées des barres
• height : scalaire ou séquence de scalaires hauteur de chaque barre
• width : scalaire ou array largeur de chaque barre
• bottom : scalaire ou array hauteur de la base de chaque barre
• align : 'center' ou 'edge' alignement sur l’axe X centré ou aligné à gauche.
  Pour aligner à droite, donner une valeur négative à width
• kwargs :
  arguments supplémentaires permettant de définir d’autres paramètres, parmi :
• color : color ou array de color
  Couleur de chaque bar
• edgecolor : color ou array de color
  Couleur de contour de chaque bar
• linewidth : scalaire ou array de scalaire largeur en pixels du contour
• xerr et yerr : scalaire ou array erreur en X et Y
  • avec un scalaire, définit l’erreur ‘+/-’ pour toutes les barres
  • avec un array de géométrie(N), défnit les l’erreur ‘+/-’ pour chaque barre
  • avec un array de géométrie(2, N), défnit les l’erreur ‘+’ et l’erreur ‘-’ pour chaque barre.

3.21 plt.fill_between() ax.fill_between()

Manuel Matplotlib : plt.fill_between()
Manuel Matplotlib : ax.fill_between()

plt.fill_between(x, y1, y2, where, **kwargs)

Color une surface entre y1 et y2 en fonction de x, où where est True

• x : array
  des coordonnées X
• y1 : array
  des coordonnées Y de la limite inférieure
• y2 : array
  des coordonnées Y de la limite supérieure
• where : array de boolean Permet de choisir les positions où colorier et où pas
• facecolor : str optionnel décrivant la couleur. Plusieurs formats possibles décrits ici : Manuel Matplotlib : Specifying Colors
• alpha : float transparence (0.0 pour transparent, 1.0 pour opaque)

3.22 plt.scatter() ax.scatter()

Manuel Matplotlib : plt.scatter()
Manuel Matplotlib : ax.scatter()

scatter(x, y, s=None, c=None, marker=None,
        cmap=None, norm=None, vmin=None, vmax=None,
        alpha=None, linewidths=None, verts=None,
        edgecolors=None, *, plotnonfinite=False,
        data=None, **kwargs)

Graphe de nuage de points aux coordonnées fixées avec différents marqueurs, tailles et/ou couleurs

• x et y : array de longueur n
  position des points
• s : scalaire ou array de longueur n (optionnel)
  taille des points
• c : couleur, séquence ou séquence de couleurs (optionnel)
  • couleur unique
  • séquence de couleurs de longueur n
  • séquence de n nombres correspondants aux couleurs à utiliser fourni par cmap et norm
• marker : str ou array de str décrivant les marqueurs
• cmap : carte de couleurs à utiliser. La référence de ces cartes de couleurs peut être consultée ici.
• alpha : opacité de chaque point (0: transparent, 1: opaque)

3.23 Colormaps

Manuel Matplotlib : Colormap reference

Chaque élément graphé peut être non-seulement positionné selon des axes (X, Y et Z), mais peut également être enrichit avec une couleur prise dans une table de couleurs indiquant ainsi une information supplémentaire. Ainsi un graph 2-D pourra devenir un graph dit 2-D et demi, un graph 3-D pourra devenir un graph dit 4-D.

Les colormaps à disposition peuvent être consultés en ligne ici : https://matplotlib.org/3.1.1/gallery/color/colormap_reference.html

3.24 plt.colorbar() fig.colorbar()

Manuel Matplotlib : plt.colorbar()
Manuel Matplotlib : fig.colorbar()

colorbar(**kwargs)
colorbar(mappable, **kwargs)
colorbar(mappable, cax=cax, **kwargs)
colorbar(mappable, ax=ax, **kwargs)

Ajoute l’affichage du Colormap à côté du graph.

3.25 ax.set_aspect()

Manuel Matplotlib : ax.set_aspect()

set_aspect(self, aspect, adjustable=None, anchor=None, share=False)¶

Définit l’aspect (ratio y/x) de l’Axes

• aspect : str ou num
  • str parmi :
    • ‘auto’ remplissage automatique
    • ‘equal’ ratio de 1 entre les 2 axis x et y
  • num définit le ratio tel que y est num x plus haut que x.

3.26 plt.pcolormesh() ax.pcolormesh()

Manuel Matplotlib : plt.pcolormesh()
Manuel Matplotlib : ax.pcolormesh()

pcolormesh([X, Y,] C, **kwargs)

Dessine l’image ou les données représentés par l’array 2-D.

• X et Y : array (optionnels)
  les coordonnées des valeurs données par Z
  Ils doivent être des 2-D array de même dimension que Z (typiquement créé par np.meshgrid), ou chacun des 1-D array avec len(X) == M et len(Y) == N
  par défaut ils valent X = range(M) et Y = range(N) M et N représentent les lignes et colonnes de l’image

• C : 2-D array de dimension (N, M)
  les valeurs qui seront prises du colormap

• cmap : carte de couleurs à utiliser

3.27 plt.contour() ax.contour()

Manuel Matplotlib : plt.contour()
Manuel Matplotlib : ax.contour()

contour([X, Y,] Z, [levels], **kwargs)

Dessine un graphe de contour.

• X et Y : array (optionnels)
  les coordonnées des valeurs données par Z
  Ils doivent être des 2-D array de même dimension que Z (typiquement créé par np.meshgrid), ou chacun des 1-D array avec len(X) == M et len(Y) == N
  par défaut ils valent X = range(M) et Y = range(N)
• Z : 2-D array de dimension (N, M)
  les hauteurs sur lesquelles le contour est dessiné
• levels : int ou array (optionnel)
  Indique le nombre de positions des contours.
  • Avec un int n, définit n intervalles (dessine n+1 lignes de contour). La hauteur de chaque niveau est automatiquement calculée.
  • Avec un array, dessine les lignes de contour à chaque niveau donné. Les valeurs doivent être données de la plus petite à la plus grande.

3.28 plt.imshow() ax.imshow()

Manuel Matplotlib : plt.imshow()
Manuel Matplotlib : ax.imshow()

imshow(X, cmap=None, norm=None, aspect=None, interpolation=None,
       alpha=None, vmin=None, vmax=None, origin=None, extent=None,
       shape=<deprecated parameter>, filternorm=1, filterrad=4.0,
       imlim=<deprecated parameter>, resample=None, url=None, *,
       data=None, **kwargs)

Dessine l’image ou les données représentés par l’array 2-D.

• X : array ou PIL image
  données de l’image. Les formats supportés sont pour les dimensions suivantes :
  • (M, N) : une image décrite par des scalaires et rendue à travers une carte de couleurs
  • (M, N, 3) : une image en RGB (valeurs réelles [0-1] ou entières [0-255])
  • (M, N, 4) : une image en RGBA (valeurs réelles [0-1] ou entières [0-255]) plus la transparence M et N représentent les lignes et colonnes de l’image
    hors des plage [0-1] et [0-255], les valeurs sont limitées à la valeur max.
• cmap : carte de couleurs à utiliser

3.29 ax.plot_surface()

Manuel Matplotlib : ax.plot_surface()

plot_surface(self, X, Y, Z, *args,
             norm=None, vmin=None, vmax=None, lightsource=None, **kwargs)

Dessine un graph de surface 3-D

• X, Y, Z : 2-D array
  Données à grapher
• cmap : carte de couleurs à utiliser

Samuel Bancal, EPFL, ENAC-IT (2019-2020)