Creare grafici con Matplotlib e Seaborn

'Creating graphs with Matplotlib and Seaborn' in English.

 

La visualizzazione dei dati è essenziale nel lavoro sui dati poiché aiuta le persone a capire cosa succede con i nostri dati. È difficile assimilare direttamente le informazioni sui dati in forma grezza, ma la visualizzazione susciterebbe l’interesse e l’interazione delle persone. Ecco perché imparare la visualizzazione dei dati è importante per avere successo nel campo dei dati.

Matplotlib è una delle librerie di visualizzazione dei dati più popolari di Python perché è molto versatile e si può visualizzare praticamente tutto da zero. Con questo pacchetto è possibile controllare molti aspetti della visualizzazione.

D’altra parte, Seaborn è un pacchetto di visualizzazione dei dati di Python che si basa su Matplotlib. Offre codice di alto livello molto più semplice con vari temi incorporati nel pacchetto. Il pacchetto è ottimo se si desidera una rapida visualizzazione dei dati con un aspetto gradevole.

In questo articolo, esploreremo entrambi i pacchetti e impareremo come visualizzare i dati con questi pacchetti. Iniziamo.

 

Visualizzazione con Matplotlib

 

Come accennato in precedenza, Matplotlib è un pacchetto versatile di Python in cui possiamo controllare vari aspetti della visualizzazione. Il pacchetto si basa sul linguaggio di programmazione Matlab, ma lo abbiamo applicato in Python.

La libreria Matplotlib è generalmente già disponibile nel tuo ambiente, specialmente se usi Anaconda. Se non è presente, puoi installarla con il seguente codice.

pip install matplotlib

 

Dopo l’installazione, importeremo il pacchetto Matplotlib per la visualizzazione con il seguente codice.

import matplotlib.pyplot as plt

 

Iniziamo con il tracciamento di base con Matplotlib. Per cominciare, creerò dei dati di esempio.

import numpy as np

x = np.linspace(0,5,21)
y = x**2

 

Con questi dati, creeremo un grafico a linee con il pacchetto Matplotlib.

plt.plot(x, y, 'b')
plt.xlabel('Asse X')
plt.ylabel('Asse Y')
plt.title('Grafico di esempio')

 

  Nel codice sopra, passiamo i dati alla funzione matplotlib (x e y) per creare un semplice grafico a linee con una linea blu. Inoltre, controlliamo l’etichetta dell’asse e il titolo con il codice sopra.

Proviamo a creare un grafico a più matplotlib con la funzione subplot.

plt.subplot(1,2,1)
plt.plot(x, y, 'b--')
plt.title('Sottografico 1')
plt.subplot(1,2,2)
plt.plot(x, y, 'r')
plt.title('Sottografico 2')

 

 

Nel codice sopra, creiamo due grafici uno accanto all’altro. La funzione subplot controlla la posizione del grafico; ad esempio, plt.subplot(1,2,1) significa che avremo due grafici in una riga (primo parametro) e due colonne (secondo parametro). Il terzo parametro serve a controllare a quale grafico ci stiamo riferendo. Quindi plt.subplot(1,2,1) significa il primo grafico dei grafici a singola riga e doppia colonna.

Queste sono le basi delle funzioni di Matplotlib, ma se vogliamo avere un maggiore controllo sulla visualizzazione di Matplotlib, dobbiamo utilizzare il Metodo Orientato agli Oggetti (OOM). Con OOM, produrremo la visualizzazione direttamente dall’oggetto figura e chiameremo qualsiasi attributo dall’oggetto specificato.

Ti darò un esempio di visualizzazione con Matplotlib OOM.

#crea un'istanza di figura (Canvas)
fig = plt.figure()

#aggiungi gli assi al canvas
ax = fig.add_axes([0.1, 0.1, 0.7, 0.7]) #left, bottom, width, height (range from 0 to 1)

#aggiungi il grafico agli assi all'interno del canvas
ax.plot(x, y, 'b')
ax.set_xlabel('Etichetta X')
ax.set_ylabel('Etichetta Y')
ax.set_title('Grafico con OOM')

 

 

Il risultato è simile al grafico che abbiamo creato, ma il codice è più complesso. All’inizio sembrava controproducente, ma usando l’OOM siamo riusciti a controllare praticamente tutto con la nostra visualizzazione. Ad esempio, nel grafico sopra possiamo controllare dove si trovano gli assi all’interno del canvas.

Per vedere come vedere le differenze nell’utilizzo dell’OOM rispetto alla normale funzione di plotting, mettiamo due grafici con i rispettivi assi sovrapposti l’uno all’altro.

#crea un'istanza del canvas (Figure)
fig = plt.figure()

#aggiungi due assi al canvas
ax1 = fig.add_axes([0.1, 0.1, 0.7, 0.7]) 
ax2 = fig.add_axes([0.2, 0.35, 0.2, 0.4]) 

#aggiungi il grafico ai rispettivi assi all'interno del canvas
ax1.plot(x, y, 'b')
ax1.set_xlabel('Etichetta X Ax 1')
ax1.set_ylabel('Etichetta Y Ax 1')
ax1.set_title('Grafico con OOM Ax 1')

ax2.plot(x, y, 'r--')
ax2.set_xlabel('Etichetta X Ax 2')
ax2.set_ylabel('Etichetta Y Ax 2')
ax2.set_title('Grafico con OOM Ax 2')

 

 

Nel codice sopra, abbiamo specificato un oggetto canvas con la funzione plt.figure e abbiamo prodotto tutti questi grafici dall’oggetto figure. Possiamo produrre tanti assi quanti ne vogliamo all’interno di un unico canvas e inserire un grafico di visualizzazione al loro interno.

È anche possibile creare automaticamente la figura e l’oggetto assi con la funzione subplot.

fig, ax = plt.subplots(nrows = 1, ncols =2)

ax[0].plot(x, y, 'b--')
ax[0].set_xlabel('Etichetta X')
ax[0].set_ylabel('Etichetta Y')
ax[0].set_title('Grafico con OOM subplot 1')

 

 

Utilizzando la funzione subplots, creiamo sia le figure che una lista di oggetti assi. Nella funzione sopra, specifichiamo il numero di grafici e la posizione di una riga con due colonne di grafici.

Per l’oggetto assi, è una lista di tutti gli assi per i grafici a cui possiamo accedere. Nel codice sopra, accediamo al primo oggetto della lista per creare il grafico. Il risultato sono due grafici, uno riempito con il grafico a linea mentre l’altro solo gli assi.

Poiché subplots produce una lista di oggetti assi, è possibile iterarli in modo simile al codice qui sotto.

fig, axes = plt.subplots(nrows = 1, ncols =2)

for ax in axes:

    ax.plot(x, y, 'b--')
    ax.set_xlabel('Etichetta X')
    ax.set_ylabel('Etichetta Y')
    ax.set_title('Grafico con OOM')

plt.tight_layout()

 

 

Puoi giocare con il codice per produrre i grafici desiderati. Inoltre, utilizziamo la funzione tight_layout perché c’è la possibilità di sovrapposizione dei grafici.

Proviamo alcuni parametri di base che possiamo utilizzare per controllare il nostro grafico Matplotlib. Prima, proviamo a modificare le dimensioni del canvas e dei pixel.

fig = plt.figure(figsize = (8,4), dpi =100)

 

   

Il parametro figsize accetta una tupla di due numeri (larghezza, altezza) dove il risultato è simile al grafico sopra.

Successivamente, proviamo ad aggiungere una legenda al grafico.

fig = plt.figure(figsize = (8,4), dpi =100)

ax = fig.add_axes([0.1, 0.1, 0.7, 0.7])

ax.plot(x, y, 'b', label = 'Prima Linea')
ax.plot(x, y/2, 'r', label = 'Seconda Linea')
ax.set_xlabel('Etichetta X')
ax.set_ylabel('Etichetta Y')
ax.set_title('Grafico con OOM e Legenda')
plt.legend()

 

 

Assegnando il parametro label al grafico e utilizzando la funzione legend, possiamo mostrare l’etichetta come legenda.

Infine, possiamo utilizzare il seguente codice per salvare il nostro grafico.

fig.savefig('visualizzazione.jpg')

 

Esistono molti grafici speciali oltre al grafico a linee mostrato sopra. Possiamo accedere a questi grafici utilizzando queste funzioni. Proviamo diversi grafici che potrebbero aiutare il tuo lavoro.

Grafico a dispersione

Al posto di un grafico a linee, possiamo creare un grafico a dispersione per visualizzare la relazione delle caratteristiche utilizzando il seguente codice.

plt.scatter(x,y)

 

 

Grafico a istogramma

Un grafico a istogramma visualizza la distribuzione dei dati rappresentata nei bin.

plt.hist(y, bins = 5)

 

 

Grafico a boxplot

Il boxplot è una tecnica di visualizzazione che rappresenta la distribuzione dei dati in quartili.

plt.boxplot(x)

 

 

Grafico a torta

Il grafico a torta è un grafico di forma circolare che rappresenta le proporzioni numeriche del grafico categorico, ad esempio la frequenza dei valori categorici nei dati.

freq = [2,4,1,3]
fruit = ['Mela', 'Banana', 'Uva', 'Pera']
plt.pie(freq, labels = fruit)

 

 

Ci sono ancora molti grafici speciali nella libreria Matplotlib che puoi consultare qui.

 

Visualizzazione con Seaborn

 

Seaborn è un pacchetto Python per la visualizzazione statistica costruito su Matplotlib. Ciò che distingue Seaborn è che semplifica la creazione di visualizzazioni con uno stile eccellente. Il pacchetto funziona anche con Matplotlib, poiché molte API di Seaborn sono legate a Matplotlib.

Proviamo il pacchetto Seaborn. Se non hai installato il pacchetto, puoi farlo utilizzando il seguente codice.

pip install seaborn

 

Seaborn ha una API integrata per ottenere set di dati di esempio che possiamo utilizzare per testare il pacchetto. Utilizzeremo questo set di dati per creare varie visualizzazioni con Seaborn.

import seaborn as sns

tips = sns.load_dataset('tips')
tips.head()

 

 

Utilizzando i dati sopra, esploreremo il grafico Seaborn, inclusi grafici di distribuzione, categorici, di relazione e matriciali.

Grafici di distribuzione

Il primo grafico che proveremo con Seaborn è il grafico di distribuzione per visualizzare la distribuzione della caratteristica numerica. Possiamo farlo con il seguente codice.

sns.displot(data = tips, x = 'tip')

 

 

Per impostazione predefinita, la funzione displot produrrà un grafico a istogramma. Se vogliamo appiattire il grafico, possiamo utilizzare il parametro KDE.

sns.displot(data = tips, x = 'tip', kind = 'kde')

 

 

Il grafico di distribuzione può anche essere suddiviso in base ai valori categorici nel DataFrame utilizzando il parametro Hue.

sns.displot(data=tips, x='tip', kind='kde', hue='smoker')

 

 

Possiamo addirittura suddividere ulteriormente il grafico con i parametri row o col. Con questo parametro, otteniamo diversi grafici divisi con una combinazione di valori categorici.

sns.displot(data=tips, x='tip', kind='kde', hue='smoker', row='time', col='sex')

 

 

Un altro modo per visualizzare la distribuzione dei dati è utilizzare il boxplot. Seabron può facilitare la visualizzazione facilmente con il seguente codice.

sns.boxplot(data=tips, x='time', y='tip')

 

 

Utilizzando il grafico a violino, possiamo visualizzare la distribuzione dei dati che combina il boxplot con KDE.

 

Infine, possiamo mostrare il punto dei dati nel grafico combinando i grafici a violino e a sciame.

sns.violinplot(data=tips, x='time', y='tip')
sns.swarmplot(data=tips, x='time', y='tip', palette='Set1')

 

 

Grafici Categorici

Un grafico categorico è una varie API di Seaborn che si applica per produrre la visualizzazione con dati categorici. Esploriamo alcuni dei grafici disponibili. 

Prima di tutto, proveremo a creare un grafico di conteggio.

sns.countplot(data=tips, x='time')

 

 

Il grafico di conteggio mostrerà una barra con la frequenza dei valori categorici. Se vogliamo mostrare il numero di conteggio nel grafico, dobbiamo combinare la funzione Matplotlib nell’API di Seaborn.

p = sns.countplot(data=tips, x='time')
p.bar_label(p.containers[0])

 

 

Possiamo estendere ulteriormente il grafico con il parametro hue e mostrare i valori di frequenza con il seguente codice.

p = sns.countplot(data=tips, x='time', hue='sex')
for container in p.containers:
    ax.bar_label(container)

 

 

Successivamente, proveremo a sviluppare un barplot. Il barplot è un grafico categorico che mostra l’aggregazione dei dati con una barra di errore. 

sns.barplot(data=tips, x='time', y='tip')

 

 

Il barplot utilizza una combinazione di caratteristiche categoriche e numeriche per fornire le statistiche di aggregazione. Per impostazione predefinita, il barplot utilizza una funzione di aggregazione media con un intervallo di confidenza del 95% barra di errore. 

Se vogliamo cambiare la funzione di aggregazione, possiamo passare la funzione nel parametro estimator.

import numpy as np
sns.barplot(data = tips, x = 'time', y = 'tip', estimator = np.median)

 

 

Grafici Relazionali

Un grafico relazionale è una tecnica di visualizzazione per mostrare la relazione tra le caratteristiche. È principalmente utilizzato per identificare eventuali tipi di modelli che esistono nel dataset.

Iniziamo utilizzando un grafico a dispersione per mostrare la relazione tra determinate caratteristiche numeriche.

sns.scatterplot(data = tips, x = 'tip', y = 'total_bill')

 

 

Possiamo combinare il grafico a dispersione con il grafico di distribuzione utilizzando un grafico congiunto.

sns.jointplot(data = tips, x = 'tip', y = 'total_bill')

 

 

Infine, possiamo tracciare automaticamente le relazioni a coppie tra le caratteristiche nel DataFrame utilizzando il pairplot.

sns.pairplot(data = tips)

 

 

Grafici Matrice

Il grafico matrice viene utilizzato per visualizzare i dati come una matrice codificata a colori. Viene utilizzato per visualizzare la relazione tra le caratteristiche o per riconoscere i cluster all’interno dei dati.

Ad esempio, abbiamo una matrice di dati di correlazione dal nostro dataset.

tips.corr()

 

 

Potremmo capire meglio il dataset sopra se lo rappresentassimo in un grafico codificato a colori. Ecco perché useremmo un grafico a mappa di calore.

sns.heatmap(tips.corr(), annot = True)

 

 

Il grafico matrice potrebbe anche produrre un grafico di clustering gerarchico che deduce i valori all’interno del nostro dataset e li raggruppa in base alla similarità esistente

sns.clustermap(tips.pivot_table(values = 'tip', index = 'size', columns = 'day').fillna(0))

 

Conclusioni

 

La visualizzazione dei dati è una parte fondamentale del mondo dei dati in quanto aiuta il pubblico a capire rapidamente cosa accade con i nostri dati. I pacchetti Python standard per la visualizzazione dei dati sono Matplotlib e Seaborn. In questo articolo, abbiamo imparato l’uso principale dei pacchetti e presentato diverse visualizzazioni che potrebbero aiutare il nostro lavoro.     Cornellius Yudha Wijaya è un assistente manager della scienza dei dati e un autore di dati. Mentre lavora a tempo pieno presso Allianz Indonesia, ama condividere consigli su Python e dati tramite i social media e i media scritti.