Guida rapida

Questo tutorial copre alcuni modelli di utilizzo di base e le migliori pratiche per aiutarti a iniziare con Matplotlib.

import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np

Un semplice esempio

Matplotlib rappresenta graficamente i tuoi dati su Figures (ad esempio finestre, widget Jupyter, ecc.), ognuno dei quali può contenere uno o più Axes, un'area in cui i punti possono essere specificati in termini di coordinate xy (o theta-r in un grafico polare, xyz in una trama 3D, ecc.). Il modo più semplice per creare una figura con un asse è usare pyplot.subplots. Possiamo quindi utilizzare Axes.plotper disegnare alcuni dati sugli Assi:

fig, ax = plt.subplots()  # Create a figure containing a single axes.
ax.plot([1, 2, 3, 4], [1, 4, 2, 3]);  # Plot some data on the axes.

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

Parti di una figura

Ecco i componenti di una figura Matplotlib.

Figure

L' intera figura. La figura tiene traccia di tutto il bambino Axes, un gruppo di artisti "speciali" (titoli, legende delle figure, barre dei colori, ecc.) e persino delle sottofigure nidificate.

Il modo più semplice per creare una nuova figura è con pyplot:

fig = plt.figure()  # an empty figure with no Axes
fig, ax = plt.subplots()  # a figure with a single Axes
fig, axs = plt.subplots(2, 2)  # a figure with a 2x2 grid of Axes

Spesso è conveniente creare gli assi insieme alla figura, ma puoi anche aggiungere manualmente gli assi in un secondo momento. Si noti che molti backend Matplotlib supportano lo zoom e la panoramica sulle finestre delle figure.

Axes

Un Axes è un artista collegato a una figura che contiene una regione per tracciare i dati e di solito include due (o tre nel caso di 3D) Axisoggetti (attenzione alla differenza tra Axes e Axis ) che forniscono segni di spunta ed etichette di spunta da fornire scale per i dati negli assi. Ognuno Axesha anche un titolo (impostato tramite set_title()), un'etichetta x (impostata tramite set_xlabel()) e un'etichetta y impostata tramite set_ylabel()).

La Axesclasse e le sue funzioni membro sono il punto di ingresso principale per lavorare con l'interfaccia OOP e hanno la maggior parte dei metodi di tracciamento definiti su di esse (ad esempio ax.plot(), mostrato sopra, usa il plotmetodo)

Axis

Questi oggetti impostano la scala e i limiti e generano tick (i segni sull'asse) e ticklabel (stringhe che etichettano i tick). La posizione dei tick è determinata da un Locatoroggetto e le stringhe ticklabel sono formattate da un Formatter. La combinazione del corretto Locatore Formatteroffre un controllo molto preciso sulle posizioni e sulle etichette delle zecche.

Artist

Fondamentalmente, tutto ciò che è visibile sulla Figura è un Artista (anche Figure, Axes, e Axisoggetti). Ciò include Textoggetti, Line2Doggetti, collectionsoggetti, Patch oggetti, ecc. Quando viene eseguito il rendering della figura, tutti gli artisti vengono disegnati sulla tela . La maggior parte degli artisti è legata a un'Ascia; tale Artista non può essere condiviso da più Assi, né spostato da uno all'altro.

Tipi di input per le funzioni di tracciamento

Le funzioni di tracciamento prevedono numpy.arrayo numpy.ma.masked_arraycome input o oggetti che possono essere passati a numpy.asarray. Classi che sono simili agli array ('array-like') come gli pandas oggetti dati e numpy.matrixpotrebbero non funzionare come previsto. La convenzione comune è convertirli in numpy.arrayoggetti prima della stampa. Ad esempio, per convertire anumpy.matrix

b = np.matrix([[1, 2], [3, 4]])
b_asarray = np.asarray(b)

La maggior parte dei metodi analizzerà anche un oggetto indirizzabile come dict , a numpy.recarrayo a pandas.DataFrame. Matplotlib consente di fornire l' dataargomento della parola chiave e generare grafici passando le stringhe corrispondenti alle variabili x e y .

np.random.seed(19680801)  # seed the random number generator.
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

fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
ax.scatter('a', 'b', c='c', s='d', data=data)
ax.set_xlabel('entry a')
ax.set_ylabel('entry b');

Text(36.334, 0.5, 'entry b')

Stili di codifica

Le interfacce esplicite e implicite

Come notato sopra, ci sono essenzialmente due modi per usare Matplotlib:

• Crea in modo esplicito figure e assi e chiama metodi su di essi (lo "stile orientato agli oggetti (OO)").

• Affidati a pyplot per creare e gestire in modo implicito le figure e gli assi e usa le funzioni pyplot per la stampa.

Vedere Matplotlib Application Interfaces (API) per una spiegazione dei compromessi tra le interfacce implicite ed esplicite.

Quindi si può usare lo stile OO

x = np.linspace(0, 2, 100)  # Sample data.

# Note that even in the OO-style, we use `.pyplot.figure` to create the Figure.
fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
ax.plot(x, x, label='linear')  # Plot some data on the axes.
ax.plot(x, x**2, label='quadratic')  # Plot more data on the axes...
ax.plot(x, x**3, label='cubic')  # ... and some more.
ax.set_xlabel('x label')  # Add an x-label to the axes.
ax.set_ylabel('y label')  # Add a y-label to the axes.
ax.set_title("Simple Plot")  # Add a title to the axes.
ax.legend();  # Add a legend.

<matplotlib.legend.Legend object at 0x7f2cdf587f70>

o lo stile pyplot:

x = np.linspace(0, 2, 100)  # Sample data.

plt.figure(figsize=(5, 2.7), layout='constrained')
plt.plot(x, x, label='linear')  # Plot some data on the (implicit) axes.
plt.plot(x, x**2, label='quadratic')  # etc.
plt.plot(x, x**3, label='cubic')
plt.xlabel('x label')
plt.ylabel('y label')
plt.title("Simple Plot")
plt.legend();

<matplotlib.legend.Legend object at 0x7f2cfa992cb0>

(Inoltre, esiste un terzo approccio, per il caso in cui si incorpora Matplotlib in un'applicazione GUI, che elimina completamente pyplot, anche per la creazione di figure. Vedere la sezione corrispondente nella galleria per maggiori informazioni: Incorporamento di Matplotlib nelle interfacce utente grafiche .)

La documentazione e gli esempi di Matplotlib usano sia gli stili OO che pyplot. In generale, suggeriamo di utilizzare lo stile OO, in particolare per trame complicate e funzioni e script destinati a essere riutilizzati come parte di un progetto più ampio. Tuttavia, lo stile pyplot può essere molto utile per un rapido lavoro interattivo.

Nota

Potresti trovare esempi più vecchi che utilizzano l' pylabinterfaccia, tramite . Questo approccio è fortemente deprecato.from pylab import *

Far funzionare un aiutante

Se devi creare gli stessi grafici più e più volte con set di dati diversi o desideri avvolgere facilmente i metodi Matplotlib, utilizza la funzione di firma consigliata di seguito.

def my_plotter(ax, data1, data2, param_dict):
    """
    A helper function to make a graph.
    """
    out = ax.plot(data1, data2, **param_dict)
    return out

che useresti quindi due volte per popolare due sottotrame:

data1, data2, data3, data4 = np.random.randn(4, 100)  # make 4 random data sets
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(5, 2.7))
my_plotter(ax1, data1, data2, {'marker': 'x'})
my_plotter(ax2, data3, data4, {'marker': 'o'});

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

Si noti che se si desidera installarli come pacchetto Python o qualsiasi altra personalizzazione è possibile utilizzare uno dei tanti modelli sul Web; Matplotlib ne ha uno su mpl-cookiecutter

Artisti dello styling

La maggior parte dei metodi di plottaggio dispone di opzioni di stile per gli artisti, accessibili quando viene richiamato un metodo di plottaggio o da un "setter" nell'artista. Nella trama sottostante impostiamo manualmente il colore , la larghezza della linea e lo stile della linea degli Artisti creati da plot, e impostiamo lo stile della linea della seconda linea dopo il fatto con set_linestyle.

fig, ax = plt.subplots(figsize=(5, 2.7))
x = np.arange(len(data1))
ax.plot(x, np.cumsum(data1), color='blue', linewidth=3, linestyle='--')
l, = ax.plot(x, np.cumsum(data2), color='orange', linewidth=2)
l.set_linestyle(':');

Colori

Matplotlib ha una gamma di colori molto flessibile accettata dalla maggior parte degli artisti; vedere il tutorial sui colori per un elenco di specifiche. Alcuni artisti prenderanno più colori. cioè per una scattertrama, il bordo dei marcatori può essere di colori diversi dall'interno:

fig, ax = plt.subplots(figsize=(5, 2.7))
ax.scatter(data1, data2, s=50, facecolor='C0', edgecolor='k');

<matplotlib.collections.PathCollection object at 0x7f2cddcf8280>

Larghezza di linea, stili di linea e dimensioni dei marcatori

Gli spessori delle linee sono in genere in punti tipografici (1 pt = 1/72 di pollice) e sono disponibili per gli artisti che hanno linee tratteggiate. Allo stesso modo, le linee tratteggiate possono avere uno stile di linea. Vedere l' esempio di stili di linea .

La dimensione del marker dipende dal metodo utilizzato. plotspecifica la dimensione del marker in punti ed è generalmente il "diametro" o la larghezza del marker. scatterspecifica markersize come approssimativamente proporzionale all'area visiva del marker. C'è una serie di stili di marcatori disponibili come codici stringa (vedi markers), oppure gli utenti possono definirne di propri MarkerStyle(vedi Riferimento marcatore ):

fig, ax = plt.subplots(figsize=(5, 2.7))
ax.plot(data1, 'o', label='data1')
ax.plot(data2, 'd', label='data2')
ax.plot(data3, 'v', label='data3')
ax.plot(data4, 's', label='data4')
ax.legend();

<matplotlib.legend.Legend object at 0x7f2cfa946650>

Trame di etichettatura

Etichette e testo degli assi

set_xlabel, set_ylabel, e set_titlevengono utilizzati per aggiungere testo nelle posizioni indicate (vedere Text in Matplotlib Plots per ulteriori discussioni). Il testo può anche essere aggiunto direttamente ai grafici utilizzando text:

mu, sigma = 115, 15
x = mu + sigma * np.random.randn(10000)
fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
# the histogram of the data
n, bins, patches = ax.hist(x, 50, density=True, facecolor='C0', alpha=0.75)

ax.set_xlabel('Length [cm]')
ax.set_ylabel('Probability')
ax.set_title('Aardvark lengths\n (not really)')
ax.text(75, .025, r'$\mu=115,\ \sigma=15$')
ax.axis([55, 175, 0, 0.03])
ax.grid(True);

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

t = ax.set_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:

ax.set_title(r'$\sigma_i=15$')

dove la rprecedente stringa del titolo indica che la stringa è una stringa grezza 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 . Puoi anche usare LaTeX direttamente per formattare il tuo testo e incorporare l'output direttamente nelle tue figure di visualizzazione o postscript salvato - vedi Rendering del testo con LaTeX .

Annotazioni

Possiamo anche annotare punti su un grafico, spesso collegando una freccia che punta a xy , a una parte di testo in xytext :

fig, ax = plt.subplots(figsize=(5, 2.7))

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

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

ax.set_ylim(-2, 2);

(-2.0, 2.0)

In questo esempio di base, sia xy che xytext sono in coordinate 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 anche in Annotating Plots .

Leggende

Spesso vogliamo identificare linee o marcatori con un Axes.legend:

fig, ax = plt.subplots(figsize=(5, 2.7))
ax.plot(np.arange(len(data1)), data1, label='data1')
ax.plot(np.arange(len(data2)), data2, label='data2')
ax.plot(np.arange(len(data3)), data3, 'd', label='data3')
ax.legend();

<matplotlib.legend.Legend object at 0x7f2cde2aaa40>

Le leggende in Matplotlib sono abbastanza flessibili nel layout, nel posizionamento e negli artisti che possono rappresentare. Sono discussi in dettaglio nella guida Legend .

Scale e segni di spunta dell'asse

Ogni Asse ha due (o tre) Axisoggetti che rappresentano gli assi x e y. Questi controllano la scala dell'Asse, i tick locator e i tick formatters . Assi aggiuntivi possono essere collegati per visualizzare ulteriori oggetti Asse.

Bilance

Oltre alla scala lineare, Matplotlib fornisce scale non lineari, come una scala logaritmica. Poiché le scale logaritmiche sono utilizzate così tanto, esistono anche metodi diretti come loglog, semilogxe semilogy. Ci sono un certo numero di scale (vedi Scale per altri esempi). Qui impostiamo la scala manualmente:

fig, axs = plt.subplots(1, 2, figsize=(5, 2.7), layout='constrained')
xdata = np.arange(len(data1))  # make an ordinal for this
data = 10**data1
axs[0].plot(xdata, data)

axs[1].set_yscale('log')
axs[1].plot(xdata, data);

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

La scala imposta la mappatura dai valori dei dati alla spaziatura lungo l'asse. Ciò accade in entrambe le direzioni e viene combinato in un transform , che è il modo in cui Matplotlib mappa dalle coordinate dei dati ad Axes, Figure o coordinate dello schermo. Vedere Trasformazioni Tutorial .

Tick ​​locator e formattatori

Ogni Axis ha un tick locator e un formattatore che scelgono dove lungo gli oggetti Axis mettere i segni di graduazione. Una semplice interfaccia per questo è set_xticks:

fig, axs = plt.subplots(2, 1, layout='constrained')
axs[0].plot(xdata, data1)
axs[0].set_title('Automatic ticks')

axs[1].plot(xdata, data1)
axs[1].set_xticks(np.arange(0, 100, 30), ['zero', '30', 'sixty', '90'])
axs[1].set_yticks([-1.5, 0, 1.5])  # note that we don't need to specify labels
axs[1].set_title('Manual ticks');

Text(0.5, 1.0, 'Manual ticks')

Scale diverse possono avere localizzatori e formattatori diversi; ad esempio la scala logaritmica sopra utilizza LogLocatore LogFormatter. Vedere Tick locators e Tick formatters per altri formattatori e locator e informazioni per scriverne di propri.

Tracciare date e stringhe

Matplotlib può gestire il tracciamento di matrici di date e matrici di stringhe, nonché di numeri in virgola mobile. Questi ottengono localizzatori e formattatori speciali a seconda dei casi. Per le date:

fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
dates = np.arange(np.datetime64('2021-11-15'), np.datetime64('2021-12-25'),
                  np.timedelta64(1, 'h'))
data = np.cumsum(np.random.randn(len(dates)))
ax.plot(dates, data)
cdf = mpl.dates.ConciseDateFormatter(ax.xaxis.get_major_locator())
ax.xaxis.set_major_formatter(cdf);

Per ulteriori informazioni, vedere gli esempi di data (ad es. Date tick labels )

Per le stringhe, otteniamo grafici categorici (vedi: Tracciare variabili categoriche ).

fig, ax = plt.subplots(figsize=(5, 2.7), layout='constrained')
categories = ['turnips', 'rutabaga', 'cucumber', 'pumpkins']

ax.bar(categories, np.random.rand(len(categories)));

<BarContainer object of 4 artists>

Un avvertimento sul tracciato categorico è che alcuni metodi di analisi dei file di testo restituiscono un elenco di stringhe, anche se le stringhe rappresentano tutte numeri o date. Se passi 1000 stringhe, Matplotlib penserà che intendevi 1000 categorie e aggiungerà 1000 tick alla tua trama!

Oggetti Axis aggiuntivi

La rappresentazione di dati di grandezza diversa in un grafico può richiedere un asse y aggiuntivo. Tale asse può essere creato utilizzando twinxper aggiungere un nuovo asse con un asse x invisibile e un asse y posizionato a destra (analogamente per twiny). Vedi Grafici con scale diverse per un altro esempio.

Allo stesso modo, puoi aggiungere secondary_xaxiso secondary_yaxisavere una scala diversa dall'asse principale per rappresentare i dati in scale o unità diverse. Vedere Asse secondario per ulteriori esempi.

fig, (ax1, ax3) = plt.subplots(1, 2, figsize=(7, 2.7), layout='constrained')
l1, = ax1.plot(t, s)
ax2 = ax1.twinx()
l2, = ax2.plot(t, range(len(t)), 'C1')
ax2.legend([l1, l2], ['Sine (left)', 'Straight (right)'])

ax3.plot(t, s)
ax3.set_xlabel('Angle [rad]')
ax4 = ax3.secondary_xaxis('top', functions=(np.rad2deg, np.deg2rad))
ax4.set_xlabel('Angle [°]')

Text(0.5, 509.6660000000001, 'Angle [°]')

Dati mappati a colori

Spesso vogliamo avere una terza dimensione in una trama rappresentata da un colore in una mappa di colori. Matplotlib ha un numero di tipi di trama che fanno questo:

X, Y = np.meshgrid(np.linspace(-3, 3, 128), np.linspace(-3, 3, 128))
Z = (1 - X/2 + X**5 + Y**3) * np.exp(-X**2 - Y**2)

fig, axs = plt.subplots(2, 2, layout='constrained')
pc = axs[0, 0].pcolormesh(X, Y, Z, vmin=-1, vmax=1, cmap='RdBu_r')
fig.colorbar(pc, ax=axs[0, 0])
axs[0, 0].set_title('pcolormesh()')

co = axs[0, 1].contourf(X, Y, Z, levels=np.linspace(-1.25, 1.25, 11))
fig.colorbar(co, ax=axs[0, 1])
axs[0, 1].set_title('contourf()')

pc = axs[1, 0].imshow(Z**2 * 100, cmap='plasma',
                          norm=mpl.colors.LogNorm(vmin=0.01, vmax=100))
fig.colorbar(pc, ax=axs[1, 0], extend='both')
axs[1, 0].set_title('imshow() with LogNorm()')

pc = axs[1, 1].scatter(data1, data2, c=data3, cmap='RdBu_r')
fig.colorbar(pc, ax=axs[1, 1], extend='both')
axs[1, 1].set_title('scatter()')

Text(0.5, 1.0, 'scatter()')

Mappe dei colori

Sono tutti esempi di Artisti che derivano da ScalarMappable oggetti. Tutti possono impostare una mappatura lineare tra vmin e vmax nella mappa dei colori specificata da cmap . Matplotlib ha molte mappe di colori tra cui scegliere ( Scegliere mappe di colori in Matplotlib ) che puoi creare tu stesso ( Creazione di mappe di colori in Matplotlib ) o scaricare come pacchetti di terze parti .

Normalizzazioni

A volte vogliamo una mappatura non lineare dei dati sulla mappa dei colori, come LogNormnell'esempio sopra. Lo facciamo fornendo a ScalarMappable l' argomento norm invece di vmin e vmax . Altre normalizzazioni sono mostrate in Colormap Normalization .

Barre colore

L'aggiunta di a colorbarfornisce una chiave per correlare il colore ai dati sottostanti. Le barre dei colori sono Artisti a livello di figura e sono collegate a uno ScalarMappable (dove ottengono le loro informazioni sulla norma e sulla mappa dei colori) e di solito rubano spazio da un Asse genitore. Il posizionamento delle barre dei colori può essere complesso: vedere Posizionamento delle barre dei colori per i dettagli. Puoi anche modificare l'aspetto delle barre dei colori con la parola chiave extend per aggiungere frecce alle estremità, e shrink e aspect per controllarne le dimensioni. Infine, la barra dei colori avrà localizzatori e formattatori predefiniti adeguati alla norma. Questi possono essere modificati come per altri oggetti Axis.

Lavorare con più figure e assi

Puoi aprire più Figure con più chiamate a o . Mantenendo i riferimenti agli oggetti puoi aggiungere artisti a entrambe le figure.fig = plt.figure()fig2, ax = plt.subplots()

Più assi possono essere aggiunti in diversi modi, ma il più semplice è plt.subplots()quello usato sopra. È possibile ottenere layout più complessi, con oggetti Axes che si estendono su colonne o righe, utilizzando subplot_mosaic.

fig, axd = plt.subplot_mosaic([['upleft', 'right'],
                               ['lowleft', 'right']], layout='constrained')
axd['upleft'].set_title('upleft')
axd['lowleft'].set_title('lowleft')
axd['right'].set_title('right');

Text(0.5, 1.0, 'right')

Matplotlib ha strumenti abbastanza sofisticati per disporre gli assi: vedi Disporre più assi in una figura e Composizione di figure complesse e semantiche .

Altre letture

Per altri tipi di grafico, vedere i tipi di grafico e il riferimento API , in particolare l' API Axes .