Tutorial su Seaborn in Python: guida alla visualizzazione statistica dei dati

Seaborn è una delle librerie Python di riferimento per la visualizzazione statistica dei dati. Costruita su Matplotlib, genera grafici curati con meno codice, si integra nativamente con i DataFrame di pandas e gestisce i grafici statistici più comuni—istogrammi, box plot, heatmap, regressioni—con un’API coerente.

In questo tutorial passerò in rassegna i tipi di grafico principali di Seaborn, mostrerò come personalizzarli e confronterò Seaborn con altre librerie di visualizzazione Python come Matplotlib e Plotly. Tutti gli esempi di codice usano Seaborn 0.13+ e pandas 2.0+.

TL;DR

• Seaborn è una libreria Python per la visualizzazione statistica costruita su Matplotlib—installala con pip install seaborn

• Funziona direttamente con i DataFrame di pandas: passa i nomi delle colonne come argomenti x, y e hue

• Tipi di grafico chiave: scatterplot(), lineplot(), barplot(), histplot(), boxplot(), heatmap(), pairplot()

• Le funzioni a livello di figura (relplot(), displot(), catplot()) creano griglie multi-pannello in una sola chiamata

• Personalizza l’aspetto con set_theme() e le palette di colori integrate

Che cos’è Seaborn?

Seaborn è una libreria Python per la visualizzazione dei dati costruita sopra Matplotlib. Lavora direttamente con i DataFrame di pandas, quindi passi i nomi delle colonne come argomenti invece di array grezzi. La libreria copre i grafici statistici più comuni: scatter plot, line plot, bar plot, istogrammi, box plot, heatmap e altro.

Seaborn organizza la sua API su tre livelli:

• Funzioni a livello di figura (relplot(), displot(), catplot()) creano intere griglie di figure e gestiscono automaticamente il faceting

• Funzioni a livello di assi (scatterplot(), histplot(), boxplot(), ecc.) disegnano su un singolo axes di Matplotlib

• Funzioni di utilità (heatmap(), pairplot(), jointplot()) per layout multi-pannello specializzati

Puoi approfondire Seaborn con il nostro corso Introduction to Data Visualization with Seaborn.

Seaborn include temi e palette di colori integrati applicabili con una singola chiamata a set_theme(). Include anche stime statistiche—intervalli di confidenza nei bar plot, regressioni, stime di densità—così puoi passare dai dati grezzi a un grafico pronto per la pubblicazione con pochissimo codice.

Fonte immagine

Seaborn vs. Matplotlib

Le due librerie di visualizzazione dati più usate in Python sono Matplotlib e Seaborn. Pur essendo entrambe progettate per creare grafici e visualizzazioni di alta qualità, presentano differenze chiave che le rendono più adatte a casi d’uso diversi.

Matplotlib ti dà il pieno controllo su ogni elemento di una figura (assi, tacche, legende, annotazioni), ma quel controllo richiede più codice per ogni grafico. Seaborn scambia parte di quella granularità per velocità: una singola chiamata di funzione con un DataFrame produce un grafico statistico già stilizzato.

In pratica, le usi insieme. Seaborn crea il grafico, poi chiami funzioni di Matplotlib per rifinire etichette, limiti o annotazioni—come vedrai negli esempi qui sotto.

Puoi esplorare Matplotlib più in dettaglio con il nostro tutorial Introduction to Plotting with Matplotlib in Python.

Installare Seaborn

Seaborn richiede Python 3.9+ (dalla versione 0.13) e dipende da Matplotlib, pandas e NumPy. Installalo con pip o conda:

# install seaborn with pip
pip install seaborn

Quando usi pip, Seaborn e le sue dipendenze necessarie verranno installate. Se vuoi accedere a funzionalità aggiuntive e opzionali, puoi includere anche le dipendenze opzionali nell’installazione con pip. Per esempio:

pip install seaborn[stats]

Oppure con conda:

# install seaborn with conda
conda install seaborn

Dataset di esempio

Seaborn fornisce diversi dataset integrati che possiamo usare per la visualizzazione e l’analisi statistica. Questi dataset sono memorizzati in DataFrame di pandas, il che li rende facili da usare con le funzioni di plotting di Seaborn.

Uno dei dataset più comuni, usato anche in tutti gli esempi ufficiali di Seaborn, è chiamato "tips dataset"; contiene informazioni sulle mance date nei ristoranti. Ecco un esempio di caricamento e visualizzazione del dataset Tips in Seaborn:

import seaborn as sns

tips = sns.load_dataset("tips")
sns.histplot(data=tips, x="total_bill")

Output:

Se questo grafico non ti è ancora chiaro, nessun problema. Si tratta di un istogramma. Spiegheremo più in dettaglio gli istogrammi più avanti nel tutorial. Per ora, l’idea chiave è che Seaborn include molti dataset di esempio come DataFrame di pandas, facili da usare per esercitarti con le visualizzazioni. Ecco un altro esempio di caricamento del dataset exercise.

import seaborn as sns

# Load the exercise dataset
exercise = sns.load_dataset("exercise")

# check the head
exercise.head()

Output:

Tipi di grafici in Seaborn

Seaborn offre una gamma di tipi di grafici per diverse esigenze analitiche. In generale, qualsiasi visualizzazione rientra in una di tre categorie: 

• Univariata – solo x (contiene un solo asse di informazione)
• Bivariata – x e y (contiene due assi di informazione)
• Trivariata – x, y, z (contiene tre assi di informazione)

Fonte immagine

Ecco alcuni dei tipi di grafico più usati in Seaborn:

• Scatter plot. Uno scatter plot è usato per visualizzare la relazione tra due variabili. La funzione scatterplot() di Seaborn offre un modo semplice per crearli.
• Line plot. Un line plot è usato per visualizzare l’andamento di una variabile nel tempo. La funzione lineplot() di Seaborn offre un modo semplice per crearli.
• Istogramma. Un istogramma è usato per visualizzare la distribuzione di una variabile. La funzione histplot() di Seaborn offre un modo semplice per crearli.
• Box plot. Un box plot è usato per visualizzare la distribuzione di una variabile. La funzione boxplot() di Seaborn offre un modo semplice per crearli.
• Violin plot. Un violin plot è simile a un box plot, ma fornisce una vista più dettagliata della distribuzione dei dati. La funzione violinplot() di Seaborn offre un modo semplice per crearli.
• Heatmap. Una heatmap è usata per visualizzare la correlazione tra variabili diverse. La funzione heatmap() di Seaborn offre un modo semplice per crearle.
• Pairplot. Un pairplot è usato per visualizzare la relazione tra più variabili. La funzione pairplot() di Seaborn offre un modo semplice per crearli.

Vedremo ora esempi e spiegazioni dettagliate per ciascuno nella prossima sezione del tutorial.

Funzioni a livello di figura vs. a livello di assi

Una delle differenze più importanti in Seaborn è tra funzioni a livello di figura e a livello di assi. Capirla ti farà risparmiare tempo di debug.

Funzioni a livello di assi (come scatterplot(), histplot(), boxplot()) disegnano su un singolo axes di Matplotlib. Puoi passare un argomento ax per controllare dove va il grafico:

import seaborn as sns
import matplotlib.pyplot as plt

fig, axes = plt.subplots(1, 2, figsize=(12, 5))

tips = sns.load_dataset("tips")
sns.histplot(data=tips, x="total_bill", ax=axes[0])
sns.boxplot(data=tips, x="day", y="total_bill", ax=axes[1])

plt.tight_layout()
plt.show()

Funzioni a livello di figura (relplot(), displot(), catplot()) creano una propria figura e possono suddividere automaticamente i dati in più pannelli usando i parametri col e row:

import seaborn as sns

tips = sns.load_dataset("tips")
sns.displot(data=tips, x="total_bill", col="time", kde=True)

Le funzioni a livello di figura restituiscono un oggetto FacetGrid invece di un axes, quindi imposti titoli ed etichette in modo diverso: usa g.set_axis_labels() e g.set_titles() invece di plt.xlabel().

Come creare grafici in Seaborn

Vediamo Seaborn in azione con alcuni esempi di tipi di grafici diversi.

Creare scatter plot in Seaborn

Gli scatter plot vengono usati per visualizzare la relazione tra due variabili continue. Ogni punto rappresenta un singolo dato e la sua posizione sugli assi x e y rappresenta i valori delle due variabili. 

Il grafico può essere personalizzato con colori e marker diversi per distinguere gruppi di punti. In Seaborn, gli scatter plot si creano con la funzione scatterplot(). 

import seaborn as sns

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

Output:

Questo semplice grafico può essere migliorato personalizzando i parametri hue e size. Ecco come:

import seaborn as sns
import matplotlib.pyplot as plt

tips = sns.load_dataset("tips")

# customize the scatter plot
sns.scatterplot(x="total_bill", y="tip", hue="sex", size="size", sizes=(50, 200), data=tips)

# add labels and title
plt.xlabel("Total Bill")
plt.ylabel("Tip")
plt.title("Relationship between Total Bill and Tip")

# display the plot
plt.show()

Output:

Creare line plot in Seaborn

I line plot vengono usati per visualizzare i trend nel tempo o su altre variabili continue. In un line plot, ogni punto dati è collegato da una linea, creando una curva continua. In Seaborn, i line plot si creano con la funzione lineplot(). Puoi approfondire nel nostro tutorial sui line plot di Seaborn.

import seaborn as sns

fmri = sns.load_dataset("fmri")
sns.lineplot(x="timepoint", y="signal", data=fmri)

Output:

Possiamo personalizzare facilmente usando le colonne event e region del dataset.

import seaborn as sns
import matplotlib.pyplot as plt

fmri = sns.load_dataset("fmri")

# customize the line plot
sns.lineplot(x="timepoint", y="signal", hue="event", style="region", markers=True, dashes=False, data=fmri)

# add labels and title
plt.xlabel("Timepoint")
plt.ylabel("Signal Intensity")
plt.title("Changes in Signal Intensity over Time")

# display the plot
plt.show()

Output:

Di nuovo, ho usato Seaborn per la base del line plot e Matplotlib per etichette degli assi e titolo. 

Creare bar plot in Seaborn

I bar plot sono usati per visualizzare la relazione tra una variabile categorica e una continua. In un bar plot, ogni barra rappresenta la media o la mediana (o qualunque aggregazione) della variabile continua per ciascuna categoria. In Seaborn, i bar plot si creano con la funzione barplot(). Per maggiori dettagli, vedi la nostra guida ai barplot di Seaborn.

import seaborn as sns

titanic = sns.load_dataset("titanic")
sns.barplot(x="class", y="fare", data=titanic)

Output:

Personalizziamo il grafico includendo la colonna sex del dataset.

import seaborn as sns
import matplotlib.pyplot as plt

titanic = sns.load_dataset("titanic")

# customize the bar plot
sns.barplot(x="class", y="fare", hue="sex", errorbar=None, palette="muted", data=titanic)

# add labels and title
plt.xlabel("Class")
plt.ylabel("Fare")
plt.title("Average Fare by Class and Gender on the Titanic")

# display the plot
plt.show()

Output:

Creare istogrammi in Seaborn

Gli istogrammi visualizzano la distribuzione di una variabile continua. Nei grafici, i dati sono divisi in bin e l’altezza di ogni bin rappresenta la frequenza o il conteggio dei punti dati in quel bin. In Seaborn, gli istogrammi si creano con la funzione histplot(). La nostra guida agli istogrammi in Seaborn approfondisce l’argomento.

import seaborn as sns

iris = sns.load_dataset("iris")
sns.histplot(x="petal_length", data=iris)

Output:

Personalizzare un istogramma

import seaborn as sns
import matplotlib.pyplot as plt

iris = sns.load_dataset("iris")

# customize the histogram
sns.histplot(data=iris, x="petal_length", bins=20, kde=True, color="green")

# add labels and title
plt.xlabel("Petal Length (cm)")
plt.ylabel("Frequency")
plt.title("Distribution of Petal Lengths in Iris Flowers")

# display the plot
plt.show()

Output:

Creare density plot in Seaborn

I density plot (detti anche kernel density estimate o grafici KDE) mostrano la distribuzione di una variabile continua come curva liscia invece che in bin discreti. Sono utili quando vuoi confrontare distribuzioni senza la sensibilità alla dimensione dei bin degli istogrammi. In Seaborn, creali con kdeplot(). 

import seaborn as sns

tips = sns.load_dataset("tips")

sns.kdeplot(data=tips, x="total_bill")

Output:

Miglioriamo il grafico personalizzandolo.

import seaborn as sns
import matplotlib.pyplot as plt

# Load the "tips" dataset from Seaborn
tips = sns.load_dataset("tips")

# Create a density plot of the "total_bill" column from the "tips" dataset
# We use the "hue" parameter to differentiate between "lunch" and "dinner" meal times
# We use the "fill" parameter to fill the area under the curve
# We adjust the "alpha" and "linewidth" parameters to make the plot more visually appealing
sns.kdeplot(data=tips, x="total_bill", hue="time", fill=True, alpha=0.6, linewidth=1.5)

# Add a title and labels to the plot using Matplotlib
plt.title("Density Plot of Total Bill by Meal Time")
plt.xlabel("Total Bill ($)")
plt.ylabel("Density")

# Show the plot
plt.show()

Output:

Creare box plot in Seaborn

I box plot sono un tipo di visualizzazione che mostra la distribuzione di un dataset. Sono comunemente usati per confrontare la distribuzione di una o più variabili tra categorie diverse.

import seaborn as sns

tips = sns.load_dataset("tips")

sns.boxplot(x="day", y="total_bill", data=tips)

Output:

Personalizza il box plot includendo la colonna time del dataset.

import seaborn as sns
import matplotlib.pyplot as plt

# load the tips dataset from Seaborn
tips = sns.load_dataset("tips")

# create a box plot of total bill by day and meal time, using the "hue" parameter to differentiate between lunch and dinner
# customize the color scheme using the "palette" parameter
# adjust the linewidth and fliersize parameters to make the plot more visually appealing
sns.boxplot(x="day", y="total_bill", hue="time", data=tips, palette="Set3", linewidth=1.5, fliersize=4)

# add a title, xlabel, and ylabel to the plot using Matplotlib functions
plt.title("Box Plot of Total Bill by Day and Meal Time")
plt.xlabel("Day of the Week")
plt.ylabel("Total Bill ($)")

# display the plot
plt.show()

Creare violin plot in Seaborn

Un violin plot è una visualizzazione che combina aspetti dei box plot e dei density plot. Mostra una stima di densità dei dati, di solito levigata con un kernel density estimator, insieme all’intervallo interquartile (IQR) e alla mediana in una forma simile a un box plot. 

La larghezza del violino rappresenta la stima di densità: le parti più larghe indicano maggiore densità; IQR e mediana sono mostrati come un punto e una linea bianchi all’interno del violino.

import seaborn as sns
import matplotlib.pyplot as plt

iris = sns.load_dataset("iris")

sns.violinplot(x="species", y="petal_length", data=iris)
plt.show()

Output:

Creare heatmap in Seaborn

Una heatmap usa i colori per rappresentare i valori in una matrice. Nell’analisi dei dati, le heatmap sono spesso usate per visualizzare matrici di correlazione. La nostra guida alle heatmap di Seaborn copre opzioni avanzate di personalizzazione.

import seaborn as sns
import matplotlib.pyplot as plt

# Load the dataset
tips = sns.load_dataset('tips')

# Create a heatmap of the correlation between variables
corr = tips.select_dtypes(include="number").corr()
sns.heatmap(corr, annot=True, cmap="coolwarm")

# Show the plot
plt.show()

Output:

Un altro esempio di heatmap usando il dataset flights.

import seaborn as sns
import matplotlib.pyplot as plt

# Load the dataset
flights = sns.load_dataset('flights')

# Pivot the data
flights = flights.pivot(index="month", columns="year", values="passengers")

# Create a heatmap
sns.heatmap(flights, cmap='Blues', annot=True, fmt='d')

# Set the title and axis labels
plt.title('Passengers per month')
plt.xlabel('Year')
plt.ylabel('Month')

# Show the plot
plt.show()

Output:

In questo esempio, usiamo il dataset flights della libreria seaborn. Riorganizziamo i dati per renderli adatti alla rappresentazione in heatmap usando il metodo .pivot(). Poi creiamo una heatmap con la funzione sns.heatmap() passando la variabile flights pivotata come argomento. 

Creare pair plot in Seaborn

I pair plot sono visualizzazioni in cui più scatter plot a coppie sono mostrati in un layout a matrice. Ogni scatter plot mostra la relazione tra due variabili, mentre i grafici diagonali mostrano la distribuzione delle singole variabili.

import seaborn as sns

# Load iris dataset
iris = sns.load_dataset("iris")

# Create pair plot
sns.pairplot(data=iris)

# Show plot
plt.show()

Output:

Possiamo personalizzare questo grafico usando i parametri hue e diag_kind.

import seaborn as sns
import matplotlib.pyplot as plt

# Load iris dataset
iris = sns.load_dataset("iris")

# Create pair plot with custom settings
sns.pairplot(data=iris, hue="species", diag_kind="kde", palette="husl")

# Set title
plt.title("Iris Dataset Pair Plot")

# Show plot
plt.show()

Output:

Creare joint plot in Seaborn

Un joint plot combina uno scatter plot (al centro) con istogrammi marginali (in alto e a destra) in un’unica figura. Questo layout mostra a colpo d’occhio sia la relazione tra due variabili sia le loro distribuzioni individuali.

Ecco un semplice esempio di joint plot con il dataset iris:

import seaborn as sns
import matplotlib.pyplot as plt

# load iris dataset
iris = sns.load_dataset("iris")

# plot a joint plot of sepal length and sepal width
sns.jointplot(x="sepal_length", y="sepal_width", data=iris)

# display the plot
plt.show()

Output:

Creare facet grid in Seaborn

FacetGrid crea una griglia di sottografi—uno per ogni valore unico in una variabile categorica. Questo ti permette di confrontare lo stesso grafico tra gruppi (ad es., la distribuzione del conto totale per ciascun giorno della settimana).

import seaborn as sns

# load the tips dataset
tips = sns.load_dataset('tips')

# create a FacetGrid for day vs total_bill
g = sns.FacetGrid(tips, col="day")

# plot histogram for total_bill in each day
g.map(sns.histplot, "total_bill")

Output:

Temi e stile in Seaborn

Seaborn fornisce cinque temi integrati che controllano l’aspetto generale dei grafici. Chiama sns.set_theme() all’inizio dello script per applicarne uno globalmente:

import seaborn as sns

sns.set_theme(style="whitegrid")  # options: darkgrid, whitegrid, dark, white, ticks

Puoi anche controllare la scala degli elementi del grafico con il parametro context. Questo regola dimensioni dei font, spessori delle linee e altri elementi per diversi formati di output:

sns.set_theme(style="whitegrid", context="talk")  # options: paper, notebook, talk, poster

Il contesto "notebook" (predefinito) funziona bene nei notebook Jupyter, mentre "talk" e "poster" ingrandiscono il tutto per le presentazioni.

Personalizzare i grafici Seaborn

Oltre allo stile predefinito, Seaborn ti dà controllo su palette di colori, dimensioni delle figure, temi e annotazioni. Ecco le personalizzazioni più comuni:

Cambiare le palette di colori

Ecco un esempio di come puoi cambiare le palette di colori dei tuoi grafici seaborn:

import seaborn as sns
import matplotlib.pyplot as plt

# Load sample dataset
tips = sns.load_dataset("tips")

# Create a scatter plot with color palette
sns.scatterplot(x="total_bill", y="tip", hue="day", data=tips, palette="Set2")

# Customize plot
plt.title("Total Bill vs Tip")
plt.xlabel("Total Bill ($)")
plt.ylabel("Tip ($)")
plt.show()

Output:

Regolare le dimensioni della figura

Per regolare le dimensioni della figura nei grafici seaborn, puoi usare l’esempio seguente come guida: 

import seaborn as sns
import matplotlib.pyplot as plt

# Load sample dataset
iris = sns.load_dataset("iris")

# Create a violin plot with adjusted figure size
plt.figure(figsize=(8,6))
sns.violinplot(x="species", y="petal_length", data=iris)

# Customize plot
plt.title("Petal Length Distribution by Species")
plt.xlabel("Species")
plt.ylabel("Petal Length (cm)")
plt.show()

Output:

Aggiungere annotazioni

Le annotazioni possono aiutare a rendere le visualizzazioni più leggibili. Ecco un esempio di come aggiungerle: 

import seaborn as sns
import matplotlib.pyplot as plt

# Load sample dataset
diamonds = sns.load_dataset("diamonds")

# Create a scatter plot with annotations
sns.scatterplot(x="carat", y="price", data=diamonds)

# Add annotations
plt.text(1, 18000, "Large, Expensive Diamonds", fontsize=12, color="red")
plt.text(2.5, 5000, "Small, Affordable Diamonds", fontsize=12, color="blue")

# Customize plot
plt.title("Diamond Prices by Carat")
plt.xlabel("Carat (ct)")
plt.ylabel("Price ($)")
plt.show()

Output:

Best practice per le visualizzazioni con Seaborn

Ecco alcune best practice da tenere a mente per ottenere il massimo da Seaborn.

Scegli il tipo di grafico giusto per i tuoi dati

Seaborn offre un’ampia gamma di tipi di grafico, ognuno pensato per tipi di dati e analisi diversi. È importante scegliere il tipo di grafico giusto per comunicare efficacemente i risultati. Ad esempio, uno scatter plot può essere più adatto a visualizzare la relazione tra due variabili continue, mentre un bar plot può essere più indicato per dati categorici.

Usa il colore in modo efficace

Il colore è uno strumento potente per la visualizzazione, ma va usato con criterio. Evita di usare troppi colori o tinte troppo vivaci, perché possono rendere il grafico difficile da leggere. Usa invece il colore per evidenziare informazioni importanti o raggruppare punti simili.

Etichetta gli assi e usa titoli chiari

Etichette e titoli sono essenziali per una visualizzazione efficace. Assicurati di etichettare chiaramente gli assi e fornire un titolo descrittivo. Aiuterà il tuo pubblico a capire il messaggio che vuoi comunicare.

Considera il pubblico

Quando crei visualizzazioni, è importante considerare il pubblico e il messaggio da comunicare. Se il tuo pubblico non è tecnico, usa un linguaggio chiaro e conciso, evita il gergo e fornisci spiegazioni semplici dei concetti statistici.

Usa analisi statistiche appropriate

Seaborn offre una serie di funzioni statistiche per analizzare i dati. Quando ne scegli una, assicurati che sia la più adatta ai tuoi dati e alla domanda di ricerca.

Personalizza le tue visualizzazioni

In Seaborn troverai molte opzioni di personalizzazione per migliorare le visualizzazioni. Sperimenta con font, stili e colori per trovare ciò che comunica meglio il tuo messaggio.

Scegliere la libreria di visualizzazione Python giusta

Partendo da quanto visto, ecco come si posiziona Seaborn rispetto a Matplotlib e ad altre due alternative che incontrerai, e quale libreria è adatta a quale caso d’uso:

Per la maggior parte del lavoro di analisi, uso Seaborn per l’esplorazione iniziale, Matplotlib per le rifiniture e Plotly quando l’output deve essere interattivo. Non sono strumenti mutuamente esclusivi.

Conclusione

Seaborn è una potente libreria di visualizzazione dati in Python che offre un’interfaccia intuitiva e facile da usare per creare grafici statistici informativi. Con la sua vasta gamma di strumenti, Seaborn permette di esplorare rapidamente dataset complessi e comunicare le intuizioni in modo efficace. 

Da scatter plot e line plot a heatmap e facet grid, Seaborn offre un ampio ventaglio di visualizzazioni per esigenze diverse. Inoltre, la sua integrazione con Pandas e Numpy lo rende uno strumento indispensabile per analisti e data scientist. 

Con questa guida introduttiva a Seaborn in Python, puoi iniziare a esplorare il mondo della visualizzazione dei dati e comunicare efficacemente le tue scoperte a un pubblico più ampio.

Se vuoi approfondire ulteriormente, dai un’occhiata ai nostri corsi Introduction to Data Visualization with Seaborn o Intermediate Data Visualization with Seaborn. 

In questi corsi imparerai a usare gli strumenti avanzati di visualizzazione di Seaborn per analizzare vari dataset reali, come l’American Housing Survey, i dati sulle tasse universitarie e gli ospiti di The Daily Show.

Puoi anche consultare il nostro cheat sheet su Seaborn gratuito.