Tutorial Pyplot

Un'introduzione all'interfaccia pyplot. Si prega di consultare anche la Guida rapida per una panoramica di come funziona Matplotlib e Matplotlib Application Interfaces (API) per una spiegazione dei compromessi tra le API utente supportate.

Introduzione a pyplot

matplotlib.pyplotè una raccolta di funzioni che fanno funzionare matplotlib come MATLAB. Ogni pyplotfunzione apporta alcune modifiche a una figura: ad esempio, crea una figura, crea un'area di disegno in una figura, traccia alcune linee in un'area di disegno, decora il disegno con etichette, ecc.

In matplotlib.pyplotvari stati vengono conservati attraverso le chiamate di funzione, in modo che tenga traccia di cose come la figura corrente e l'area del tracciato, e le funzioni del tracciato sono dirette agli assi correnti (si noti che "assi" qui e nella maggior parte dei punti della documentazione si riferisce agli assi parte di una figura e non il termine matematico stretto per più di un asse).

Nota

l'API pyplot implicita è generalmente meno dettagliata ma anche non flessibile come l'API esplicita. La maggior parte delle chiamate di funzione che vedi qui possono anche essere chiamate come metodi da un Axesoggetto. Ti consigliamo di sfogliare i tutorial e gli esempi per vedere come funziona. Vedere Matplotlib Application Interfaces (API) per una spiegazione del compromesso delle API utente supportate.

La generazione di visualizzazioni con pyplot è molto rapida:

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

Forse ti starai chiedendo perché l'asse x va da 0-3 e l'asse y da 1-4. Se fornisci un singolo elenco o array a plot, matplotlib presuppone che sia una sequenza di valori y e genera automaticamente i valori x per te. Poiché gli intervalli Python iniziano con 0, il vettore x predefinito ha la stessa lunghezza di y ma inizia con 0. Quindi i dati x sono .[0, 1, 2, 3]

plotè una funzione versatile e accetta un numero arbitrario di argomenti. Ad esempio, per tracciare x rispetto a y, puoi scrivere:

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

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

Formattazione dello stile della tua trama

Per ogni coppia di argomenti x, y, esiste un terzo argomento facoltativo che è la stringa di formato che indica il colore e il tipo di linea del grafico. Le lettere e i simboli della stringa di formato provengono da MATLAB e si concatena una stringa di colore con una stringa di stile di linea. La stringa di formato predefinita è 'b-', ovvero una linea blu continua. Ad esempio, per tracciare quanto sopra con cerchi rossi, dovresti emettere

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

Consulta la plotdocumentazione per un elenco completo degli stili di linea e delle stringhe di formato. La axisfunzione nell'esempio sopra prende un elenco di e specifica il viewport degli assi.[xmin, xmax, ymin, ymax]

Se matplotlib fosse limitato a lavorare con gli elenchi, sarebbe abbastanza inutile per l'elaborazione numerica. In genere, utilizzerai array numpy . In effetti, tutte le sequenze vengono convertite internamente in array numpy. L'esempio seguente illustra la tracciatura di più righe con diversi stili di formato in una chiamata di funzione utilizzando gli array.

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

Tracciare con stringhe di parole chiave

Ci sono alcuni casi in cui hai dati in un formato che ti consente di accedere a particolari variabili con stringhe. Ad esempio, con numpy.recarrayo pandas.DataFrame.

Matplotlib ti consente di fornire un tale oggetto con l' dataargomento della parola chiave. Se fornito, è possibile generare grafici con le stringhe corrispondenti a queste variabili.

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

Tracciare con variabili categoriali

È anche possibile creare un grafico utilizzando variabili categoriali. Matplotlib ti consente di passare variabili categoriche direttamente a molte funzioni di tracciamento. Per esempio:

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

Controllo delle proprietà della linea

Le linee hanno molti attributi che puoi impostare: larghezza linea, stile trattino, antialiasing, ecc.; vedere matplotlib.lines.Line2D. Esistono diversi modi per impostare le proprietà della linea

• Usa argomenti di parole chiave:

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

• Usa i metodi setter di Line2Dun'istanza. plotrestituisce un elenco di Line2Doggetti; es, . Nel codice seguente supponiamo di avere solo una riga in modo che l'elenco restituito sia di lunghezza 1. Usiamo il tuple unpacking with per ottenere il primo elemento di quell'elenco:line1, line2 = plot(x1, y1, x2, y2)line,

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

• Usa setp. L'esempio seguente utilizza una funzione in stile MATLAB per impostare più proprietà su un elenco di righe. setpfunziona in modo trasparente con un elenco di oggetti o un singolo oggetto. Puoi utilizzare argomenti di parole chiave python o coppie stringa/valore in stile 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)
  

Ecco gli Line2Dimmobili disponibili.

Proprietà	Tipo di valore
alfa	galleggiante
animato	[Vero | Falso]
antialias o aa	[Vero | Falso]
clip_box	un'istanza matplotlib.transform.Bbox
clip_on	[Vero | Falso]
percorso_clip	un'istanza Path e un'istanza Transform, una Patch
colore o c	qualsiasi colore matplotlib
contiene	la funzione di hit testing
dash_capstyle	[ 'butt'| 'round'| 'projecting']
dash_joinstyle	[ 'miter'| 'round'| 'bevel']
trattini	sequenza di inchiostro on/off in punti
dati	(np.array xdata, np.array ydata)
figura	un'istanza matplotlib.figure.Figure
etichetta	qualsiasi stringa
stile di linea o ls	[ '-'| '--'| '-.'| ':'| 'steps'| ...]
larghezza di riga o lw	valore float in punti
marcatore	[ '+'| ','| '.'| '1'| '2'| '3'| '4']
markeredgecolor o mec	qualsiasi colore matplotlib
markeredgewidth o miagolio	valore float in punti
markerfacecolor o mfc	qualsiasi colore matplotlib
markersize o ms	galleggiante
markevery	[ Nessuno | intero | (inizio, passo) ]
raccoglitore	utilizzato nella selezione della linea interattiva
pickradius	il raggio di selezione della selezione della linea
solid_capstyle	[ 'butt'| 'round'| 'projecting']
solid_joinstyle	[ 'miter'| 'round'| 'bevel']
trasformare	un'istanza matplotlib.transforms.Transform
visibile	[Vero | Falso]
xdata	np.array
ydata	np.array
zordine	qualsiasi numero

Per ottenere un elenco di proprietà della linea impostabili, chiamare la setpfunzione con una o più linee come argomento

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

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

Lavorare con più figure e assi

MATLAB, e pyplot, hanno il concetto della figura corrente e degli assi correnti. Tutte le funzioni di plottaggio si applicano agli assi correnti. La funzione gcarestituisce gli assi correnti ( matplotlib.axes.Axesun'istanza) e gcfrestituisce la figura corrente ( matplotlib.figure.Figureun'istanza). Normalmente, non devi preoccuparti di questo, perché è tutto curato dietro le quinte. Di seguito è riportato uno script per creare due sottotrame.

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

La figurechiamata qui è facoltativa perché verrà creata una figura se non esiste, proprio come verrà creato un Axes (equivalente a una subplot()chiamata esplicita) se non esiste. La subplotchiamata specifica dove va da 1 a . Le virgole nella chiamata sono facoltative se . Quindi è identico a .numrows, numcols, plot_numberplot_numbernumrows*numcolssubplotnumrows*numcols<10subplot(211)subplot(2, 1, 1)

È possibile creare un numero arbitrario di sottotrame e assi. Se si desidera posizionare manualmente un Axes, cioè non su una griglia rettangolare, utilizzare axes, che consente di specificare la posizione in cui tutti i valori sono in coordinate frazionarie (da 0 a 1). Vedere Axes Demo per un esempio di posizionamento manuale degli assi e Più sottotrame per un esempio con molte sottotrame.axes([left, bottom, width, height])

È possibile creare più cifre utilizzando più figurechiamate con un numero di cifra crescente. Naturalmente, ogni figura può contenere tutti gli assi e le sottotrame che il tuo cuore desidera:

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

È possibile cancellare la figura corrente con clf e gli assi correnti con cla. Se trovi fastidioso che gli stati (in particolare l'immagine, la figura e gli assi correnti) vengano mantenuti per te dietro le quinte, non disperare: questo è solo un sottile involucro di stato attorno a un'API orientata agli oggetti, che puoi usare invece (vedi tutorial dell'artista )

Se stai realizzando molte figure, devi essere consapevole di un'altra cosa: la memoria richiesta per una figura non viene completamente rilasciata fino a quando la figura non viene chiusa esplicitamente con close. Cancellare tutti i riferimenti alla figura, e/o usare il window manager per chiudere la finestra in cui la figura appare sullo schermo, non è sufficiente, perché pyplot mantiene i riferimenti interni finché non close viene chiamato.

Lavorare con il testo

textpuò essere utilizzato per aggiungere testo in una posizione arbitraria, e xlabel, ylabele titlesono utilizzati per aggiungere testo nelle posizioni indicate (vedere Text in Matplotlib Plots per un esempio più dettagliato)

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

Tutte le textfunzioni restituiscono matplotlib.text.Text un'istanza. Proprio come con le linee sopra, puoi personalizzare le proprietà passando argomenti di parole chiave nelle funzioni di testo o usando setp:

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

Queste proprietà sono trattate in modo più dettagliato in Proprietà e layout del testo .

Utilizzo di espressioni matematiche nel testo

matplotlib accetta espressioni di equazioni TeX in qualsiasi espressione di testo. Ad esempio per scrivere l'espressione\(\sigma_i=15\)nel titolo puoi scrivere un'espressione TeX racchiusa tra i simboli del dollaro:

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

Il rprecedente alla stringa del titolo è importante: significa che la stringa è una stringa non elaborata e non trattare le barre rovesciate come escape di Python. matplotlib ha un parser di espressioni TeX integrato e un motore di layout e fornisce i propri caratteri matematici - per i dettagli vedere Scrittura di espressioni matematiche . In questo modo è possibile utilizzare il testo matematico su più piattaforme senza richiedere l'installazione di TeX. Per coloro che hanno installato LaTeX e dvipng, è anche possibile utilizzare LaTeX per formattare il testo e incorporare l'output direttamente nelle figure visualizzate o nel postscript salvato: vedere Rendering del testo con LaTeX .

Testo di annotazione

Gli usi della textfunzione di base sopra collocano il testo in una posizione arbitraria sugli assi. Un uso comune del testo è annotare alcune caratteristiche della trama e il annotatemetodo fornisce funzionalità di supporto per semplificare le annotazioni. In un'annotazione, ci sono due punti da considerare: la posizione annotata rappresentata dall'argomento xye la posizione del testo xytext. Entrambi questi argomenti sono tuple.(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()

In questo esempio di base, sia la xy(punta della freccia) che xytext le posizioni (posizione del testo) sono nelle coordinate dei dati. È possibile scegliere una varietà di altri sistemi di coordinate: vedere Annotazione di base e Annotazioni avanzate per i dettagli. Altri esempi possono essere trovati in Annotating Plots .

Assi logaritmici e altri assi non lineari

matplotlib.pyplotsupporta non solo le scale degli assi lineari, ma anche le scale logaritmiche e logit. Questo è comunemente usato se i dati si estendono su molti ordini di grandezza. Cambiare la scala di un asse è facile:

plt.xscale('log')

Di seguito è riportato un esempio di quattro grafici con gli stessi dati e scale diverse per l'asse y.

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

È anche possibile aggiungere la propria scala, vedere matplotlib.scaleper i dettagli.