Nota
Fare clic qui per scaricare il codice di esempio completo
Tutorial dell'artista #
Utilizzo di oggetti Artist per il rendering nell'area di disegno.
Ci sono tre livelli nell'API Matplotlib.
è l'
matplotlib.backend_bases.FigureCanvasarea su cui è disegnata la figurail
matplotlib.backend_bases.Rendererè l'oggetto che sa attingere alFigureCanvased
matplotlib.artist.Artistè l'oggetto che sa usare un renderer per dipingere sulla tela.
Gestisce tutti i dettagli della comunicazione con toolkit dell'interfaccia utente come wxPython o linguaggi di disegno come PostScript® e FigureCanvasgestisce
tutti i costrutti di alto livello come rappresentare e disporre la figura, il testo e le linee. L'utente tipico trascorrerà il 95% del proprio tempo lavorando con .RendererArtistArtists
Esistono due tipi di Artists: primitive e contenitori. Le primitive rappresentano gli oggetti grafici standard che vogliamo dipingere sulla nostra tela:
Line2D, Rectangle,
Text, AxesImage, ecc., ei contenitori sono posti dove metterli ( Axis,
Axese Figure). L'utilizzo standard consiste nel creare Figureun'istanza, utilizzare the Figureper creare una o più Axesistanze
Subplote utilizzare i Axesmetodi helper dell'istanza per creare le primitive. Nell'esempio seguente, creiamo
Figureun'istanza utilizzando matplotlib.pyplot.figure(), che è un metodo pratico per creare istanze di Figureistanze e collegarle all'interfaccia utente o al toolkit di disegnoFigureCanvas. Come discuteremo di seguito, questo non è necessario: puoi lavorare direttamente con istanze PostScript, PDF Gtk+ o wxPython FigureCanvas, istanziare Figures
direttamente le tue istanze e collegarle tu stesso, ma poiché qui ci stiamo concentrando
Artistsull'API, lasceremo pyplotgestire alcune di quei dettagli per noi:
import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_subplot(2, 1, 1) # two rows, one column, first plot
È Axesprobabilmente la classe più importante nell'API Matplotlib e quella con cui lavorerai la maggior parte del tempo. Questo perché Axesè l'area di disegno in cui va la maggior parte degli oggetti e Axesha molti metodi di supporto speciali ( plot(),
text(),
hist(),
imshow()) per creare le primitive grafiche più comuni ( Line2D,
Text,
Rectangle,
AxesImage, rispettivamente). Questi metodi di supporto prenderanno i tuoi dati (ad esempio, numpyarray e stringhe) e creeranno istanze primitive Artistsecondo necessità (ad esempio, Line2D), le aggiungeranno ai contenitori pertinenti e le disegneranno quando richiesto. La maggior parte di voi probabilmente conosce il Subplot, che è solo un caso speciale di un Axesche vive su una griglia regolare di righe per colonne diSubplotistanze. Se vuoi creare un Axesin una posizione arbitraria, usa semplicemente il
add_axes()metodo che accetta un elenco di valori in coordinate di figura relativa 0-1:[left, bottom, width, height]
fig2 = plt.figure()
ax2 = fig2.add_axes([0.15, 0.1, 0.7, 0.3])
Continuando con il nostro esempio:
In questo esempio, axè l' Axesistanza creata dalla
fig.add_subplotchiamata sopra (ricorda Subplotche è solo una sottoclasse di
Axes) e quando chiami ax.plot, crea Line2Dun'istanza e la aggiunge a Axes. Nella sessione IPython interattiva
di seguito, puoi vedere che l' Axes.lineselenco è di lunghezza uno e contiene la stessa riga restituita dalla chiamata: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>
Se si effettuano chiamate successive a ax.plot(e lo stato di attesa è "on" che è l'impostazione predefinita), verranno aggiunte ulteriori linee all'elenco. Puoi rimuovere una riga in un secondo momento chiamando il suo removemetodo:
The Axes ha anche metodi di supporto per configurare e decorare il segno di spunta dell'asse x e dell'asse y, le etichette del segno di spunta e le etichette dell'asse:
xtext = ax.set_xlabel('my xdata') # returns a Text instance
ytext = ax.set_ylabel('my ydata')
Quando chiami ax.set_xlabel, passa le informazioni sull'istanza Text
di XAxis. Ogni Axes
istanza contiene un'istanza XAxise
YAxisun'istanza, che gestiscono il layout e il disegno delle tacche, delle etichette delle tacche e delle etichette degli assi.
Prova a creare la figura qui sotto.
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()
Personalizzare i tuoi oggetti #
Ogni elemento nella figura è rappresentato da un Matplotlib
Artiste ognuno ha un ampio elenco di proprietà per configurarne l'aspetto. La figura stessa contiene
Rectangleesattamente le dimensioni della figura, che puoi utilizzare per impostare il colore di sfondo e la trasparenza delle figure. Allo stesso modo, ogni Axesriquadro di delimitazione (il riquadro bianco standard con bordi neri nel tipico grafico Matplotlib, ha Rectangleun'istanza che determina il colore, la trasparenza e altre proprietà degli assi. Queste istanze sono memorizzate come variabili membro Figure.patche Axes.patch("Patch" è un nome ereditato da MATLAB, ed è una "macchia" 2D di colore sulla figura, ad esempio, rettangoli, cerchi e poligoni).Ogni Matplotlib Artistha le seguenti proprietà
Proprietà |
Descrizione |
|---|---|
alfa |
La trasparenza - uno scalare da 0-1 |
animato |
Un valore booleano utilizzato per facilitare il disegno animato |
assi |
Gli assi in cui vive l'artista, forse nessuno |
clip_box |
Il riquadro di delimitazione che ritaglia l'artista |
clip_on |
Se il ritaglio è abilitato |
percorso_clip |
Il percorso a cui è agganciato l'artista |
contiene |
Una funzione di prelievo per verificare se l'artista contiene il punto di prelievo |
figura |
L'istanza della figura in cui vive l'artista, forse Nessuno |
etichetta |
Un'etichetta di testo (ad es. per l'etichettatura automatica) |
raccoglitore |
Un oggetto python che controlla la selezione degli oggetti |
trasformare |
La trasformazione |
visibile |
Un valore booleano indica se l'artista deve essere disegnato |
zordine |
Un numero che determina l'ordine di disegno |
rasterizzato |
booleano; Trasforma i vettori in grafica raster (per compressione e trasparenza EPS) |
Si accede a ciascuna delle proprietà con un setter o getter vecchio stile (sì, sappiamo che questo irrita i Pythonisti e abbiamo in programma di supportare l'accesso diretto tramite proprietà o tratti, ma non è stato ancora fatto). Ad esempio, per moltiplicare l'alfa corrente per metà:
a = o.get_alpha()
o.set_alpha(0.5*a)
Se vuoi impostare più proprietà contemporaneamente, puoi anche utilizzare il setmetodo con argomenti di parole chiave. Per esempio:
o.set(alpha=0.5, zorder=2)
Se stai lavorando in modo interattivo alla shell python, un modo pratico per ispezionare le Artistproprietà è usare la
matplotlib.artist.getp()funzione (semplicemente
getp()in pyplot), che elenca le proprietà e i loro valori. Questo funziona anche per le classi derivate da Artist, ad esempio, Figuree Rectangle. Ecco le Figureproprietà del rettangolo menzionate sopra:
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
Le docstring per tutte le classi contengono anche le Artist
proprietà, quindi puoi consultare la "guida" interattiva o il
matplotlib.artist per un elenco delle proprietà per un dato oggetto.
Contenitori di oggetti #
Ora che sappiamo come ispezionare e impostare le proprietà di un dato oggetto che vogliamo configurare, dobbiamo sapere come arrivare a quell'oggetto. Come accennato nell'introduzione, esistono due tipi di oggetti: primitivi e contenitori. Le primitive sono solitamente le cose che vuoi configurare (il carattere di Text
un'istanza, la larghezza di a Line2D) sebbene anche i contenitori abbiano alcune proprietà -- per esempio the
è un contenitore che contiene molte delle primitive nel tuo grafico, ma ha anche proprietà come per controllare se l'asse x è 'lineare' o 'log'. In questa sezione esamineremo dove i vari oggetti contenitore memorizzano il che vuoi ottenere.Axes ArtistxscaleArtists
Figura contenitore #
Il contenitore di livello superiore Artistè il
matplotlib.figure.Figure, e contiene tutto nella figura. Lo sfondo della figura è un
Rectanglefile memorizzato in
Figure.patch. Man mano che aggiungi sottotrame ( add_subplot()) e assi ( add_axes()) alla figura, questi verranno aggiunti al file Figure.axes. Questi vengono restituiti anche dai metodi che li creano:
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>]
Poiché la figura mantiene il concetto degli "Assi correnti" (vedere
Figure.gcae
Figure.sca) per supportare la macchina a stati pylab/pyplot, non è necessario inserire o rimuovere Axes direttamente dall'elenco Axes, ma piuttosto utilizzare i
metodi add_subplot()e
add_axes()per inserire e il
Axes.removemetodo cancellare. Sei libero, tuttavia, di scorrere l'elenco degli assi o indicizzarlo per ottenere l'accesso alle Axesistanze che desideri personalizzare. Ecco un esempio che attiva tutte le griglie Axes:
for ax in fig.axes:
ax.grid(True)
La figura ha anche i propri attributi images, lines, patchese text
, che puoi utilizzare per aggiungere direttamente le primitive. Quando lo fai, il sistema di coordinate predefinito per Figuresarà semplicemente in pixel (che di solito non è quello che vuoi). Se invece utilizzi i metodi a livello di figura per aggiungere artisti (ad esempio, utilizzando Figure.textper aggiungere testo), il sistema di coordinate predefinito sarà "coordinate figura" dove (0, 0) è la parte inferiore sinistra della figura e (1, 1 ) è l'angolo in alto a destra della figura.
Come con tutte le Artists, puoi controllare questo sistema di coordinate impostando la proprietà transform. È possibile utilizzare esplicitamente "coordinate figura" impostando la Artisttrasformazione su fig.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()
Ecco un riassunto degli Artisti che la Figura contiene
Attributo figura |
Descrizione |
|---|---|
assi |
Un elenco di |
toppa |
Lo |
immagini |
Un elenco di |
leggende |
|
linee |
|
cerotti |
Un elenco di figure |
testi |
Un elenco Figura |
Contenitore assi #
è il matplotlib.axes.Axescentro dell'universo Matplotlib: contiene la stragrande maggioranza di tutti gli elementi Artistsutilizzati in una figura con molti metodi di supporto per crearli e aggiungerli
Artistsa se stesso, nonché metodi di supporto per accedere e personalizzare Artistsciò che contiene. Come
Figure, contiene a
che è a
per coordinate cartesiane e a
per coordinate polari; questa patch determina la forma, lo sfondo e il bordo dell'area di stampa:Patch
patchRectangleCircle
ax = fig.add_subplot()
rect = ax.patch # a Rectangle instance
rect.set_facecolor('green')
Quando chiami un metodo di plottaggio, ad esempio canonical
plote passi in array o liste di valori, il metodo creerà matplotlib.lines.Line2Dun'istanza, aggiornerà la riga con tutte le Line2Dproprietà passate come argomenti di parole chiave, aggiungerà la riga a Axese te la restituirà :
In [213]: x, y = np.random.rand(2, 100)
In [214]: line, = ax.plot(x, y, '-', color='blue', linewidth=2)
plotrestituisce un elenco di righe perché è possibile passare più coppie x, y al grafico e stiamo decomprimendo il primo elemento dell'elenco di lunghezza una nella variabile riga. La riga è stata aggiunta
Axes.linesall'elenco:
In [229]: print(ax.lines)
[<matplotlib.lines.Line2D at 0xd378b0c>]
Allo stesso modo, i metodi che creano patch, come
bar()crea un elenco di rettangoli, aggiungeranno le patch Axes.patchesall'elenco:
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
Non dovresti aggiungere oggetti direttamente agli
elenchi Axes.lineso , perché deve fare alcune cose quando crea e aggiunge un oggetto:Axes.patchesAxes
Imposta la proprietà
figureeaxesdelArtist;Imposta la
Axestrasformazione predefinita (a meno che non ne sia già impostata una);Ispeziona i dati contenuti in
Artistper aggiornare le strutture di dati che controllano il ridimensionamento automatico, in modo che i limiti di visualizzazione possano essere regolati per contenere i dati tracciati.
Puoi, tuttavia, creare oggetti tu stesso e aggiungerli direttamente ai
Axesmetodi di supporto come add_linee
add_patch. Ecco una sessione interattiva annotata che illustra cosa sta succedendo:
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()
Esistono molti, molti Axesmetodi di supporto per creare primitive
Artistse aggiungerle ai rispettivi contenitori. La tabella seguente ne riassume un piccolo campionario, i tipi Artistche creano e dove li memorizzano
Metodo di supporto degli assi |
Artista |
Contenitore |
|---|---|---|
|
ax.texts |
|
|
ax.patch |
|
|
ax.lines e ax.patches |
|
|
ax.patch |
|
|
ax.patch |
|
|
ax.images |
|
|
ax.get_legend() |
|
|
linee d'asse |
|
|
ax.collezioni |
|
|
ax.texts |
Oltre a tutto ciò Artists, il Axescontiene due importanti Artistcontenitori: il XAxis
e YAxis, che gestiscono il disegno delle zecche e delle etichette. Questi sono memorizzati come variabili di istanza
xaxise
yaxis. I contenitori XAxise YAxis
saranno descritti in dettaglio di seguito, ma tieni presente che Axescontiene molti metodi di supporto che inoltrano le chiamate alle
Axisistanze, quindi spesso non è necessario lavorare direttamente con loro a meno che tu non voglia. Ad esempio, puoi impostare il colore del carattere delle etichette di XAxisspunta utilizzando il Axesmetodo helper:
ax.tick_params(axis='x', labelcolor='orange')
Di seguito è riportato un riepilogo degli Artisti che Axescontiene
Attributo degli assi |
Descrizione |
|---|---|
artisti |
Una |
toppa |
|
collezioni |
Una |
immagini |
Un |
linee |
Una |
cerotti |
Una |
testi |
Una |
asse x |
Un'istanza |
asse |
Un'istanza |
La legenda è accessibile da get_legend,
Contenitori dell'asse #
Le matplotlib.axis.Axisistanze gestiscono il disegno delle linee di graduazione, delle linee della griglia, delle etichette di graduazione e dell'etichetta dell'asse. È possibile configurare separatamente i tick sinistro e destro per l'asse y e i tick superiore e inferiore separatamente per l'asse x. Memorizza anche i Axis
dati e gli intervalli di visualizzazione utilizzati per il ridimensionamento automatico, la panoramica e lo zoom, nonché le istanze Locatore
Formatterche controllano dove sono posizionati i tick e come sono rappresentati come stringhe.
Ogni Axisoggetto contiene un labelattributo (questo è ciò che pyplotmodifica nelle chiamate a xlabele
ylabel) così come un elenco di tick maggiori e minori. I segni di spunta sono
axis.XTicke le axis.YTickistanze, che contengono le effettive primitive di linea e testo che rendono i segni di spunta e le etichette di spunta. Poiché i tick vengono creati dinamicamente secondo necessità (ad esempio, durante la panoramica e lo zoom), è necessario accedere agli elenchi dei tick principali e secondari tramite i relativi metodi di accesso
axis.Axis.get_major_tickse axis.Axis.get_minor_ticks. Sebbene i tick contengano tutte le primitive e verranno trattati di seguito, le Axis
istanze hanno metodi di accesso che restituiscono le linee di tick, le etichette dei tick, le posizioni dei tick ecc.:
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')]
nota che ci sono il doppio delle linee di spunta rispetto alle etichette perché per impostazione predefinita ci sono linee di spunta in alto e in basso ma solo le etichette di spunta sotto l'asse x; tuttavia, questo può essere personalizzato.
<a list of 12 Line2D ticklines objects>
E con i metodi di cui sopra, ottieni solo gli elenchi dei tick principali per impostazione predefinita, ma puoi anche richiedere i tick minori:
axis.get_ticklabels(minor=True)
axis.get_ticklines(minor=True)
<a list of 0 Line2D ticklines objects>
Ecco un riepilogo di alcuni degli utili metodi di accesso di Axis
(questi hanno setter corrispondenti dove utili, come
set_major_formatter().)
Metodo di accesso all'asse |
Descrizione |
|---|---|
La scala dell'asse, ad es. "log" o "lineare" |
|
L'istanza dell'intervallo dei limiti della vista dell'asse |
|
L'istanza di intervallo dei limiti di dati Axis |
|
Un elenco di linee della griglia per l'Asse |
|
L'etichetta Axis - |
|
Il testo dell'offset dell'asse - |
|
Un elenco di |
|
Un elenco di |
|
Un elenco di posizioni Tick - parola chiave minor=True|False |
|
L' |
|
L' |
|
L' |
|
L' |
|
Un elenco di |
|
Un elenco di |
|
Attiva o disattiva la griglia per i tick maggiori o minori |
Ecco un esempio, sconsigliato per la sua bellezza, che personalizza le proprietà Axes e 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()
Spunta i contenitori #
Il matplotlib.axis.Tickè l'oggetto contenitore finale nella nostra discesa dal Figureal al
Axesal Axis
al Tick. contiene le Tickistanze della linea di graduazione e della griglia, nonché le istanze dell'etichetta per le graduazioni superiori e inferiori. Ognuno di questi è accessibile direttamente come attributo del file Tick.
Attributo segno di spunta |
Descrizione |
|---|---|
tick1line |
Un'istanza |
tick2line |
Un'istanza |
linea della griglia |
Un'istanza |
etichetta1 |
Un'istanza |
etichetta2 |
Un'istanza |
Ecco un esempio che imposta il formattatore per i segni di spunta del lato destro con i simboli del dollaro e li colora di verde sul lato destro dell'asse 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()
Tempo di esecuzione totale dello script: (0 minuti 1,067 secondi)