Noter
Cliquez ici pour télécharger l'exemple de code complet
Tutoriel d'artiste #
Utilisation d'objets Artist pour le rendu sur le canevas.
Il y a trois couches dans l'API Matplotlib.
la
matplotlib.backend_bases.FigureCanvasest la zone sur laquelle la figure est dessinéele
matplotlib.backend_bases.Rendererest l'objet qui sait tirer sur leFigureCanvaset le
matplotlib.artist.Artistest l'objet qui sait comment utiliser un moteur de rendu pour peindre sur la toile.
Le FigureCanvaset
Renderergèrent tous les détails de la communication avec les boîtes à outils de l'interface utilisateur comme wxPython ou les langages de dessin comme PostScript®, et le Artistgère toutes les constructions de haut niveau comme la représentation et la mise en page de la figure, du texte et des lignes. L'utilisateur type passera 95 % de son temps à travailler avec Artists.
Il en existe deux types Artists: les primitives et les conteneurs. Les primitives représentent les objets graphiques standard que nous voulons peindre sur notre canevas :
Line2D, Rectangle,
Text, AxesImage, etc., et les conteneurs sont des emplacements pour les mettre ( Axis,
Axeset Figure). L'utilisation standard est de créer une Figureinstance, d'utiliser le Figurepour créer une ou plusieurs instances Axesou
Subplotet d'utiliser les Axesméthodes d'assistance d'instance pour créer les primitives. Dans l'exemple ci-dessous, nous créons une
Figureinstance à l'aide de matplotlib.pyplot.figure(), qui est une méthode pratique pour instancier des Figureinstances et les connecter à votre interface utilisateur ou à votre boîte à outils de dessin.FigureCanvas. Comme nous le verrons ci-dessous, ce n'est pas nécessaire -- vous pouvez travailler directement avec des instances PostScript, PDF Gtk+ ou wxPython FigureCanvas, instancier Figures
directement vos instances et les connecter vous-mêmes -- mais puisque nous nous concentrons ici sur l'
ArtistAPI, nous allons nous en pyplotcharger de ces détails pour nous :
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(2, 1, 1) # two rows, one column, first plot
C'est Axesprobablement la classe la plus importante de l'API Matplotlib, et celle avec laquelle vous travaillerez la plupart du temps. En effet, Axesest la zone de traçage dans laquelle se trouvent la plupart des objets et Axespossède de nombreuses méthodes d'assistance spéciales ( plot(),
text(),
hist(),
imshow()) pour créer les primitives graphiques les plus courantes ( Line2D,
Text,
Rectangle,
AxesImage, respectivement). Ces méthodes d'assistance prendront vos données (par exemple, numpydes tableaux et des chaînes) et créeront des Artistinstances primitives selon les besoins (par exemple, Line2D), les ajouteront aux conteneurs appropriés et les dessineront à la demande. La plupart d'entre vous connaissent probablement le Subplot, qui n'est qu'un cas particulier d'un Axesqui vit sur une grille régulière de lignes par colonnes deSubplotinstances. Si vous souhaitez créer un Axesà un emplacement arbitraire, utilisez simplement la
add_axes()méthode qui prend une liste de valeurs en coordonnées relatives 0-1 :[left, bottom, width, height]
fig2 = plt.figure()
ax2 = fig2.add_axes([0.15, 0.1, 0.7, 0.3])
Continuons avec notre exemple :
Dans cet exemple, axest l' Axesinstance créée par l'
fig.add_subplotappel ci-dessus (rappelez -vous Subplotqu'il s'agit simplement d'une sous-classe de
Axes) et lorsque vous appelez ax.plot, il crée une Line2Dinstance et l'ajoute au Axes.
Dans la session IPython interactive ci-dessous, vous pouvez voir que la Axes.linesliste est de longueur un et contient la même ligne que celle renvoyée par l' appel :line, = ax.plot...
In [101]: ax.lines[0]
Out[101]: <matplotlib.lines.Line2D at 0x19a95710>
In [102]: line
Out[102]: <matplotlib.lines.Line2D at 0x19a95710>
Si vous effectuez des appels ultérieurs vers ax.plot(et que l'état d'attente est "activé", ce qui est la valeur par défaut), des lignes supplémentaires seront ajoutées à la liste. Vous pouvez supprimer une ligne ultérieurement en appelant sa removeméthode :
Les axes ont également des méthodes d'assistance pour configurer et décorer les graduations des axes x et y, les étiquettes de graduation et les étiquettes d'axe :
xtext = ax.set_xlabel('my xdata') # returns a Text instance
ytext = ax.set_ylabel('my ydata')
Lorsque vous appelez ax.set_xlabel, il transmet les informations sur l' Text
instance de XAxis. Chaque Axes
instance contient une XAxiset une
YAxisinstance, qui gèrent la disposition et le dessin des graduations, des étiquettes de graduation et des étiquettes d'axe.
Essayez de créer la figure ci-dessous.
import numpy as np
import matplotlib.pyplot as plt
fig = plt.figure()
fig.subplots_adjust(top=0.8)
ax1 = fig.add_subplot(211)
ax1.set_ylabel('volts')
ax1.set_title('a sine wave')
t = np.arange(0.0, 1.0, 0.01)
s = np.sin(2*np.pi*t)
line, = ax1.plot(t, s, color='blue', lw=2)
# Fixing random state for reproducibility
np.random.seed(19680801)
ax2 = fig.add_axes([0.15, 0.1, 0.7, 0.3])
n, bins, patches = ax2.hist(np.random.randn(1000), 50,
facecolor='yellow', edgecolor='yellow')
ax2.set_xlabel('time (s)')
plt.show()
Personnaliser vos objets #
Chaque élément de la figure est représenté par un Matplotlib
Artist, et chacun a une longue liste de propriétés pour configurer son apparence. La figure elle-même contient
Rectangleexactement la taille de la figure, que vous pouvez utiliser pour définir la couleur d'arrière-plan et la transparence des figures. De même, chaque Axesboîte englobante (la boîte blanche standard avec des bords noirs dans le tracé Matplotlib typique, a une Rectangleinstance qui détermine la couleur, la transparence et d'autres propriétés des Axes. Ces instances sont stockées en tant que variables membres Figure.patchet Axes.patch("Patch" est un nom hérité de MATLAB, et est un "patch" 2D de couleur sur la figure, par exemple, des rectangles, des cercles et des polygones). Chaque Matplotlib Artista les propriétés suivantes
Propriété |
La description |
|---|---|
alpha |
La transparence - un scalaire de 0-1 |
Animé |
Un booléen utilisé pour faciliter le dessin animé |
axes |
Les haches dans lesquelles vit l'artiste, peut-être aucune |
clip_box |
La boîte englobante qui coupe l'artiste |
clip_on |
Si le découpage est activé |
clip_path |
Le chemin auquel l'artiste est attaché |
contient |
Une fonction de picking pour tester si l'artiste contient le point de picking |
chiffre |
L'instance de la figure dans laquelle vit l'artiste, peut-être Aucune |
étiquette |
Une étiquette de texte (par exemple, pour l'étiquetage automatique) |
cueilleur |
Un objet python qui contrôle la sélection d'objets |
transformer |
La transformation |
visible |
Un booléen indiquant si l'artiste doit être dessiné |
zorder |
Un nombre qui détermine l'ordre de dessin |
tramé |
Booléen ; Transforme les vecteurs en graphiques raster (pour la compression et la transparence EPS) |
Chacune des propriétés est accessible avec un setter ou un getter à l'ancienne (oui, nous savons que cela irrite les Pythonistas et nous prévoyons de prendre en charge l'accès direct via des propriétés ou des traits, mais cela n'a pas encore été fait). Par exemple, pour multiplier l'alpha actuel par la moitié :
a = o.get_alpha()
o.set_alpha(0.5*a)
Si vous souhaitez définir plusieurs propriétés à la fois, vous pouvez également utiliser la setméthode avec des arguments de mots clés. Par exemple:
o.set(alpha=0.5, zorder=2)
Si vous travaillez de manière interactive sur le shell python, un moyen pratique d'inspecter les Artistpropriétés consiste à utiliser la
matplotlib.artist.getp()fonction (simplement
getp()dans pyplot), qui répertorie les propriétés et leurs valeurs. Cela fonctionne également pour les classes dérivées de Artist, par exemple, Figureet Rectangle. Voici les Figurepropriétés du rectangle mentionnées ci-dessus :
In [149]: matplotlib.artist.getp(fig.patch)
agg_filter = None
alpha = None
animated = False
antialiased or aa = False
bbox = Bbox(x0=0.0, y0=0.0, x1=1.0, y1=1.0)
capstyle = butt
children = []
clip_box = None
clip_on = True
clip_path = None
contains = None
data_transform = BboxTransformTo( TransformedBbox( Bbox...
edgecolor or ec = (1.0, 1.0, 1.0, 1.0)
extents = Bbox(x0=0.0, y0=0.0, x1=640.0, y1=480.0)
facecolor or fc = (1.0, 1.0, 1.0, 1.0)
figure = Figure(640x480)
fill = True
gid = None
hatch = None
height = 1
in_layout = False
joinstyle = miter
label =
linestyle or ls = solid
linewidth or lw = 0.0
patch_transform = CompositeGenericTransform( BboxTransformTo( ...
path = Path(array([[0., 0.], [1., 0.], [1.,...
path_effects = []
picker = None
rasterized = None
sketch_params = None
snap = None
transform = CompositeGenericTransform( CompositeGenericTra...
transformed_clip_path_and_affine = (None, None)
url = None
verts = [[ 0. 0.] [640. 0.] [640. 480.] [ 0. 480....
visible = True
width = 1
window_extent = Bbox(x0=0.0, y0=0.0, x1=640.0, y1=480.0)
x = 0
xy = (0, 0)
y = 0
zorder = 1
Les docstrings de toutes les classes contiennent également les Artist
propriétés, vous pouvez donc consulter "l'aide" interactive ou le
matplotlib.artist pour une liste des propriétés d'un objet donné.
Conteneurs d'objets #
Maintenant que nous savons comment inspecter et définir les propriétés d'un objet donné que nous voulons configurer, nous devons savoir comment accéder à cet objet. Comme mentionné dans l'introduction, il existe deux types d'objets : les primitives et les conteneurs. Les primitives sont généralement les éléments que vous souhaitez configurer (la police d'une Text
instance, la largeur d'un Line2D) bien que les conteneurs aient également certaines propriétés - par exemple, le
est un conteneur qui contient de nombreuses primitives dans votre tracé, mais il a également des propriétés telles que pour contrôler si l'axe des abscisses est 'linéaire' ou 'log'. Dans cette section, nous verrons où les différents objets conteneurs stockent les objets auxquels vous souhaitez accéder.Axes ArtistxscaleArtists
Conteneur de figurines #
Le conteneur de niveau supérieur Artistest le
matplotlib.figure.Figure, et il contient tout dans la figure. L'arrière-plan de la figure est un
Rectanglequi est stocké dans
Figure.patch. Au fur et à mesure que vous ajoutez des sous-parcelles ( add_subplot()) et des axes ( add_axes()) à la figure, ceux-ci seront ajoutés au fichier Figure.axes. Ceux-ci sont également renvoyés par les méthodes qui les créent :
In [156]: fig = plt.figure()
In [157]: ax1 = fig.add_subplot(211)
In [158]: ax2 = fig.add_axes([0.1, 0.1, 0.7, 0.3])
In [159]: ax1
Out[159]: <AxesSubplot:>
In [160]: print(fig.axes)
[<AxesSubplot:>, <matplotlib.axes._axes.Axes object at 0x7f0768702be0>]
Étant donné que la figure conserve le concept des "axes actuels" (voir
Figure.gcaet
Figure.sca) pour prendre en charge la machine d'état pylab/pyplot, vous ne devez pas insérer ou supprimer des axes directement de la liste des axes, mais plutôt utiliser les
méthodes add_subplot()et
add_axes()pour insérer, et la
Axes.removeméthode supprimer. Vous êtes cependant libre de parcourir la liste des Axes ou de l'indexer pour accéder aux Axesinstances que vous souhaitez personnaliser. Voici un exemple qui active toutes les grilles Axes :
for ax in fig.axes:
ax.grid(True)
La figure possède également ses propres attributs images, et lines,
que vous pouvez utiliser pour ajouter directement des primitives. Ce faisant, le système de coordonnées par défaut pour le sera simplement en pixels (ce qui n'est généralement pas ce que vous voulez). Si vous utilisez plutôt des méthodes au niveau de la figure pour ajouter des artistes (par exemple, en utilisant pour ajouter du texte), le système de coordonnées par défaut sera "coordonnées de la figure" où (0, 0) est le coin inférieur gauche de la figure et (1, 1 ) est le coin supérieur droit de la figure.patchestextFigureFigure.text
Comme avec tous les Artists, vous pouvez contrôler ce système de coordonnées en définissant la propriété transform. Vous pouvez utiliser explicitement les "coordonnées de la figure" en définissant la Artisttransformation surfig.transFigure :
import matplotlib.lines as lines
fig = plt.figure()
l1 = lines.Line2D([0, 1], [0, 1], transform=fig.transFigure, figure=fig)
l2 = lines.Line2D([0, 1], [1, 0], transform=fig.transFigure, figure=fig)
fig.lines.extend([l1, l2])
plt.show()
Voici un résumé des artistes que contient la figure
Attribut de la figure |
La description |
|---|---|
axes |
Une liste d' |
correctif |
Le |
images |
Une liste de |
légendes |
|
lignes |
Une liste d'instances de Figure |
correctifs |
Une liste de figures |
les textes |
Une liste Figure |
Conteneur haches #
Le matplotlib.axes.Axesest le centre de l'univers Matplotlib - il contient la grande majorité de tous les Artistséléments utilisés dans une figure avec de nombreuses méthodes d'assistance pour les créer et les ajouter
Artistsà lui-même, ainsi que des méthodes d'assistance pour accéder et personnaliser ce Artistsqu'il contient. Comme le
Figure, il contient a
qui est a
pour les coordonnées cartésiennes et a
pour les coordonnées polaires ; ce patch détermine la forme, l'arrière-plan et la bordure de la zone de traçage :Patch
patchRectangleCircle
ax = fig.add_subplot()
rect = ax.patch # a Rectangle instance
rect.set_facecolor('green')
Lorsque vous appelez une méthode de traçage, par exemple, le canonique
plotet que vous transmettez des tableaux ou des listes de valeurs, la méthode crée une matplotlib.lines.Line2Dinstance, met à jour la ligne avec toutes les Line2Dpropriétés passées en tant qu'arguments de mots-clés, ajoute la ligne au Axes, et vous la renvoie :
In [213]: x, y = np.random.rand(2, 100)
In [214]: line, = ax.plot(x, y, '-', color='blue', linewidth=2)
plotrenvoie une liste de lignes car vous pouvez transmettre plusieurs paires x, y au tracé, et nous décompressons le premier élément de la liste de longueur un dans la variable de ligne. La ligne a été ajoutée à la
Axes.linesliste :
In [229]: print(ax.lines)
[<matplotlib.lines.Line2D at 0xd378b0c>]
De même, les méthodes qui créent des correctifs, comme
bar()crée une liste de rectangles, ajouteront les correctifs à la Axes.patchesliste :
In [233]: n, bins, rectangles = ax.hist(np.random.randn(1000), 50)
In [234]: rectangles
Out[234]: <BarContainer object of 50 artists>
In [235]: print(len(ax.patches))
Out[235]: 50
Vous ne devez pas ajouter d'objets directement aux
listes Axes.linesou , car le doit effectuer certaines opérations lorsqu'il crée et ajoute un objet :Axes.patchesAxes
Il définit la propriété
figureet du ;axesArtistAxesIl définit la transformation par défaut (sauf si une est déjà définie) ;Il inspecte les données contenues dans
Artistpour mettre à jour les structures de données contrôlant la mise à l'échelle automatique, afin que les limites de la vue puissent être ajustées pour contenir les données tracées.
Vous pouvez néanmoins créer vous-même des objets et les ajouter directement à l'
Axesaide de méthodes d'assistance telles que add_lineet
add_patch. Voici une session interactive annotée illustrant ce qui se passe :
In [262]: fig, ax = plt.subplots()
# create a rectangle instance
In [263]: rect = matplotlib.patches.Rectangle((1, 1), width=5, height=12)
# by default the axes instance is None
In [264]: print(rect.axes)
None
# and the transformation instance is set to the "identity transform"
In [265]: print(rect.get_data_transform())
IdentityTransform()
# now we add the Rectangle to the Axes
In [266]: ax.add_patch(rect)
# and notice that the ax.add_patch method has set the axes
# instance
In [267]: print(rect.axes)
Axes(0.125,0.1;0.775x0.8)
# and the transformation has been set too
In [268]: print(rect.get_data_transform())
CompositeGenericTransform(
TransformWrapper(
BlendedAffine2D(
IdentityTransform(),
IdentityTransform())),
CompositeGenericTransform(
BboxTransformFrom(
TransformedBbox(
Bbox(x0=0.0, y0=0.0, x1=1.0, y1=1.0),
TransformWrapper(
BlendedAffine2D(
IdentityTransform(),
IdentityTransform())))),
BboxTransformTo(
TransformedBbox(
Bbox(x0=0.125, y0=0.10999999999999999, x1=0.9, y1=0.88),
BboxTransformTo(
TransformedBbox(
Bbox(x0=0.0, y0=0.0, x1=6.4, y1=4.8),
Affine2D(
[[100. 0. 0.]
[ 0. 100. 0.]
[ 0. 0. 1.]])))))))
# the default axes transformation is ax.transData
In [269]: print(ax.transData)
CompositeGenericTransform(
TransformWrapper(
BlendedAffine2D(
IdentityTransform(),
IdentityTransform())),
CompositeGenericTransform(
BboxTransformFrom(
TransformedBbox(
Bbox(x0=0.0, y0=0.0, x1=1.0, y1=1.0),
TransformWrapper(
BlendedAffine2D(
IdentityTransform(),
IdentityTransform())))),
BboxTransformTo(
TransformedBbox(
Bbox(x0=0.125, y0=0.10999999999999999, x1=0.9, y1=0.88),
BboxTransformTo(
TransformedBbox(
Bbox(x0=0.0, y0=0.0, x1=6.4, y1=4.8),
Affine2D(
[[100. 0. 0.]
[ 0. 100. 0.]
[ 0. 0. 1.]])))))))
# notice that the xlimits of the Axes have not been changed
In [270]: print(ax.get_xlim())
(0.0, 1.0)
# but the data limits have been updated to encompass the rectangle
In [271]: print(ax.dataLim.bounds)
(1.0, 1.0, 5.0, 12.0)
# we can manually invoke the auto-scaling machinery
In [272]: ax.autoscale_view()
# and now the xlim are updated to encompass the rectangle, plus margins
In [273]: print(ax.get_xlim())
(0.75, 6.25)
# we have to manually force a figure draw
In [274]: fig.canvas.draw()
Il existe de très nombreuses Axesméthodes d'assistance pour créer des primitives
Artistset les ajouter à leurs conteneurs respectifs. Le tableau ci-dessous en résume un petit échantillon, les types Artistqu'ils créent et où ils les stockent
Méthode d'aide aux axes |
Artiste |
Récipient |
|---|---|---|
|
ax.texts |
|
|
ax.patches |
|
|
ax.lines et ax.patches |
|
|
ax.patches |
|
|
ax.patches |
|
|
ax.images |
|
|
ax.get_legend() |
|
|
ax.lines |
|
|
ax.collections |
|
|
ax.texts |
En plus de tout cela Artists, le Axescontient deux Artistconteneurs importants : le XAxis
et YAxis, qui gèrent le dessin des coches et des étiquettes. Celles-ci sont stockées sous forme de variables d'instance
xaxiset
yaxis. Les conteneurs XAxiset YAxis
seront détaillés ci-dessous, mais notez que le Axescontient de nombreuses méthodes d'assistance qui transfèrent les appels aux
Axisinstances, de sorte que vous n'avez souvent pas besoin de travailler directement avec elles, sauf si vous le souhaitez. Par exemple, vous pouvez définir la couleur de police des XAxisticklabels à l' Axesaide de la méthode d'assistance :
ax.tick_params(axis='x', labelcolor='orange')
Vous trouverez ci-dessous un résumé des artistes que Axescontient le
Attribut des axes |
La description |
|---|---|
artistes |
Une |
correctif |
|
collections |
Une |
images |
Un |
lignes |
Une |
correctifs |
Une |
les textes |
Une |
axe des abscisses |
Un |
yaxis |
Un |
La légende est accessible par get_legend,
Conteneurs d'axe #
Les matplotlib.axis.Axisinstances gèrent le dessin des lignes de graduation, des lignes de grille, des étiquettes de graduation et de l'étiquette d'axe. Vous pouvez configurer les graduations gauche et droite séparément pour l'axe y, et les graduations supérieure et inférieure séparément pour l'axe x. Le Axis
stocke également les données et les intervalles d'affichage utilisés dans la mise à l'échelle automatique, le panoramique et le zoom, ainsi que les instances Locatoret
Formatterqui contrôlent l'emplacement des graduations et la manière dont elles sont représentées sous forme de chaînes.
Chaque Axisobjet contient un labelattribut (c'est ce qui se pyplotmodifie dans les appels à xlabelet
ylabel) ainsi qu'une liste de ticks majeurs et mineurs. Les ticks sont
axis.XTicket les axis.YTickinstances, qui contiennent les primitives de ligne et de texte réelles qui rendent les ticks et les ticklabels. Étant donné que les graduations sont créées dynamiquement selon les besoins (par exemple, lors d'un panoramique et d'un zoom), vous devez accéder aux listes de graduations majeures et mineures via leurs méthodes d'accès
axis.Axis.get_major_tickset axis.Axis.get_minor_ticks. Bien que les ticks contiennent toutes les primitives et seront couverts ci-dessous, Axis
les instances ont des méthodes d'accès qui renvoient les lignes de tick, les étiquettes de tick, les emplacements de tick, etc. :
fig, ax = plt.subplots()
axis = ax.xaxis
axis.get_ticklocs()
array([0. , 0.2, 0.4, 0.6, 0.8, 1. ])
[Text(0.0, 0, '0.0'), Text(0.2, 0, '0.2'), Text(0.4, 0, '0.4'), Text(0.6000000000000001, 0, '0.6'), Text(0.8, 0, '0.8'), Text(1.0, 0, '1.0')]
notez qu'il y a deux fois plus de graduations que d'étiquettes car, par défaut, il y a des lignes de graduation en haut et en bas mais seulement des étiquettes de graduation sous l'axe des x ; cependant, cela peut être personnalisé.
<a list of 12 Line2D ticklines objects>
Et avec les méthodes ci-dessus, vous ne récupérez que les listes de ticks majeurs par défaut, mais vous pouvez également demander les ticks mineurs :
axis.get_ticklabels(minor=True)
axis.get_ticklines(minor=True)
<a list of 0 Line2D ticklines objects>
Voici un résumé de certaines des méthodes d'accès utiles de Axis
(celles-ci ont des setters correspondants lorsque cela est utile, comme
set_major_formatter().)
Méthode d'accès à l'axe |
La description |
|---|---|
L'échelle de l'axe, par exemple, "log" ou "linéaire" |
|
L'instance d'intervalle des limites de la vue Axis |
|
L'instance d'intervalle des limites de données Axis |
|
Une liste de lignes de grille pour l'Axe |
|
L'étiquette Axis - une |
|
Le texte de décalage de l'axe - une |
|
Une liste d' |
|
Une liste d' |
|
Une liste des emplacements des ticks - mot-clé minor=True|False |
|
L' |
|
L' |
|
L' |
|
L' |
|
Une liste d' |
|
Une liste d' |
|
Activer ou désactiver la grille pour les graduations majeures ou mineures |
Voici un exemple, déconseillé pour sa beauté, qui personnalise les propriétés Axes et Tick.
# plt.figure creates a matplotlib.figure.Figure instance
fig = plt.figure()
rect = fig.patch # a rectangle instance
rect.set_facecolor('lightgoldenrodyellow')
ax1 = fig.add_axes([0.1, 0.3, 0.4, 0.4])
rect = ax1.patch
rect.set_facecolor('lightslategray')
for label in ax1.xaxis.get_ticklabels():
# label is a Text instance
label.set_color('red')
label.set_rotation(45)
label.set_fontsize(16)
for line in ax1.yaxis.get_ticklines():
# line is a Line2D instance
line.set_color('green')
line.set_markersize(25)
line.set_markeredgewidth(3)
plt.show()
Cochez les conteneurs #
Le matplotlib.axis.Tickest le dernier objet conteneur dans notre descente du Figureau au
Axesau Axis
au Tick. Le Tickcontient les occurrences de graduation et de ligne de grille, ainsi que les occurrences d'étiquette pour les graduations supérieures et inférieures. Chacun d'entre eux est accessible directement en tant qu'attribut du fichier Tick.
Attribut de tique |
La description |
|---|---|
tick1line |
Un |
tick2line |
Un |
ligne de la grille |
Un |
étiquette1 |
Un |
étiquette2 |
Un |
Voici un exemple qui définit le formateur pour les ticks du côté droit avec des signes dollar et les colore en vert sur le côté droit de l'axe y.
import numpy as np
import matplotlib.pyplot as plt
# Fixing random state for reproducibility
np.random.seed(19680801)
fig, ax = plt.subplots()
ax.plot(100*np.random.rand(20))
# Use automatic StrMethodFormatter
ax.yaxis.set_major_formatter('${x:1.2f}')
ax.yaxis.set_tick_params(which='major', labelcolor='green',
labelleft=False, labelright=True)
plt.show()
Durée totale d'exécution du script : (0 minutes 1,067 secondes)