Matplotlib - Guida rapida

Matplotlib è uno dei pacchetti Python più popolari utilizzati per la visualizzazione dei dati. È una libreria multipiattaforma per creare grafici 2D da dati in array. Matplotlib è scritto in Python e utilizza NumPy, l'estensione matematica numerica di Python. Fornisce un'API orientata agli oggetti che aiuta a incorporare grafici in applicazioni utilizzando toolkit GUI Python come PyQt, WxPythonotTkinter. Può essere utilizzato anche in shell Python e IPython, notebook Jupyter e server di applicazioni web.

Matplotlib ha un'interfaccia procedurale chiamata Pylab, progettata per assomigliare a MATLAB, un linguaggio di programmazione proprietario sviluppato da MathWorks. Matplotlib insieme a NumPy può essere considerato l'equivalente open source di MATLAB.

Matplotlib è stato originariamente scritto da John D. Hunter nel 2003. L'attuale versione stabile è 2.2.0 rilasciata nel gennaio 2018.

Matplotlib ei suoi pacchetti di dipendenze sono disponibili sotto forma di pacchetti wheel nei repository di pacchetti Python standard e possono essere installati su sistemi Windows, Linux e MacOS utilizzando il gestore pacchetti pip.

pip3 install matplotlib

Nel caso in cui le versioni Python 2.7 o 3.4 non siano installate per tutti gli utenti, è necessario installare i pacchetti ridistribuibili Microsoft Visual C ++ 2008 (64 bit o 32 bit per Python 2.7) o Microsoft Visual C ++ 2010 (64 bit o 32 bit per Python 3.4).

Se stai usando Python 2.7 su un Mac, esegui il seguente comando:

xcode-select –install

Dopo l'esecuzione del comando precedente, è possibile compilare il sottoprocesso32, una dipendenza.

Su versioni estremamente vecchie di Linux e Python 2.7, potrebbe essere necessario installare la versione master di subprocess32.

Matplotlib richiede un gran numero di dipendenze -

  • Python (> = 2,7 o> = 3,4)
  • NumPy
  • setuptools
  • dateutil
  • pyparsing
  • libpng
  • pytz
  • FreeType
  • cycler
  • six

Facoltativamente, puoi anche installare una serie di pacchetti per abilitare migliori toolkit per l'interfaccia utente.

  • tk
  • PyQt4
  • PyQt5
  • pygtk
  • wxpython
  • pycairo
  • Tornado

Per un migliore supporto del formato di output dell'animazione e dei formati di file immagine, LaTeX, ecc., È possibile installare quanto segue:

  • _mpeg/avconv
  • ImageMagick
  • Cuscino (> = 2.0)
  • LaTeX e GhostScript (per il rendering del testo con LaTeX).
  • LaTeX e GhostScript (per il rendering del testo con LaTeX).

Anaconda è una distribuzione gratuita e open source dei linguaggi di programmazione Python e R per elaborazione dati su larga scala, analisi predittiva e calcolo scientifico. La distribuzione rende la gestione e la distribuzione dei pacchetti semplici e facili. Matplotlib e molti altri utili strumenti scientifici (dati) fanno parte della distribuzione. Le versioni dei pacchetti sono gestite dal sistema di gestione dei pacchetti Conda. Il vantaggio di Anaconda è che hai accesso a oltre 720 pacchetti che possono essere facilmente installati con Conda di Anaconda, un pacchetto, dipendenza e gestore dell'ambiente.

La distribuzione di Anaconda è disponibile per l'installazione su https://www.anaconda.com/download/. Per l'installazione su Windows, sono disponibili binari a 32 e 64 bit -

https://repo.continuum.io/archive/Anaconda3-5.1.0-Windows-x86.exe

https://repo.continuum.io/archive/Anaconda3-5.1.0-Windows-x86_64.exe

L'installazione è un processo basato su una procedura guidata abbastanza semplice. Puoi scegliere tra l'aggiunta di Anaconda nella variabile PATH e la registrazione di Anaconda come Python predefinito.

Per l'installazione su Linux, scarica i programmi di installazione per i programmi di installazione a 32 bit e 64 bit dalla pagina dei download -

https://repo.continuum.io/archive/Anaconda3-5.1.0-Linux-x86.sh

https://repo.continuum.io/archive/Anaconda3-5.1.0-Linux-x86_64.sh

Ora, esegui il seguente comando dal terminale Linux:

$ bash Anaconda3-5.0.1-Linux-x86_64.sh

Canopy e ActiveState sono le scelte più ricercate per Windows, macOS e piattaforme Linux comuni. Gli utenti Windows possono trovare un'opzione in WinPython.

Jupyter è un acronimo che significa Julia, Python e R. Questi linguaggi di programmazione sono stati i primi linguaggi di destinazione dell'applicazione Jupyter, ma oggigiorno la tecnologia notebook supporta anche molti altri linguaggi.

Nel 2001, Fernando Pérez ha iniziato a sviluppare Ipython. IPython è una shell di comandi per il calcolo interattivo in più linguaggi di programmazione, originariamente sviluppata per Python.

Considera le seguenti funzionalità fornite da IPython:

  • Shell interattive (terminale e basate su Qt).

  • Un notebook basato su browser con supporto per codice, testo, espressioni matematiche, grafici in linea e altri media.

  • Supporto per la visualizzazione interattiva dei dati e l'uso di toolkit GUI.

  • Interpreti flessibili e incorporabili da caricare nei propri progetti.

Nel 2014, Fernando Pérez ha annunciato un progetto spin-off di IPython chiamato Project Jupyter. IPython continuerà ad esistere come shell Python e kernel per Jupyter, mentre il notebook e altre parti indipendenti dal linguaggio di IPython si sposteranno con il nome Jupyter. Jupyter ha aggiunto il supporto per Julia, R, Haskell e Ruby.

Per avviare il notebook Jupyter, apri Anaconda navigator (un'interfaccia utente grafica desktop inclusa in Anaconda che consente di avviare applicazioni e gestire facilmente pacchetti, ambienti e canali Conda senza la necessità di utilizzare comandi da riga di comando).

Navigator mostra i componenti installati nella distribuzione.

Avvia Jupyter Notebook dal Navigatore -

Vedrai l'apertura dell'applicazione nel browser web al seguente indirizzo: http://localhost:8888.

Probabilmente vorrai iniziare creando un nuovo taccuino. Puoi farlo facilmente facendo clic sul pulsante "Nuovo" nella "scheda File". Vedi che hai la possibilità di creare un normale file di testo, una cartella e un terminale. Infine, vedrai anche l'opzione per creare un notebook Python 3.

Un nuovo taccuino senza titolo con l'estensione .ipynbl'estensione (sta per il notebook IPython) viene visualizzata nella nuova scheda del browser.

matplotlib.pyplotè una raccolta di funzioni in stile comando che fanno funzionare Matplotlib come MATLAB. Ogni funzione Pyplot apporta alcune modifiche a una figura. Ad esempio, una funzione crea una figura, un'area di stampa in una figura, traccia alcune linee in un'area di stampa, decora la trama con etichette, ecc.

Tipi di grafici

Suor n Descrizione della funzione
1

Bar

Crea un grafico da bar.

2

Barh

Crea un grafico a barre orizzontali.

3

Boxplot

Crea un diagramma a scatola e baffi.

4

Hist

Traccia un istogramma.

5

hist2d

Crea un grafico a istogramma 2D.

6

Pie

Traccia un grafico a torta.

7

Plot

Traccia linee e / o indicatori sugli assi.

8

Polar

Crea un diagramma polare ..

9

Scatter

Crea un grafico a dispersione di x vs y.

10

Stackplot

Disegna un grafico ad area in pila.

11

Stem

Crea un grafico a stelo.

12

Step

Crea un grafico a gradini.

13

Quiver

Traccia un campo di frecce 2-D.

Funzioni immagine

Suor n Descrizione della funzione
1

Imread

Legge un'immagine da un file in un array.

2

Imsave

Salva un array come file immagine.

3

Imshow

Visualizza un'immagine sugli assi.

Funzioni degli assi

Suor n Descrizione della funzione
1

Axes

Aggiungi assi alla figura.

2

Text

Aggiungi testo agli assi.

3

Title

Imposta un titolo per gli assi correnti.

4

Xlabel

Imposta l'etichetta dell'asse x dell'asse corrente.

5

Xlim

Ottieni o imposta i limiti x degli assi correnti.

6

Xscale

.

7

Xticks

Ottieni o imposta i limiti x delle posizioni e delle etichette dei tick correnti.

8

Ylabel

Imposta l'etichetta dell'asse y dell'asse corrente.

9

Ylim

Ottieni o imposta i limiti y degli assi correnti.

10

Yscale

Imposta la scala dell'asse y.

11

Yticks

Ottieni o imposta i limiti y delle posizioni e delle etichette dei tick correnti.

Funzioni di figura

Suor n Descrizione della funzione
1

Figtext

Aggiungi testo alla figura.

2

Figure

Crea una nuova figura.

3

Show

Mostra una figura.

4

Savefig

Salva la cifra attuale.

5

Close

Chiudere una finestra della figura.

In questo capitolo impareremo come creare una trama semplice con Matplotlib.

Ora visualizzeremo un semplice grafico a linee dell'angolo in radianti rispetto al suo valore di seno in Matplotlib. Per cominciare, il modulo Pyplot dal pacchetto Matplotlib viene importato, con un alias plt per convenzione.

import matplotlib.pyplot as plt

Successivamente abbiamo bisogno di una matrice di numeri da tracciare. Varie funzioni di array sono definite nella libreria NumPy importata con l'alias np.

import numpy as np

Ora otteniamo l'oggetto ndarray di angoli tra 0 e 2π usando la funzione arange () dalla libreria NumPy.

x = np.arange(0, math.pi*2, 0.05)

L'oggetto ndarray funge da valori sull'asse x del grafico. I corrispondenti valori del seno degli angoli in x da visualizzare sull'asse y sono ottenuti dalla seguente dichiarazione:

y = np.sin(x)

I valori di due array vengono tracciati utilizzando la funzione plot ().

plt.plot(x,y)

È possibile impostare il titolo del grafico e le etichette per gli assi x e y.

You can set the plot title, and labels for x and y axes.
plt.xlabel("angle")
plt.ylabel("sine")
plt.title('sine wave')

La finestra del visualizzatore di grafico viene richiamata dalla funzione show () -

plt.show()

Il programma completo è il seguente:

from matplotlib import pyplot as plt
import numpy as np
import math #needed for definition of pi
x = np.arange(0, math.pi*2, 0.05)
y = np.sin(x)
plt.plot(x,y)
plt.xlabel("angle")
plt.ylabel("sine")
plt.title('sine wave')
plt.show()

Quando viene eseguita la riga di codice sopra, viene visualizzato il grafico seguente:

Ora usa il notebook Jupyter con Matplotlib.

Avvia il notebook Jupyter dal navigatore Anaconda o dalla riga di comando come descritto in precedenza. Nella cella di input, inserisci le istruzioni di importazione per Pyplot e NumPy -

from matplotlib import pyplot as plt
import numpy as np

Per visualizzare gli output della trama all'interno del taccuino stesso (e non nel visualizzatore separato), inserisci la seguente istruzione magica:

%matplotlib inline

Ottieni x come oggetto ndarray contenente angoli in radianti compresi tra 0 e 2π e y come valore del seno di ciascun angolo -

import math
x = np.arange(0, math.pi*2, 0.05)
y = np.sin(x)

Imposta le etichette per gli assi x e y così come il titolo del grafico -

plt.xlabel("angle")
plt.ylabel("sine")
plt.title('sine wave')

Infine, esegui la funzione plot () per generare la visualizzazione dell'onda sinusoidale nel notebook (non è necessario eseguire la funzione show ()) -

plt.plot(x,y)

Dopo l'esecuzione dell'ultima riga di codice, viene visualizzato il seguente output:

PyLab è un'interfaccia procedurale per la libreria di plottaggio orientata agli oggetti Matplotlib. Matplotlib è l'intero pacchetto; matplotlib.pyplot è un modulo in Matplotlib; e PyLab è un modulo che viene installato insieme a Matplotlib.

PyLab è un comodo modulo che importa in blocco matplotlib.pyplot (per il plottaggio) e NumPy (per la matematica e lavorare con gli array) in un unico spazio dei nomi. Sebbene molti esempi utilizzino PyLab, non è più consigliato.

Stampa di base

Il tracciamento delle curve viene eseguito con il comando Stampa. Richiede una coppia di array (o sequenze) della stessa lunghezza -

from numpy import *
from pylab import *
x = linspace(-3, 3, 30)
y = x**2
plot(x, y)
show()

La riga di codice precedente genera il seguente output:

Per tracciare simboli anziché linee, fornire un argomento stringa aggiuntivo.

simboli -, -, -.,,. ,,, o, ^, v, <,>, s, +, x, D, d, 1, 2, 3, 4, h, H, p, | , _
colori b, g, r, c, m, y, k, w

Ora, considera di eseguire il seguente codice:

from pylab import *
x = linspace(-3, 3, 30)
y = x**2
plot(x, y, 'r.')
show()

Traccia i punti rossi come mostrato di seguito -

I grafici possono essere sovrapposti. Usa semplicemente i comandi multipli della trama. Usa clf () per cancellare il grafico.

from pylab import *
plot(x, sin(x))
plot(x, cos(x), 'r-')
plot(x, -sin(x), 'g--')
show()

La riga di codice precedente genera il seguente output:

Sebbene sia facile generare rapidamente grafici con l'estensione matplotlib.pyplotmodulo, l'uso dell'approccio orientato agli oggetti è consigliato in quanto offre un maggiore controllo e personalizzazione dei grafici. La maggior parte delle funzioni sono disponibili anche inmatplotlib.axes.Axes classe.

L'idea principale alla base dell'utilizzo del metodo orientato agli oggetti più formale è creare oggetti figura e quindi chiamare semplicemente metodi o attributi da quell'oggetto. Questo approccio aiuta a gestire meglio una tela che ha più trame su di essa.

Nell'interfaccia orientata agli oggetti, Pyplot viene utilizzato solo per alcune funzioni come la creazione di figure e l'utente crea esplicitamente e tiene traccia degli oggetti figura e assi. A questo livello, l'utente utilizza Pyplot per creare figure e attraverso queste figure è possibile creare uno o più oggetti assi. Questi oggetti assi vengono quindi utilizzati per la maggior parte delle azioni di stampa.

Per cominciare, creiamo un'istanza di figura che fornisce una tela vuota.

fig = plt.figure()

Ora aggiungi gli assi alla figura. Iladd_axes()richiede un oggetto lista di 4 elementi corrispondenti a sinistra, fondo, larghezza e altezza della figura. Ogni numero deve essere compreso tra 0 e 1 -

ax=fig.add_axes([0,0,1,1])

Imposta le etichette per gli assi x e y oltre al titolo -

ax.set_title("sine wave")
ax.set_xlabel('angle')
ax.set_ylabel('sine')

Richiama il metodo plot () dell'oggetto axes.

ax.plot(x,y)

Se stai usando Jupyter notebook, la direttiva inline% matplotlib deve essere emessa; la funzione otherwistshow () del modulo pyplot mostra il grafico.

Considera di eseguire il codice seguente:

from matplotlib import pyplot as plt
import numpy as np
import math
x = np.arange(0, math.pi*2, 0.05)
y = np.sin(x)
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.plot(x,y)
ax.set_title("sine wave")
ax.set_xlabel('angle')
ax.set_ylabel('sine')
plt.show()

Produzione

La riga di codice precedente genera il seguente output:

Lo stesso codice quando viene eseguito nel notebook Jupyter mostra l'output come mostrato di seguito -

Il matplotlib.figureIl modulo contiene la classe Figure. È un contenitore di primo livello per tutti gli elementi della trama. L'oggetto Figure viene istanziato chiamando ilfigure() funzione dal modulo pyplot -

fig = plt.figure()

La tabella seguente mostra i parametri aggiuntivi:

Figsize (larghezza, altezza) tupla in pollici
Dpi Punti per pollice
Facecolor Figura patch facecolor
Edgecolor Colore del bordo della toppa della figura
Larghezza della linea Larghezza della linea del bordo

L'oggetto Axes è la regione dell'immagine con lo spazio dati. Una data figura può contenere molti assi, ma un dato oggetto Axes può essere solo in una figura. Axes contiene due (o tre nel caso di 3D) oggetti Axis. La classe Axes e le sue funzioni membro sono il punto di ingresso principale per lavorare con l'interfaccia OO.

L'oggetto Axes viene aggiunto alla figura chiamando il metodo add_axes (). Restituisce l'oggetto assi e aggiunge un asse alla posizione rect [sinistra, fondo, larghezza, altezza] dove tutte le quantità sono in frazioni di larghezza e altezza della figura.

Parametro

Di seguito è riportato il parametro per la classe Axes:

  • rect - Una sequenza di 4 lunghezze di quantità [sinistra, fondo, larghezza, altezza].

ax=fig.add_axes([0,0,1,1])

Le seguenti funzioni membro della classe axes aggiungono diversi elementi al grafico:

Leggenda

Il legend()Il metodo della classe degli assi aggiunge una legenda alla figura del grafico. Ci vogliono tre parametri:

ax.legend(handles, labels, loc)

Dove etichette è una sequenza di stringhe e gestisce una sequenza di istanze Line2D o Patch. loc può essere una stringa o un numero intero che specifica la posizione della legenda.

Stringa di posizione Codice posizione
Migliore 0
In alto a destra 1
superiore sinistro 2
in basso a sinistra 3
in basso a destra 4
Destra 5
Centro sinistra 6
Centro destra 7
centro inferiore 8
centro superiore 9
Centro 10

axes.plot ()

Questo è il metodo di base della classe degli assi che traccia i valori di un array rispetto a un altro come linee o indicatori. Il metodo plot () può avere un argomento stringa di formato opzionale per specificare il colore, lo stile e la dimensione della linea e dell'indicatore.

Codici colore

Personaggio Colore
'b' Blu
'g' verde
'r' Rosso
'b' Blu
'c' Ciano
'm' Magenta
'y' Giallo
'K' Nero
'b' Blu
'w' bianca

Codici dei marker

Personaggio Descrizione
"." Indicatore di punto
'o' Marcatore cerchio
'X' Marcatore X.
"D" Marcatore di diamanti
'H' Marcatore esagonale
'S' Indicatore quadrato
"+" Pennarello Plus

Stili di linea

Personaggio Descrizione
'-' Linea continua
'-' Linea tratteggiata
"-." Linea tratteggiata
':' Linea tratteggiata
'H' Marcatore esagonale

L'esempio seguente mostra le spese pubblicitarie e i dati di vendita di TV e smartphone sotto forma di grafici. La linea che rappresenta la TV è una linea continua con colori gialli e indicatori quadrati, mentre la linea dello smartphone è una linea tratteggiata con colore verde e un indicatore circolare.

import matplotlib.pyplot as plt
y = [1, 4, 9, 16, 25,36,49, 64]
x1 = [1, 16, 30, 42,55, 68, 77,88]
x2 = [1,6,12,18,28, 40, 52, 65]
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
l1 = ax.plot(x1,y,'ys-') # solid line with yellow colour and square marker
l2 = ax.plot(x2,y,'go--') # dash line with green colour and circle marker
ax.legend(labels = ('tv', 'Smartphone'), loc = 'lower right') # legend placed at lower right
ax.set_title("Advertisement effect on sales")
ax.set_xlabel('medium')
ax.set_ylabel('sales')
plt.show()

Quando la riga di codice sopra viene eseguita, produce il seguente grafico:

In questo capitolo impareremo come creare più sottotrame sulla stessa tela.

Il subplot()restituisce l'oggetto assi in una data posizione della griglia. La firma della chiamata di questa funzione è:

plt.subplot(subplot(nrows, ncols, index)

Nella figura corrente, la funzione crea e restituisce un oggetto Axes, all'indice di posizione di una griglia di nrows per ncolsaxes. Gli indici vanno da 1 a nrows * ncols, con incremento in ordine di riga maggiore. Ifnrows, ncols e index sono tutti inferiori a 10. Gli indici possono anche essere forniti come numero singolo, concatenato, a tre cifre.

Ad esempio, sottotrama (2, 3, 3) e sottotrama (233) creano entrambi un Asse nell'angolo in alto a destra della figura corrente, occupando metà dell'altezza della figura e un terzo della larghezza della figura.

La creazione di una sottotrama eliminerà qualsiasi sottotrama preesistente che si sovrappone ad essa oltre la condivisione di un confine.

import matplotlib.pyplot as plt
# plot a line, implicitly creating a subplot(111)
plt.plot([1,2,3])
# now create a subplot which represents the top plot of a grid with 2 rows and 1 column.
#Since this subplot will overlap the first, the plot (and its axes) previously 
created, will be removed
plt.subplot(211)
plt.plot(range(12))
plt.subplot(212, facecolor='y') # creates 2nd subplot with yellow background
plt.plot(range(12))

La riga di codice precedente genera il seguente output:

La funzione add_subplot () della classe figure non sovrascriverà il grafico esistente -

import matplotlib.pyplot as plt
fig = plt.figure()
ax1 = fig.add_subplot(111)
ax1.plot([1,2,3])
ax2 = fig.add_subplot(221, facecolor='y')
ax2.plot([1,2,3])

Quando la riga di codice precedente viene eseguita, genera il seguente output:

È possibile aggiungere un grafico a inserti nella stessa figura aggiungendo un altro oggetto assi nella stessa tela della figura.

import matplotlib.pyplot as plt
import numpy as np
import math
x = np.arange(0, math.pi*2, 0.05)
fig=plt.figure()
axes1 = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # main axes
axes2 = fig.add_axes([0.55, 0.55, 0.3, 0.3]) # inset axes
y = np.sin(x)
axes1.plot(x, y, 'b')
axes2.plot(x,np.cos(x),'r')
axes1.set_title('sine')
axes2.set_title("cosine")
plt.show()

All'esecuzione della riga di codice precedente, viene generato il seguente output:

Matplotlib'spyplot API ha una comoda funzione chiamata subplots () che funge da wrapper di utilità e aiuta a creare layout comuni di sottotrame, incluso l'oggetto figura che lo racchiude, in una singola chiamata.

Plt.subplots(nrows, ncols)

I due argomenti interi di questa funzione specificano il numero di righe e colonne della griglia del subplot. La funzione restituisce un oggetto figura e una tupla contenente oggetti assi uguali a nrows * ncols. Ogni oggetto degli assi è accessibile dal suo indice. Qui creiamo una sottotrama di 2 righe per 2 colonne e visualizziamo 4 diverse trame in ciascuna sottotrama.

import matplotlib.pyplot as plt
fig,a =  plt.subplots(2,2)
import numpy as np
x = np.arange(1,5)
a[0][0].plot(x,x*x)
a[0][0].set_title('square')
a[0][1].plot(x,np.sqrt(x))
a[0][1].set_title('square root')
a[1][0].plot(x,np.exp(x))
a[1][0].set_title('exp')
a[1][1].plot(x,np.log10(x))
a[1][1].set_title('log')
plt.show()

La riga di codice precedente genera il seguente output:

Questa funzione offre maggiore flessibilità nella creazione di un oggetto assi in una posizione specifica della griglia. Consente inoltre di estendere l'oggetto assi su più righe o colonne.

Plt.subplot2grid(shape, location, rowspan, colspan)

Nell'esempio seguente, una griglia 3X3 dell'oggetto figura è riempita con oggetti assi di dimensioni variabili in intervalli di righe e colonne, ciascuno con un grafico diverso.

import matplotlib.pyplot as plt
a1 = plt.subplot2grid((3,3),(0,0),colspan = 2)
a2 = plt.subplot2grid((3,3),(0,2), rowspan = 3)
a3 = plt.subplot2grid((3,3),(1,0),rowspan = 2, colspan = 2)
import numpy as np
x = np.arange(1,10)
a2.plot(x, x*x)
a2.set_title('square')
a1.plot(x, np.exp(x))
a1.set_title('exp')
a3.plot(x, np.log(x))
a3.set_title('log')
plt.tight_layout()
plt.show()

All'esecuzione del codice di riga sopra, viene generato il seguente output:

La funzione grid () dell'oggetto assi imposta la visibilità della griglia all'interno della figura su on o off. Puoi anche visualizzare le tacche maggiori / minori (o entrambe) della griglia. Inoltre, le proprietà di colore, stile di linea e larghezza di riga possono essere impostate nella funzione grid ().

import matplotlib.pyplot as plt
import numpy as np
fig, axes = plt.subplots(1,3, figsize = (12,4))
x = np.arange(1,11)
axes[0].plot(x, x**3, 'g',lw=2)
axes[0].grid(True)
axes[0].set_title('default grid')
axes[1].plot(x, np.exp(x), 'r')
axes[1].grid(color='b', ls = '-.', lw = 0.25)
axes[1].set_title('custom grid')
axes[2].plot(x,x)
axes[2].set_title('no grid')
fig.tight_layout()
plt.show()

A volte, uno o pochi punti sono molto più grandi della maggior parte dei dati. In tal caso, la scala di un asse deve essere impostata come logaritmica anziché come scala normale. Questa è la scala logaritmica. In Matplotlib, è possibile impostare la proprietà xscale o vscale dell'oggetto axes su "log".

A volte è anche necessario mostrare una distanza aggiuntiva tra i numeri degli assi e l'etichetta dell'asse. La proprietà labelpad di uno degli assi (x o y o entrambi) può essere impostata sul valore desiderato.

Entrambe le caratteristiche di cui sopra sono dimostrate con l'aiuto del seguente esempio. La sottotrama a destra ha una scala logaritmica e quella a sinistra ha il suo asse x con etichetta a maggiore distanza.

import matplotlib.pyplot as plt
import numpy as np
fig, axes = plt.subplots(1, 2, figsize=(10,4))
x = np.arange(1,5)
axes[0].plot( x, np.exp(x))
axes[0].plot(x,x**2)
axes[0].set_title("Normal scale")
axes[1].plot (x, np.exp(x))
axes[1].plot(x, x**2)
axes[1].set_yscale("log")
axes[1].set_title("Logarithmic scale (y)")
axes[0].set_xlabel("x axis")
axes[0].set_ylabel("y axis")
axes[0].xaxis.labelpad = 10
axes[1].set_xlabel("x axis")
axes[1].set_ylabel("y axis")
plt.show()

I dorsi degli assi sono le linee che collegano i segni di graduazione dell'asse che delimitano i confini dell'area del tracciato. L'oggetto assi ha spine situate in alto, in basso, a sinistra ea destra.

Ogni dorso può essere formattato specificando colore e larghezza. Qualsiasi bordo può essere reso invisibile se il suo colore è impostato su nessuno.

import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.spines['bottom'].set_color('blue')
ax.spines['left'].set_color('red')
ax.spines['left'].set_linewidth(2)
ax.spines['right'].set_color(None)
ax.spines['top'].set_color(None)
ax.plot([1,2,3,4,5])
plt.show()

Matplotlib arriva automaticamente ai valori minimo e massimo delle variabili da visualizzare lungo gli assi x, y (e z in caso di grafico 3D) di un grafico. Tuttavia, è possibile impostare i limiti in modo esplicito utilizzandoset_xlim() e set_ylim() funzioni.

Nel grafico seguente vengono mostrati i limiti in scala automatica degli assi xey:

import matplotlib.pyplot as plt
fig = plt.figure()
a1 = fig.add_axes([0,0,1,1])
import numpy as np
x = np.arange(1,10)
a1.plot(x, np.exp(x))
a1.set_title('exp')
plt.show()

Ora formattiamo i limiti sull'asse x su (da 0 a 10) e sull'asse y (da 0 a 10000) -

import matplotlib.pyplot as plt
fig = plt.figure()
a1 = fig.add_axes([0,0,1,1])
import numpy as np
x = np.arange(1,10)
a1.plot(x, np.exp(x),'r')
a1.set_title('exp')
a1.set_ylim(0,10000)
a1.set_xlim(0,10)
plt.show()

Le zecche sono i marcatori che indicano i punti dati sugli assi. Finora Matplotlib ha assunto automaticamente, in tutti i nostri esempi precedenti, il compito di spaziare i punti sull'asse. Gli indicatori di graduazione predefiniti e i formattatori di Matplotlib sono progettati per essere generalmente sufficienti in molte situazioni comuni. La posizione e le etichette delle zecche possono essere menzionate esplicitamente per soddisfare requisiti specifici.

Il xticks() e yticks()funzione accetta un oggetto lista come argomento. Gli elementi nell'elenco indicano le posizioni sull'azione corrispondente in cui verranno visualizzati i segni di spunta.

ax.set_xticks([2,4,6,8,10])

Questo metodo segnerà i punti dati nelle posizioni date con delle zecche.

Allo stesso modo, le etichette corrispondenti ai segni di graduazione possono essere impostate da set_xlabels() e set_ylabels() funzioni rispettivamente.

ax.set_xlabels([‘two’, ‘four’,’six’, ‘eight’, ‘ten’])

Questo mostrerà le etichette di testo sotto i marcatori sull'asse x.

L'esempio seguente mostra l'uso di segni di spunta ed etichette.

import matplotlib.pyplot as plt
import numpy as np
import math
x = np.arange(0, math.pi*2, 0.05)
fig = plt.figure()
ax = fig.add_axes([0.1, 0.1, 0.8, 0.8]) # main axes
y = np.sin(x)
ax.plot(x, y)
ax.set_xlabel(‘angle’)
ax.set_title('sine')
ax.set_xticks([0,2,4,6])
ax.set_xticklabels(['zero','two','four','six'])
ax.set_yticks([-1,0,1])
plt.show()

Si ritiene utile avere due assi x o y in una figura. Moreso, quando si tracciano curve con unità diverse insieme. Matplotlib lo supporta con le funzioni twinx e twiny.

Nell'esempio seguente, il grafico ha due assi y, uno che mostra exp (x) e l'altro che mostra log (x) -

import matplotlib.pyplot as plt
import numpy as np
fig = plt.figure()
a1 = fig.add_axes([0,0,1,1])
x = np.arange(1,11)
a1.plot(x,np.exp(x))
a1.set_ylabel('exp')
a2 = a1.twinx()
a2.plot(x, np.log(x),'ro-')
a2.set_ylabel('log')
fig.legend(labels = ('exp','log'),loc='upper left')
plt.show()

Un grafico a barre o un grafico a barre è un grafico o un grafico che presenta dati categoriali con barre rettangolari con altezze o lunghezze proporzionali ai valori che rappresentano. Le barre possono essere tracciate verticalmente o orizzontalmente.

Un grafico a barre mostra i confronti tra categorie discrete. Un asse del grafico mostra le categorie specifiche da confrontare e l'altro asse rappresenta un valore misurato.

L'API Matplotlib fornisce l'estensione bar()funzione che può essere utilizzata nell'uso in stile MATLAB così come API orientata agli oggetti. La firma della funzione bar () da utilizzare con l'oggetto assi è la seguente:

ax.bar(x, height, width, bottom, align)

La funzione crea un grafico a barre con il rettangolo di dimensione delimitato (x −width = 2; x + width = 2; bottom; bottom + height).

I parametri della funzione sono:

X sequenza di scalari che rappresentano le coordinate x delle barre. allinea i controlli se x è il centro della barra (predefinito) o il bordo sinistro.
altezza scalare o sequenza di scalari che rappresentano l'altezza (e) delle barre.
larghezza scalare o tipo array, opzionale. la larghezza (e) delle barre è di default 0,8
parte inferiore scalare o tipo array, opzionale. le coordinate y delle barre sono predefinite Nessuno.
allineare {"center", "edge"}, facoltativo, "center" predefinito

La funzione restituisce un oggetto contenitore Matplotlib con tutte le barre.

Di seguito è riportato un semplice esempio del grafico a barre Matplotlib. Mostra il numero di studenti iscritti a vari corsi offerti presso un istituto.

import matplotlib.pyplot as plt
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
langs = ['C', 'C++', 'Java', 'Python', 'PHP']
students = [23,17,35,29,12]
ax.bar(langs,students)
plt.show()

Quando si confrontano più quantità e quando si modifica una variabile, potremmo volere un grafico a barre in cui abbiamo barre di un colore per un valore di quantità.

Possiamo tracciare più grafici a barre giocando con lo spessore e le posizioni delle barre. La variabile di dati contiene tre serie di quattro valori. Il seguente script mostrerà tre grafici a barre di quattro barre. Le barre avranno uno spessore di 0,25 unità. Ogni grafico a barre verrà spostato di 0,25 unità rispetto a quello precedente. L'oggetto dati è un multidict contenente il numero di studenti passati in tre rami di un college di ingegneria negli ultimi quattro anni.

import numpy as np
import matplotlib.pyplot as plt
data = [[30, 25, 50, 20],
[40, 23, 51, 17],
[35, 22, 45, 19]]
X = np.arange(4)
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.bar(X + 0.00, data[0], color = 'b', width = 0.25)
ax.bar(X + 0.25, data[1], color = 'g', width = 0.25)
ax.bar(X + 0.50, data[2], color = 'r', width = 0.25)

Il grafico a barre in pila impila le barre che rappresentano diversi gruppi uno sopra l'altro. L'altezza della barra risultante mostra il risultato combinato dei gruppi.

Il parametro inferiore opzionale di pyplot.bar()funzione consente di specificare un valore iniziale per una barra. Invece di andare da zero a un valore, andrà dal basso al valore. La prima chiamata a pyplot.bar () traccia le barre blu. La seconda chiamata a pyplot.bar () traccia le barre rosse, con la parte inferiore delle barre blu nella parte superiore delle barre rosse.

import numpy as np
import matplotlib.pyplot as plt
N = 5
menMeans = (20, 35, 30, 35, 27)
womenMeans = (25, 32, 34, 20, 25)
ind = np.arange(N) # the x locations for the groups
width = 0.35
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.bar(ind, menMeans, width, color='r')
ax.bar(ind, womenMeans, width,bottom=menMeans, color='b')
ax.set_ylabel('Scores')
ax.set_title('Scores by group and gender')
ax.set_xticks(ind, ('G1', 'G2', 'G3', 'G4', 'G5'))
ax.set_yticks(np.arange(0, 81, 10))
ax.legend(labels=['Men', 'Women'])
plt.show()

Un istogramma è una rappresentazione accurata della distribuzione dei dati numerici. È una stima della distribuzione di probabilità di una variabile continua. È una specie di grafico a barre.

Per costruire un istogramma, segui questi passaggi:

  • Bin l'intervallo di valori.
  • Dividi l'intero intervallo di valori in una serie di intervalli.
  • Contare quanti valori rientrano in ogni intervallo.

I bin sono generalmente specificati come intervalli consecutivi e non sovrapposti di una variabile.

Il matplotlib.pyplot.hist()la funzione traccia un istogramma. Calcola e disegna l'istogramma di x.

Parametri

La tabella seguente elenca i parametri per un istogramma:

X matrice o sequenza di matrici
bidoni numero intero o sequenza o 'auto', opzionale
parametri opzionali
gamma La gamma inferiore e superiore dei bidoni.
densità Se True, il primo elemento della tupla di ritorno saranno i conteggi normalizzati per formare una densità di probabilità
cumulativo Se True, viene calcolato un istogramma in cui ogni bin fornisce i conteggi in quel bin più tutti i bin per valori inferiori.
histtype Il tipo di istogramma da disegnare. L'impostazione predefinita è "bar"
  • "bar" è un istogramma di tipo barra tradizionale. Se vengono forniti più dati, le barre vengono disposte una accanto all'altra.
  • 'barstacked' è un istogramma di tipo barra in cui più dati sono impilati uno sopra l'altro.
  • 'step' genera un lineplot che per impostazione predefinita non è compilato.
  • "stepfilled" genera un lineplot riempito per impostazione predefinita.

L'esempio seguente traccia un istogramma dei voti ottenuti dagli studenti in una classe. Sono definiti quattro bin, 0-25, 26-50, 51-75 e 76-100. L'istogramma mostra il numero di studenti che rientrano in questo intervallo.

from matplotlib import pyplot as plt
import numpy as np
fig,ax = plt.subplots(1,1)
a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27])
ax.hist(a, bins = [0,25,50,75,100])
ax.set_title("histogram of result")
ax.set_xticks([0,25,50,75,100])
ax.set_xlabel('marks')
ax.set_ylabel('no. of students')
plt.show()

La trama appare come mostrato di seguito -

Un grafico a torta può visualizzare solo una serie di dati. I grafici a torta mostrano la dimensione degli elementi (denominata fetta) in una serie di dati, proporzionale alla somma degli elementi. I punti dati in un grafico a torta vengono visualizzati come percentuale dell'intera torta.

L'API Matplotlib ha un'estensione pie()funzione che genera un diagramma a torta che rappresenta i dati in un array. L'area frazionaria di ogni cuneo è data dax/sum(x). Se sum (x) <1, i valori di x forniscono direttamente l'area frazionaria e l'array non verrà normalizzato. La torta risultante avrà una fetta vuota di dimensione 1 - sum (x).

Il grafico a torta ha un aspetto migliore se la figura e gli assi sono quadrati o se l'aspetto Assi è uguale.

Parametri

La tabella seguente elenca i parametri per un grafico a torta:

X come un array. Le dimensioni del cuneo.
etichette elenco. Una sequenza di stringhe che fornisce le etichette per ogni fetta.
Colori Una sequenza di matplotlibcolorarg attraverso i quali scorre il grafico a torta. Se Nessuno, utilizzerà i colori nel ciclo attualmente attivo.
Autopct stringa, utilizzata per etichettare le fette con il loro valore numerico. L'etichetta verrà posizionata all'interno del cuneo. La stringa di formato sarà fmt% pct.

Il codice seguente utilizza la funzione pie () per visualizzare il grafico a torta dell'elenco degli studenti iscritti a vari corsi di lingua informatica. La percentuale proporzionale viene visualizzata all'interno del rispettivo cuneo con l'aiuto diautopct parametro impostato su% 1.2f%.

from matplotlib import pyplot as plt
import numpy as np
fig = plt.figure()
ax = fig.add_axes([0,0,1,1])
ax.axis('equal')
langs = ['C', 'C++', 'Java', 'Python', 'PHP']
students = [23,17,35,29,12]
ax.pie(students, labels = langs,autopct='%1.2f%%')
plt.show()

I grafici a dispersione vengono utilizzati per tracciare i punti dati sull'asse orizzontale e verticale nel tentativo di mostrare quanto una variabile è influenzata da un'altra. Ogni riga nella tabella dati è rappresentata da un marker la cui posizione dipende dai suoi valori nelle colonne impostate sugli assi X e Y. Una terza variabile può essere impostata in modo che corrisponda al colore o alla dimensione dei marker, aggiungendo così un'altra dimensione al grafico.

Lo script seguente traccia un diagramma a dispersione della gamma di voti rispetto ai voti di ragazzi e ragazze in due colori diversi.

import matplotlib.pyplot as plt
girls_grades = [89, 90, 70, 89, 100, 80, 90, 100, 80, 34]
boys_grades = [30, 29, 49, 48, 100, 48, 38, 45, 20, 30]
grades_range = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]
fig=plt.figure()
ax=fig.add_axes([0,0,1,1])
ax.scatter(grades_range, girls_grades, color='r')
ax.scatter(grades_range, boys_grades, color='b')
ax.set_xlabel('Grades Range')
ax.set_ylabel('Grades Scored')
ax.set_title('scatter plot')
plt.show()

I grafici a contorno (a volte chiamati grafici di livello) sono un modo per mostrare una superficie tridimensionale su un piano bidimensionale. Rappresenta graficamente due variabili predittive XY sull'asse y e una variabile di risposta Z come contorni. Questi contorni sono talvolta chiamati z-slice o valori di risposta iso.

Un contour plot è appropriato se si desidera vedere come cambia il alore Z in funzione di due ingressi X e Y, in modo tale che Z = f (X, Y). Una linea di contorno o isolinea di una funzione di due variabili è una curva lungo la quale la funzione ha un valore costante.

Le variabili indipendenti x e y sono generalmente limitate a una griglia regolare chiamata meshgrid. Il numpy.meshgrid crea una griglia rettangolare da una matrice di valori x e una matrice di valori y.

L'API Matplotlib contiene funzioni contour () e contourf () che disegnano rispettivamente linee di contorno e contorni riempiti. Entrambe le funzioni richiedono tre parametri x, y e z.

import numpy as np
import matplotlib.pyplot as plt
xlist = np.linspace(-3.0, 3.0, 100)
ylist = np.linspace(-3.0, 3.0, 100)
X, Y = np.meshgrid(xlist, ylist)
Z = np.sqrt(X**2 + Y**2)
fig,ax=plt.subplots(1,1)
cp = ax.contourf(X, Y, Z)
fig.colorbar(cp) # Add a colorbar to a plot
ax.set_title('Filled Contours Plot')
#ax.set_xlabel('x (cm)')
ax.set_ylabel('y (cm)')
plt.show()

Un grafico a faretra mostra i vettori di velocità come frecce con componenti (u, v) nei punti (x, y).

quiver(x,y,u,v)

Il comando precedente traccia i vettori come frecce alle coordinate specificate in ciascuna coppia di elementi corrispondenti in x e y.

Parametri

La tabella seguente elenca i diversi parametri per il grafico Quiver -

X Array 1D o 2D, sequenza. Le coordinate x delle posizioni delle frecce
y Array 1D o 2D, sequenza. Le coordinate y delle posizioni delle frecce
u Array 1D o 2D, sequenza. Le componenti x dei vettori freccia
v Array 1D o 2D, sequenza. Le componenti y dei vettori freccia
c Array 1D o 2D, sequenza. I colori della freccia

Il codice seguente disegna un semplice diagramma della faretra:

import matplotlib.pyplot as plt
import numpy as np
x,y = np.meshgrid(np.arange(-2, 2, .2), np.arange(-2, 2, .25))
z = x*np.exp(-x**2 - y**2)
v, u = np.gradient(z, .2, .2)
fig, ax = plt.subplots()
q = ax.quiver(x,y,u,v)
plt.show()

Un box plot, noto anche come diagramma dei baffi, visualizza un riepilogo di un set di dati contenente il minimo, il primo quartile, la mediana, il terzo quartile e il massimo. In un box plot, disegniamo un riquadro dal primo quartile al terzo quartile. Una linea verticale attraversa la scatola in corrispondenza della mediana. I baffi vanno da ogni quartile al minimo o massimo.

Creiamo i dati per i boxplot. Noi usiamo ilnumpy.random.normal()funzione per creare i dati falsi. Sono necessari tre argomenti, media e deviazione standard della distribuzione normale e il numero di valori desiderati.

np.random.seed(10)
collectn_1 = np.random.normal(100, 10, 200)
collectn_2 = np.random.normal(80, 30, 200)
collectn_3 = np.random.normal(90, 20, 200)
collectn_4 = np.random.normal(70, 25, 200)

L'elenco degli array che abbiamo creato sopra è l'unico input richiesto per la creazione del boxplot. Usando ildata_to_plot riga di codice, possiamo creare il boxplot con il seguente codice -

fig = plt.figure()
# Create an axes instance
ax = fig.add_axes([0,0,1,1])
# Create the boxplot
bp = ax.boxplot(data_to_plot)
plt.show()

La riga di codice precedente genererà il seguente output:

I grafici del violino sono simili ai grafici a scatole, tranne per il fatto che mostrano anche la densità di probabilità dei dati a valori diversi. Questi grafici includono un marker per la mediana dei dati e un riquadro che indica l'intervallo interquartile, come nei box plot standard. Sovrapposta a questo box plot c'è una stima della densità del kernel. Come i box plot, i grafici per violino vengono utilizzati per rappresentare il confronto di una distribuzione variabile (o distribuzione campione) tra diverse "categorie".

La trama di un violino è più istruttiva di una semplice trama a scatola. Infatti, mentre un box plot mostra solo statistiche riassuntive come media / mediana e intervalli interquartili, il grafico del violino mostra la distribuzione completa dei dati.

import matplotlib.pyplot as plt

np.random.seed(10)
collectn_1 = np.random.normal(100, 10, 200)
collectn_2 = np.random.normal(80, 30, 200)
collectn_3 = np.random.normal(90, 20, 200)
collectn_4 = np.random.normal(70, 25, 200)

## combine these different collections into a list
data_to_plot = [collectn_1, collectn_2, collectn_3, collectn_4]

# Create a figure instance
fig = plt.figure()

# Create an axes instance
ax = fig.add_axes([0,0,1,1])

# Create the boxplot
bp = ax.violinplot(data_to_plot)
plt.show()

Anche se Matplotlib è stato inizialmente progettato con in mente solo il plottaggio bidimensionale, alcune utilità di plottaggio tridimensionale sono state costruite sopra il display bidimensionale di Matplotlib nelle versioni successive, per fornire una serie di strumenti per la visualizzazione dei dati tridimensionali. I grafici tridimensionali vengono abilitati importando il filemplot3d toolkit, incluso con il pacchetto Matplotlib.

Un asse tridimensionale può essere creato passando la parola chiave projection = '3d' a una qualsiasi delle normali routine di creazione degli assi.

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
fig = plt.figure()
ax = plt.axes(projection='3d')
z = np.linspace(0, 1, 100)
x = z * np.sin(20 * z)
y = z * np.cos(20 * z)
ax.plot3D(x, y, z, 'gray')
ax.set_title('3D line plot')
plt.show()

Ora possiamo tracciare una varietà di tipi di grafici tridimensionali. La trama tridimensionale più semplice è a3D line plotcreato da insiemi di triple (x, y, z). Questo può essere creato utilizzando la funzione ax.plot3D.

3D scatter plot viene generato utilizzando il ax.scatter3D funzione.

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
fig = plt.figure()
ax = plt.axes(projection='3d')
z = np.linspace(0, 1, 100)
x = z * np.sin(20 * z)
y = z * np.cos(20 * z)
c = x + y
ax.scatter(x, y, z, c=c)
ax.set_title('3d Scatter plot')
plt.show()

Il ax.contour3D()la funzione crea un grafico di contorno tridimensionale. Richiede che tutti i dati di input siano sotto forma di griglie regolari bidimensionali, con i dati Z valutati in ogni punto. Qui, mostreremo un diagramma di contorno tridimensionale di una funzione sinusoidale tridimensionale.

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
def f(x, y):
   return np.sin(np.sqrt(x ** 2 + y ** 2))
	
x = np.linspace(-6, 6, 30)
y = np.linspace(-6, 6, 30)

X, Y = np.meshgrid(x, y)
Z = f(X, Y)

fig = plt.figure()
ax = plt.axes(projection='3d')
ax.contour3D(X, Y, Z, 50, cmap='binary')
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('z')
ax.set_title('3D contour')
plt.show()

Il grafico wireframe prende una griglia di valori e la proietta sulla superficie tridimensionale specificata e può rendere le forme tridimensionali risultanti abbastanza facili da visualizzare. Ilplot_wireframe() la funzione è utilizzata allo scopo:

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
def f(x, y):
   return np.sin(np.sqrt(x ** 2 + y ** 2))
	
x = np.linspace(-6, 6, 30)
y = np.linspace(-6, 6, 30)

X, Y = np.meshgrid(x, y)
Z = f(X, Y)

fig = plt.figure()
ax = plt.axes(projection='3d')
ax.plot_wireframe(X, Y, Z, color='black')
ax.set_title('wireframe')
plt.show()

La riga di codice precedente genererà il seguente output:

Il grafico della superficie mostra una relazione funzionale tra una variabile dipendente designata (Y) e due variabili indipendenti (X e Z). Il grafico è un grafico associato al grafico di contorno. Un grafico di superficie è come un grafico wireframe, ma ogni faccia del wireframe è un poligono pieno. Ciò può aiutare la percezione della topologia della superficie visualizzata. Ilplot_surface() funzione x, yez come argomenti.

from mpl_toolkits import mplot3d
import numpy as np
import matplotlib.pyplot as plt
x = np.outer(np.linspace(-2, 2, 30), np.ones(30))
y = x.copy().T # transpose
z = np.cos(x ** 2 + y ** 2)

fig = plt.figure()
ax = plt.axes(projection='3d')

ax.plot_surface(x, y, z,cmap='viridis', edgecolor='none')
ax.set_title('Surface plot')
plt.show()

La riga di codice precedente genererà il seguente output:

Matplotlib ha un ampio supporto di testo, incluso il supporto per espressioni matematiche, TrueTypesupporto per output raster e vettoriali, testo separato da nuova riga con rotazioni arbitrarie e supporto unicode. Matplotlib include il proprio matplotlib.font_manager che implementa un algoritmo di ricerca dei font compatibile con W3C e multipiattaforma.

L'utente ha un grande controllo sulle proprietà del testo (dimensione del carattere, spessore del carattere, posizione e colore del testo, ecc.). Matplotlib implementa un gran numero di simboli e comandi matematici TeX.

Il seguente elenco di comandi viene utilizzato per creare testo nell'interfaccia di Pyplot:

testo Aggiungi testo in una posizione arbitraria degli assi.
annotare Aggiungi un'annotazione, con una freccia opzionale, in una posizione arbitraria degli assi.
xlabel Aggiungi un'etichetta all'asse x degli assi.
ylabel Aggiungi un'etichetta all'asse y degli assi.
titolo Aggiungi un titolo agli assi.
figtext Aggiungi testo in una posizione arbitraria della figura.
suptitle Aggiungi un titolo alla figura.

Tutte queste funzioni creano e restituiscono un file matplotlib.text.Text() esempio.

I seguenti script dimostrano l'uso di alcune delle funzioni di cui sopra:

import matplotlib.pyplot as plt
fig = plt.figure()

ax = fig.add_axes([0,0,1,1])

ax.set_title('axes title')
ax.set_xlabel('xlabel')
ax.set_ylabel('ylabel')
ax.text(3, 8, 'boxed italics text in data coords', style='italic', 
bbox = {'facecolor': 'red'})
ax.text(2, 6, r'an equation: $E = mc^2$', fontsize = 15)
ax.text(4, 0.05, 'colored text in axes coords',
verticalalignment = 'bottom', color = 'green', fontsize = 15)
ax.plot([2], [1], 'o')
ax.annotate('annotate', xy = (2, 1), xytext = (3, 4),
arrowprops = dict(facecolor = 'black', shrink = 0.05))
ax.axis([0, 10, 0, 10])
plt.show()

La riga di codice precedente genererà il seguente output:

Puoi usare un sottoinsieme TeXmarkup in qualsiasi stringa di testo Matplotlib inserendolo all'interno di una coppia di segni di dollaro ($).

# math text
plt.title(r'$\alpha > \beta$')

Per creare pedici e apici, utilizza i simboli "_" e "^" -

r'$\alpha_i> \beta_i$'

import numpy as np
import matplotlib.pyplot as plt
t = np.arange(0.0, 2.0, 0.01)
s = np.sin(2*np.pi*t)

plt.plot(t,s)
plt.title(r'$\alpha_i> \beta_i$', fontsize=20)

plt.text(0.6, 0.6, r'$\mathcal{A}\mathrm{sin}(2 \omega t)$', fontsize = 20)
plt.text(0.1, -0.5, r'$\sqrt{2}$', fontsize=10)
plt.xlabel('time (s)')
plt.ylabel('volts (mV)')
plt.show()

La riga di codice precedente genererà il seguente output:

Il modulo immagine nel pacchetto Matplotlib fornisce le funzionalità necessarie per caricare, ridimensionare e visualizzare l'immagine.

Il caricamento dei dati di immagine è supportato dalla libreria Pillow. In modo nativo, Matplotlib supporta solo immagini PNG. I comandi mostrati di seguito ricadono su Pillow se la lettura nativa fallisce.

L'immagine utilizzata in questo esempio è un file PNG, ma tieni presente il requisito di Pillow per i tuoi dati. Ilimread() viene utilizzata per leggere i dati dell'immagine in un file ndarray oggetto di float32 dtype.

import matplotlib.pyplot as plt
import matplotlib.image as mpimg
import numpy as np
img = mpimg.imread('mtplogo.png')

Supponendo che l'immagine seguente denominata come mtplogo.png è presente nella directory di lavoro corrente.

Qualsiasi array contenente dati immagine può essere salvato su un file su disco eseguendo il imsave()funzione. Qui una versione capovolta verticalmente del file png originale viene salvata dando il parametro di origine come inferiore.

plt.imsave("logo.png", img, cmap = 'gray', origin = 'lower')

La nuova immagine appare come di seguito se aperta in qualsiasi visualizzatore di immagini.

Per disegnare l'immagine sul visualizzatore Matplotlib, eseguire il imshow() funzione.

imgplot = plt.imshow(img)

Il pacchetto matplotlib è costruito su un framework di trasformazione per spostarsi facilmente tra i sistemi di coordinate. È possibile utilizzare quattro sistemi di coordinate. I sistemi sono descritti brevemente nella tabella sotto riportata:

Coordinata Oggetto di trasformazione Descrizione
Dati ax.transData

Il sistema di coordinate dei dati territoriali dell'utente. controllato da xlim e ylim

Assi ax.transAxes

Il sistema di coordinate degli assi. (0,0) è in basso a sinistra e (1,1) è in alto a destra degli assi.

figura fig.transFigure

Il sistema di coordinate della figura. (0,0) è in basso a sinistra e (1,1) è in alto a destra della figura

Schermo Nessuna

Questo è il sistema di coordinate pixel del display. (0,0) è l'angolo inferiore sinistro e (larghezza, altezza) è l'angolo superiore destro del display in pixel.

In alternativa, è possibile utilizzare (matplotlib.transforms.IdentityTransform ()) invece di None.

Considera il seguente esempio:

axes.text(x,y,"my label")

Il testo viene posizionato nella posizione teorica di un punto dati (x, y). Si parlerebbe quindi di "coordinate dati".

Utilizzando altri oggetti di trasformazione, è possibile controllare il posizionamento. Ad esempio, se il test di cui sopra deve essere posizionato al centro del sistema di coordinate degli assi, eseguire la seguente riga di codice:

axes.text(0.5, 0.5, "middle of graph", transform=axes.transAxes)

Queste trasformazioni possono essere utilizzate per qualsiasi tipo di oggetti Matplotlib. La trasformazione predefinita perax.text è ax.transData e la trasformazione predefinita per fig.text è fig.transFigure.

Il sistema di coordinate degli assi è estremamente utile quando si inserisce il testo negli assi. Spesso potresti volere un fumetto di testo in una posizione fissa; ad esempio, nella parte superiore sinistra del riquadro degli assi e lasciare che la posizione rimanga fissa quando si esegue la panoramica o lo zoom.