Tutoriel Pyplot

Une introduction à l'interface pyplot. Veuillez également consulter le guide de démarrage rapide pour un aperçu du fonctionnement de Matplotlib et les interfaces d'application (API) de Matplotlib pour une explication des compromis entre les API utilisateur prises en charge.

Introduction à pyplot

matplotlib.pyplotest une collection de fonctions qui font fonctionner matplotlib comme MATLAB. Chaque pyplotfonction apporte des modifications à une figure : par exemple, crée une figure, crée une zone de traçage dans une figure, trace des lignes dans une zone de traçage, décore le tracé avec des étiquettes, etc.

Dans matplotlib.pyplotdivers états sont conservés à travers les appels de fonction, de sorte qu'il garde une trace de choses comme la figure actuelle et la zone de traçage, et les fonctions de traçage sont dirigées vers les axes actuels (veuillez noter que les "axes" ici et dans la plupart des endroits de la documentation se réfèrent à la partie des axes d'une figure et non au terme mathématique strict pour plus d'un axe).

Noter

l'API pyplot implicite est généralement moins détaillée mais pas aussi flexible que l'API explicite. La plupart des appels de fonction que vous voyez ici peuvent également être appelés en tant que méthodes à partir d'un Axesobjet. Nous vous recommandons de parcourir les didacticiels et les exemples pour voir comment cela fonctionne. Voir Matplotlib Application Interfaces (APIs) pour une explication du compromis des API utilisateur prises en charge.

Générer des visualisations avec pyplot est très rapide :

import matplotlib.pyplot as plt
plt.plot([1, 2, 3, 4])
plt.ylabel('some numbers')
plt.show()

Vous vous demandez peut-être pourquoi l'axe des x va de 0 à 3 et l'axe des y de 1 à 4. Si vous fournissez une liste ou un tableau unique à plot, matplotlib suppose qu'il s'agit d'une séquence de valeurs y et génère automatiquement les valeurs x pour vous. Étant donné que les plages python commencent par 0, le vecteur x par défaut a la même longueur que y mais commence par 0. Par conséquent, les données x sont .[0, 1, 2, 3]

plotest une fonction polyvalente, et prendra un nombre arbitraire d'arguments. Par exemple, pour tracer x en fonction de y, vous pouvez écrire :

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

[<matplotlib.lines.Line2D object at 0x7f2cf9d23b20>]

Formater le style de votre tracé

Pour chaque paire d'arguments x, y, il existe un troisième argument facultatif qui est la chaîne de format qui indique la couleur et le type de ligne du tracé. Les lettres et les symboles de la chaîne de format proviennent de MATLAB et vous concaténez une chaîne de couleur avec une chaîne de style de ligne. La chaîne de format par défaut est 'b-', qui est une ligne bleue continue. Par exemple, pour tracer ce qui précède avec des cercles rouges, vous émettez

plt.plot([1, 2, 3, 4], [1, 4, 9, 16], 'ro')
plt.axis([0, 6, 0, 20])
plt.show()

Consultez la plotdocumentation pour une liste complète des styles de ligne et des chaînes de format. La axisfonction dans l'exemple ci-dessus prend une liste et spécifie la fenêtre d'affichage des axes.[xmin, xmax, ymin, ymax]

Si matplotlib se limitait à travailler avec des listes, il serait assez inutile pour le traitement numérique. Généralement, vous utiliserez des tableaux numpy . En fait, toutes les séquences sont converties en tableaux numpy en interne. L'exemple ci-dessous illustre le traçage de plusieurs lignes avec différents styles de format dans un appel de fonction à l'aide de tableaux.

import numpy as np

# evenly sampled time at 200ms intervals
t = np.arange(0., 5., 0.2)

# red dashes, blue squares and green triangles
plt.plot(t, t, 'r--', t, t**2, 'bs', t, t**3, 'g^')
plt.show()

Tracé avec des chaînes de mots-clés

Dans certains cas, vous avez des données dans un format qui vous permet d'accéder à des variables particulières avec des chaînes. Par exemple, avec numpy.recarrayou pandas.DataFrame.

Matplotlib vous permet de fournir un tel objet avec l' dataargument du mot-clé. Si elles sont fournies, vous pouvez générer des graphiques avec les chaînes correspondant à ces variables.

data = {'a': np.arange(50),
        'c': np.random.randint(0, 50, 50),
        'd': np.random.randn(50)}
data['b'] = data['a'] + 10 * np.random.randn(50)
data['d'] = np.abs(data['d']) * 100

plt.scatter('a', 'b', c='c', s='d', data=data)
plt.xlabel('entry a')
plt.ylabel('entry b')
plt.show()

Tracé avec des variables catégorielles

Il est également possible de créer un graphique à l'aide de variables catégorielles. Matplotlib vous permet de passer des variables catégorielles directement à de nombreuses fonctions de traçage. Par exemple:

names = ['group_a', 'group_b', 'group_c']
values = [1, 10, 100]

plt.figure(figsize=(9, 3))

plt.subplot(131)
plt.bar(names, values)
plt.subplot(132)
plt.scatter(names, values)
plt.subplot(133)
plt.plot(names, values)
plt.suptitle('Categorical Plotting')
plt.show()

Contrôle des propriétés de ligne

Les lignes ont de nombreux attributs que vous pouvez définir : largeur de ligne, style de tiret, anticrénelage, etc. ; voir matplotlib.lines.Line2D. Il existe plusieurs façons de définir les propriétés de ligne

• Utilisez des arguments de mots clés :

  plt.plot(x, y, linewidth=2.0)
  

• Utilisez les méthodes setter d'une Line2Dinstance. plotrenvoie une liste d' Line2Dobjets ; par exemple, . Dans le code ci-dessous, nous supposerons que nous n'avons qu'une seule ligne pour que la liste renvoyée soit de longueur 1. Nous utilisons le déballage de tuple avec pour obtenir le premier élément de cette liste :line1, line2 = plot(x1, y1, x2, y2)line,

  line, = plt.plot(x, y, '-')
  line.set_antialiased(False) # turn off antialiasing
  

• Utilisez setp. L'exemple ci-dessous utilise une fonction de style MATLAB pour définir plusieurs propriétés sur une liste de lignes. setpfonctionne de manière transparente avec une liste d'objets ou un seul objet. Vous pouvez soit utiliser des arguments de mot-clé python, soit des paires chaîne/valeur de style MATLAB :

  lines = plt.plot(x1, y1, x2, y2)
  # use keyword arguments
  plt.setp(lines, color='r', linewidth=2.0)
  # or MATLAB style string value pairs
  plt.setp(lines, 'color', 'r', 'linewidth', 2.0)
  

Voici les Line2Dpropriétés disponibles.

Propriété	Type de valeur
alpha	flotteur
Animé	[Vrai | Faux]
anticrénelé ou aa	[Vrai | Faux]
clip_box	une instance matplotlib.transform.Bbox
clip_on	[Vrai | Faux]
clip_path	une instance Path et une instance Transform, un Patch
couleur ou c	n'importe quelle couleur matplotlib
contient	la fonction de test de réussite
dash_capstyle	[ 'butt'| 'round'| 'projecting']
dash_joinstyle	[ 'miter'| 'round'| 'bevel']
tirets	séquence d'encre marche/arrêt en points
Les données	(np.array xdata, np.array ydata)
chiffre	une instance matplotlib.figure.Figure
étiquette	n'importe quelle chaîne
style de ligne ou ls	[ '-'| '--'| '-.'| ':'| 'steps'| ...]
largeur de ligne ou lw	valeur flottante en points
marqueur	[ '+'| ','| '.'| '1'| '2'| '3'| '4']
markeredgecolor ou mec	n'importe quelle couleur matplotlib
markeredgewidth ou mew	valeur flottante en points
markerfacecolor ou mfc	n'importe quelle couleur matplotlib
taille du marqueur ou ms	flotteur
marque chaque	[ Aucun | entier | (démarrage, foulée) ]
cueilleur	utilisé dans la sélection de ligne interactive
rayon de sélection	le rayon de sélection de sélection de ligne
solid_capstyle	[ 'butt'| 'round'| 'projecting']
solid_joinstyle	[ 'miter'| 'round'| 'bevel']
transformer	une instance matplotlib.transforms.Transform
visible	[Vrai | Faux]
xdata	np.array
ydata	np.array
zorder	n'importe quel chiffre

Pour obtenir une liste des propriétés de ligne configurables, appelez la setpfonction avec une ligne ou des lignes comme argument

In [69]: lines = plt.plot([1, 2, 3])

In [70]: plt.setp(lines)
  alpha: float
  animated: [True | False]
  antialiased or aa: [True | False]
  ...snip

Travailler avec plusieurs figures et axes

MATLAB, et pyplot, ont le concept de la figure courante et des axes courants. Toutes les fonctions de traçage s'appliquent aux axes actuels. La fonction gcarenvoie les axes actuels (une matplotlib.axes.Axesinstance) et gcfrenvoie la figure actuelle (une matplotlib.figure.Figureinstance). Normalement, vous n'avez pas à vous en soucier, car tout est pris en charge dans les coulisses. Vous trouverez ci-dessous un script pour créer deux sous-parcelles.

def f(t):
    return np.exp(-t) * np.cos(2*np.pi*t)

t1 = np.arange(0.0, 5.0, 0.1)
t2 = np.arange(0.0, 5.0, 0.02)

plt.figure()
plt.subplot(211)
plt.plot(t1, f(t1), 'bo', t2, f(t2), 'k')

plt.subplot(212)
plt.plot(t2, np.cos(2*np.pi*t2), 'r--')
plt.show()

L' figureappel ici est facultatif car une figure sera créée s'il n'en existe pas, de même qu'un Axe sera créé (équivalent à un subplot()appel explicite) s'il n'en existe pas. L' subplotappel spécifie où va de 1 à . Les virgules dans l' appel sont facultatives si . Donc est identique à .numrows, numcols, plot_numberplot_numbernumrows*numcolssubplotnumrows*numcols<10subplot(211)subplot(2, 1, 1)

Vous pouvez créer un nombre arbitraire de sous-parcelles et d'axes. Si vous souhaitez placer un Axe manuellement, c'est-à-dire pas sur une grille rectangulaire, utilisez axes, qui vous permet de spécifier l'emplacement où toutes les valeurs sont en coordonnées fractionnaires (0 à 1). Voir Axes Demo pour un exemple de placement manuel des axes et Plusieurs sous-parcelles pour un exemple avec beaucoup de sous-parcelles.axes([left, bottom, width, height])

Vous pouvez créer plusieurs figures en utilisant plusieurs figureappels avec un numéro de figure croissant. Bien sûr, chaque figure peut contenir autant d'axes et de sous-parcelles que votre cœur le souhaite :

import matplotlib.pyplot as plt
plt.figure(1)                # the first figure
plt.subplot(211)             # the first subplot in the first figure
plt.plot([1, 2, 3])
plt.subplot(212)             # the second subplot in the first figure
plt.plot([4, 5, 6])


plt.figure(2)                # a second figure
plt.plot([4, 5, 6])          # creates a subplot() by default

plt.figure(1)                # figure 1 current; subplot(212) still current
plt.subplot(211)             # make subplot(211) in figure1 current
plt.title('Easy as 1, 2, 3') # subplot 211 title

Vous pouvez effacer la figure actuelle avec clf et les axes actuels avec cla. Si vous trouvez ennuyeux que des états (en particulier l'image, la figure et les axes actuels) soient maintenus pour vous dans les coulisses, ne désespérez pas : il ne s'agit que d'un mince wrapper avec état autour d'une API orientée objet, que vous pouvez utiliser à la place. (voir tutoriel de l'artiste )

Si vous faites beaucoup de figures, vous devez être conscient d'une dernière chose : la mémoire requise pour une figure n'est pas complètement libérée tant que la figure n'est pas explicitement fermée avec close. Supprimer toutes les références à la figure et/ou utiliser le gestionnaire de fenêtres pour tuer la fenêtre dans laquelle la figure apparaît à l'écran ne suffit pas, car pyplot conserve les références internes jusqu'à ce qu'il close soit appelé.

Travailler avec du texte

textpeuvent être utilisés pour ajouter du texte à un emplacement arbitraire, et xlabel, ylabelet titlesont utilisés pour ajouter du texte aux emplacements indiqués (voir Texte dans les tracés Matplotlib pour un exemple plus détaillé)

mu, sigma = 100, 15
x = mu + sigma * np.random.randn(10000)

# the histogram of the data
n, bins, patches = plt.hist(x, 50, density=True, facecolor='g', alpha=0.75)


plt.xlabel('Smarts')
plt.ylabel('Probability')
plt.title('Histogram of IQ')
plt.text(60, .025, r'$\mu=100,\ \sigma=15$')
plt.axis([40, 160, 0, 0.03])
plt.grid(True)
plt.show()

Toutes les textfonctions renvoient une matplotlib.text.Text instance. Tout comme avec les lignes ci-dessus, vous pouvez personnaliser les propriétés en passant des arguments de mots-clés dans les fonctions de texte ou en utilisant setp:

t = plt.xlabel('my data', fontsize=14, color='red')

Ces propriétés sont décrites plus en détail dans Propriétés et disposition du texte .

Utilisation d'expressions mathématiques dans le texte

matplotlib accepte les expressions d'équation TeX dans n'importe quelle expression de texte. Par exemple pour écrire l'expression\(\sigma_i=15\)dans le titre, vous pouvez écrire une expression TeX entourée de signes dollar :

plt.title(r'$\sigma_i=15$')

La rchaîne de titre qui précède est importante - cela signifie que la chaîne est une chaîne brute et qu'il ne faut pas traiter les barres obliques inverses comme des échappements python. matplotlib possède un analyseur d'expressions et un moteur de mise en page TeX intégrés, et fournit ses propres polices mathématiques - pour plus de détails, voir Écrire des expressions mathématiques . Ainsi, vous pouvez utiliser du texte mathématique sur toutes les plates-formes sans nécessiter d'installation de TeX. Pour ceux qui ont installé LaTeX et dvipng, vous pouvez également utiliser LaTeX pour formater votre texte et incorporer la sortie directement dans vos figures d'affichage ou votre postscript enregistré - voir Rendu de texte avec LaTeX .

Annoter le texte

Les utilisations de la textfonction de base ci-dessus placent le texte à une position arbitraire sur les Axes. Une utilisation courante du texte consiste à annoter certaines caractéristiques du tracé, et la annotateméthode fournit une fonctionnalité d'assistance pour faciliter les annotations. Dans une annotation, il y a deux points à considérer : l'emplacement annoté représenté par l'argument xyet l'emplacement du texte xytext. Ces deux arguments sont des tuples.(x, y)

ax = plt.subplot()

t = np.arange(0.0, 5.0, 0.01)
s = np.cos(2*np.pi*t)
line, = plt.plot(t, s, lw=2)

plt.annotate('local max', xy=(2, 1), xytext=(3, 1.5),
             arrowprops=dict(facecolor='black', shrink=0.05),
             )

plt.ylim(-2, 2)
plt.show()

Dans cet exemple de base, la xy(pointe de la flèche) et xytext les emplacements (emplacement du texte) sont en coordonnées de données. Il existe une variété d'autres systèmes de coordonnées que l'on peut choisir - voir Annotation de base et Annotations avancées pour plus de détails. Vous trouverez d'autres exemples dans Annotation de tracés .

Axes logarithmiques et autres axes non linéaires

matplotlib.pyplotprend en charge non seulement les échelles d'axe linéaire, mais également les échelles logarithmiques et logit. Ceci est couramment utilisé si les données couvrent plusieurs ordres de grandeur. Changer l'échelle d'un axe est simple :

plt.xscale('journal')

Un exemple de quatre tracés avec les mêmes données et des échelles différentes pour l'axe y est illustré ci-dessous.

# Fixing random state for reproducibility
np.random.seed(19680801)

# make up some data in the open interval (0, 1)
y = np.random.normal(loc=0.5, scale=0.4, size=1000)
y = y[(y > 0) & (y < 1)]
y.sort()
x = np.arange(len(y))

# plot with various axes scales
plt.figure()

# linear
plt.subplot(221)
plt.plot(x, y)
plt.yscale('linear')
plt.title('linear')
plt.grid(True)

# log
plt.subplot(222)
plt.plot(x, y)
plt.yscale('log')
plt.title('log')
plt.grid(True)

# symmetric log
plt.subplot(223)
plt.plot(x, y - y.mean())
plt.yscale('symlog', linthresh=0.01)
plt.title('symlog')
plt.grid(True)

# logit
plt.subplot(224)
plt.plot(x, y)
plt.yscale('logit')
plt.title('logit')
plt.grid(True)
# Adjust the subplot layout, because the logit one may take more space
# than usual, due to y-tick labels like "1 - 10^{-3}"
plt.subplots_adjust(top=0.92, bottom=0.08, left=0.10, right=0.95, hspace=0.25,
                    wspace=0.35)

plt.show()

Il est également possible d'ajouter votre propre échelle, voir matplotlib.scalepour plus de détails.