Tutorial su Plotly Express in Python: sblocca visualizzazioni straordinarie

Plotly non serve solo a creare belle visualizzazioni: ti aiuta a sbloccare tutto il potenziale dei tuoi dati e a far emergere insight che altrimenti resterebbero nascosti. È il ponte tra il linguaggio dei numeri e quello delle storie, dando a persone e organizzazioni il potere di prendere decisioni informate e generare cambiamenti significativi.

È la descrizione che ChatGPT usa per parlare di Plotly. Chiaro: Plotly è una delle migliori librerie di visualizzazione dei dati in circolazione.

Crea grafici altamente interattivi e visivamente accattivanti come quello qui sotto:

Oggi imparerai le basi per creare visual straordinari con Plotly.

Nozioni di base su Plotly Express

Come in qualsiasi altro tutorial, iniziamo installando la libreria tramite pip (o se preferisci conda).

$ pip install --upgrade plotly
$ conda install -c conda-forge plotly

Plotly riceve aggiornamenti regolari, quindi assicurati di includere il tag --upgrade se hai già installato la libreria.

Il tutorial si concentra sulla Express API di Plotly, introdotta nel 2019, che offre numerosi vantaggi rispetto ai vecchi modi di interagire con la libreria core di Plotly:

• Sintassi semplice (si legge quasi come l’inglese)
• Ampia gamma di visualizzazioni (o strumenti per crearne di tue)
• Scalatura automatica di assi e colori
• Integrazione con pandas (puoi usare Plotly come backend di plotting per la funzione .plot di Pandas)

Ecco l’anatomia di un grafico di base in Plotly Express:

import plotly.express as px

fig = px.plotting_function(
    dataframe,
    x='column-for-xaxis',
    y='column-for-yaxis',
    title='Title For the Plot',
    width=width_in_pixels,
    height=height_in_pixels
)

fig.show()

I diversi grafici hanno il proprio nome, come histogram o scatter nel modulo express, caricato come px. Il primo argomento di qualsiasi funzione di plotting è il dataframe e i nomi delle colonne da tracciare sugli assi X e Y.

Le buone pratiche suggeriscono di dare ai grafici un title informativo, così chi legge capisce subito di cosa parla il grafico.

Quando una funzione di plotting viene eseguita, restituisce un oggetto Figure su cui chiamare il metodo show per visualizzare il grafico nel tuo amato notebook.

Per iniziare a creare i grafici, ci serve un dataset. Per questo tutorial useremo un dataset sui diamanti. Contiene una bella combinazione di feature numeriche e categoriche: perfetto per gli scopi di questo articolo.

import pandas as pd

diamonds = pd.read_csv("data/diamonds.csv")

diamonds.head()

Il dataset contiene oltre 53k diamanti con 10 caratteristiche fisiche. Qui sotto puoi esplorarne le statistiche di base.

diamonds.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 53940 entries, 0 to 53939
Data columns (total 10 columns):
#   Column   Non-Null Count  Dtype 
---  ------   --------------  ----- 
0   carat    53940 non-null  float64
1   cut      53940 non-null  object
2   color    53940 non-null  object
3   clarity  53940 non-null  object
4   depth    53940 non-null  float64
5   table    53940 non-null  float64
6   price    53940 non-null  int64 
7   x        53940 non-null  float64
8   y        53940 non-null  float64
9   z        53940 non-null  float64
dtypes: float64(6), int64(1), object(3)
memory usage: 4.1+ MB

diamonds.describe()

Una delle prime cose da fare quando si esegue l’analisi esplorativa dei dati (EDA) è esplorare le distribuzioni individuali.

Plotly offre molti grafici per questo compito: istogrammi, boxplot, violin plot, bar chart, ecc. Vediamone alcuni.

Istogrammi in Plotly Express

L’istogramma è probabilmente il primo grafico che si impara.

Ordina i valori di una distribuzione e li inserisce in bin. Poi usa barre per rappresentare quanti valori ricadono in ciascun bin:

import plotly.express as px
​
fig = px.histogram(
  diamonds,
  x="price",
  title="Histogram of diamond prices",
  width=600,
  height=400,
)
​
fig.show()

Se passi il mouse su una barra, puoi vedere l’intervallo del bin corrispondente. Plotly trova automaticamente il numero di bin, ma se vuoi impostarlo tu, puoi usare il parametro nbins.

Trovare il numero perfetto di bin per ogni distribuzione non è semplice. Per questo puoi usare una pratica comune: impostare lo stesso numero di bin pari alla radice quadrata della lunghezza della distribuzione:

# Find the correct number of bins
nbins = int(len(diamonds) ** (1 / 2))
​
fig = px.histogram(
  diamonds,
  x="price",
  title="Histogram of diamond prices",
  nbins=nbins,
  width=600,
  height=400,
)
​
fig.show()

Bar chart in Plotly Express

Gli istogrammi analizzano caratteristiche quantitative. Per analizzare dati categorici, usiamo i bar chart. Ad esempio, passando la colonna categorica cut alla funzione histogram, otteniamo un tipo di bar chart chiamato countplot. Sì, l’hai indovinato: conta il numero di osservazioni in ogni categoria.

fig = px.histogram(diamonds, x="cut")
​
fig.show()

Ma aspetta, non abbiamo messo etichette sul grafico! Risolviamo con la funzione update_layout, che può modificare molti aspetti di una figura dopo la creazione.

fig.update_layout(
  title="The number of diamonds in each diamond cut category",
  xaxis_title="",
  yaxis_title="Count",
)

Sai già cosa fa title. xaxis_title e yaxis_title sostituiscono le etichette degli assi generate da Plotly (che sono semplicemente i nomi delle colonne).

Ora vediamo il prezzo medio per ogni categoria di taglio del diamante. Per prima cosa usiamo il groupby di pandas:

mean_prices = (
    diamonds.groupby("cut")["price"].mean().reset_index()
)

mean_prices

Concatenare la funzione reset_index alla fine di un’operazione di groupby trasforma l’output in un DataFrame, e Plotly ama i DataFrame. Quindi, passiamolo alla funzione bar:

fig = px.bar(mean_prices, x="cut", y="price")
​
fig.update_layout(
  title="Average diamond prices for each cut category",
  xaxis_title="",
  yaxis_title="Mean price ($)",
)
​
fig.show()

bar prende una feature categorica e una numerica, creando una singola barra per ogni riga del DataFrame passato. Il risultato è un confronto piacevole alla vista dei prezzi per ciascun tipo di diamante.

Box plot in Plotly Express

Un altro grafico comune per analizzare le distribuzioni è il boxplot, creato con box in Plotly Express:

fig = px.box(diamonds, x="clarity", y="carat")
​
fig.update_layout(
  title="Distribution of diamond carats for each clarity category",
  xaxis_title="Clarity",
  yaxis_title="Carat",
)
​
fig.show()

Invece di creare barre che mostrano solo il carato medio dei diamanti, il boxplot visualizza più statistiche:

Puoi vedere:

• Minimo/massimo
• Mediana
• 25º percentile
• 75º percentile
• e outlier

per ogni categoria di purezza del diamante.

Violin plot in Plotly Express

Un altro grafico utile per esplorare le distribuzioni è il violin plot. I violin plot sono sostanzialmente box plot con qualche abbellimento in più:

fig = px.violin(diamonds, x="cut", y="price")
​
fig.show()

Invece di mostrare una scatola, visualizza una curva liscia che rappresenta la densità di una feature. Per sovrapporre un box plot, puoi impostare l’attributo box su True:

fig = px.violin(diamonds, x="cut", y="price", box=True)
​
fig.show()

A differenza dei box plot, che mostrano solo statistiche riassuntive, i violin plot mostrano anche la forma della distribuzione.

Visualizzare le relazioni tra feature con Plotly Express

Quando tracci feature strettamente correlate, inizi a vedere nuovi pattern e insight. Ad esempio, se assumiamo che il carato (peso) del diamante sia il principale fattore che ne determina il prezzo, esploriamo questa relazione.

Scatterplot in Plotly Express

Possiamo usare uno scatterplot (px.scatter) che rappresenta tutti i diamanti del dataset come punti. La posizione dei punti è determinata dai rispettivi valori di prezzo e carato:

fig = px.scatter(diamonds, x="price", y="carat")
​
fig.update_layout(
  title="Price vs. Carat",
  xaxis_title="Price ($)",
  yaxis_title="Carat",
)
​
fig.show()

Qui incappiamo in un brutto caso di overplotting, che si verifica quando ci sono troppi dati da visualizzare in un unico grafico. Invece di mostrare pattern e trend reali, l’overplotting li maschera.

Possiamo risolvere tracciando solo ~10% del dataset, più che sufficiente per rivelare eventuali pattern:

fig = px.scatter(
  diamonds.sample(5000), x="price", y="carat"
)
​
fig.update_layout(
  title="Price vs. Carat",
  xaxis_title="Price ($)",
  yaxis_title="Carat",
)
​
fig.show()

Nella chiamata a scatter, passiamo solo 5000 righe (.sample(5000)), che mostrano una leggera tendenza crescente nella relazione prezzo-carat.

Heatmap in Plotly Express

Le heatmap sono ottime per visualizzare dataset complessi, come una grande matrice in cui è difficile scorgere pattern da una miriade di numeri nelle celle.

Una heatmap assegna colori in base alla magnitudine di ciascuna cella della matrice. Uno scenario utile è osservare la matrice di correlazione di un dataset.

La correlazione misura la relazione lineare tra feature numeriche. Quindi, ogni cella della matrice di correlazione rappresenta la correlazione tra una coppia di feature.

Puoi calcolare la matrice di correlazione di qualsiasi dataset con il metodo corr di pandas, che restituisce un DataFrame. Se lo passi alla funzione imshow di Express, ottieni una heatmap:

import plotly.express as px
​
# Create heatmap using Plotly Express
fig = px.imshow(
  diamonds.corr(),
  color_continuous_scale="Inferno_r",
)
​
# Show plot
fig.show()

La correlazione varia da -1 a 1. Valori vicini ai bordi dell’intervallo indicano una forte relazione lineare positiva o negativa tra le feature.

Qui scegliamo la mappa colori Inferno invertita per il parametro color_continuous_scale. Puoi scegliere altre mappe dalla pagina delle scale di colore della documentazione di Plotly.

Personalizzare i grafici in Plotly Express

Una delle caratteristiche migliori della API di Plotly Express è la facile personalizzazione dei grafici.

La funzione update_layout include molti parametri con cui modificare quasi ogni aspetto dei tuoi chart.

In base a dove verranno mostrati i grafici, sta a te renderli presentabili per qualsiasi pubblico, sede o supporto.

Una delle prime cose da scegliere è il tema del grafico. I temi in Plotly sono configurazioni predefinite che controllano quasi tutti i componenti.

Puoi cambiarlo usando il parametro template di qualsiasi funzione di plotting:

sample = diamonds.sample(3000)
​
fig = px.scatter(
  sample, x="price", y="carat", template="ggplot2"
)
​
fig.show()

Alcuni tra i più popolari sono ggplot2, seaborn, plotly_dark e presentation. Puoi vedere l’elenco completo chiamando plotly.io.templates.

Colori

Finora i nostri scatterplot sono stati bidimensionali. Ma possiamo aggiungere ulteriore informazione tramite il colore.

Per esempio, possiamo colorare ogni punto in base alla categoria di appartenenza del diamante. Per farlo, ti basta passare cut al parametro color:

sample = diamonds.sample(3000)
​
fig = px.scatter(sample, x="price", y="carat", color="cut")
​
fig.show()

Il parametro cut forza anche la presenza della legenda nel grafico, mostrando i colori delle categorie.

Dimensione dei marker

Un altro approccio è visualizzare una feature numerica tramite la dimensione dei punti.

Impostando il parametro size su carat, otteniamo punti di dimensioni diverse in base al carato del diamante:

fig = px.scatter(sample, x="price", y="x", size="carat")
​
fig.show()

E se usassimo sia colore che dimensione? Ma certo!

fig = px.scatter(
  sample, x="price", y="x", size="carat", color="cut"
)
​
fig.show()

Ma questo grafico non è molto informativo perché contiene troppa informazione da elaborare a colpo d’occhio. È buona pratica non inserire più di tre feature in un singolo grafico.

Conclusione

Complimenti per essere arrivato fino in fondo! In questo tutorial hai imparato abbastanza per continuare a studiare Plotly con alcune delle nostre altre risorse:

• Corso Introduzione alla data visualization con Plotly in Python
• Tutorial Data Visualization con Plotly in R
• Tutorial Creare istogrammi in Plotly

Puoi anche scoprire la Graph Objects API di Plotly, per più opzioni di personalizzazione, pieno controllo su interattività e animazioni, e supporto per tipi di visualizzazione avanzati.