Matplotlib Colormaps: Personalizzare gli schemi di colore

La visualizzazione dei dati è una delle migliori vie (se non la migliore) per gli analisti e gli scienziati dei dati per rappresentare informazioni complesse e generare insight significativi. Per sfruttare al massimo la tua opportunità di comunicare con gli stakeholder, ho raccolto informazioni utili sulle mappe dei colori di Matplotlib. 

Come vedrai in questo articolo, Matplotlib è una libreria di visualizzazione estremamente versatile ed estensibile in Python. Offre tutte le opzioni, dai grafici semplici a quelli interattivi completi. Se non sei generalmente familiare con Python, ti consiglio di iscriverti al nostro corso di Introduzione a Python prima di iniziare, per comprendere le sue basi. Personalmente, tengo sempre a portata di mano la Scheda di Ricordo di Python perché è un utile riferimento per le funzioni comuni.

Scegliere la Giusta Mappa dei Colori di Matplotlib

Una delle prime cose da considerare è decidere tra mappe dei colori sequenziali, divergenti o categoriali. Altri fattori importanti da considerare quando si scelgono le mappe dei colori includono l’uniformità percettiva, cioè che le differenze uguali nei valori dei dati vengono percepite come differenze uguali nei colori, e l’uso di opzioni di mappe dei colori adatte ai daltonici per rendere le tue visualizzazioni accessibili a tutte le audience.

Dovresti anche considerare diversi standard di dominio quando scegli le mappe dei colori. Ad esempio, diverse sfumature di blu rappresentano diverse profondità d’acqua negli studi oceanografici. Se non sei sicuro della mappa dei colori giusta per la tua visualizzazione, ci sono diversi strumenti e risorse a tua disposizione. In particolare, il nostro corso Introduzione alla Visualizzazione dei Dati con Matplotlib ti aiuta a lavorare attraverso molti scenari.

Mappe dei Colori Diverse in Matplotlib

In Python, il modulo matplotlib.colormaps fornisce l’accesso alle mappe dei colori incorporate, il che ti aiuta a selezionare lo schema più adatto al tuo progetto. Di seguito sono riportate le categorie più comuni di opzioni:

Mappe dei colori sequenziali

Le colormap sequenziali rappresentano dati ordinati che progressano da valori bassi a valori alti. esse transitono da tonalità chiare a tonalità scure, mostrando la magnitude dei dati a diversi livelli. Un esempio di colormap sequenziale è nelle mappe di calore per dati di temperatura, dove le colori più chiari rappresentano temperature più basse e le sfumature più scure rappresentano temperature più alte.

Supponiamo di avere un set di dati con colonne per data e temperatura. Il seguente codice creerà una mappa di calore per la temperatura.

Importare le librerie richieste
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.colors as mcolors

Fase 1: Estrarre le informazioni del mese e del giorno dalla colonna della data
calendar_data = temperature_data.copy()   Creare una copia su cui lavorare
calendar_data['Month'] = calendar_data['Date'].dt.strftime('%B')
calendar_data['Day'] = calendar_data['Date'].dt.day

Fase 2: Definire l'ordine dei mesi per una sequenza di calendario naturale
month_names = ['January', 'February', 'March', 'April', 'May', 'June', 
               'July', 'August', 'September', 'October', 'November', 'December']

Convertire la colonna 'Mese' in un tipo categorico con l'ordine specificato
calendar_data['Month'] = pd.Categorical(calendar_data['Month'], categories=month_names, ordered=True)

Fase 3: Pivotare i dati per creare una tabella strutturata per la mappa di calore
monthly_temperature_table = calendar_data.pivot(index='Month', columns='Day', values='Temperature')

Fase 4: Impostare il grafico per la mappa di calore
plt.figure(figsize=(12, 8))

Definire una normalizzazione personalizzata per l'intervallo di temperature (opzionale)
norm = mcolors.Normalize(vmin=15, vmax=35)

Creare la mappa di calore con una colormap sequenziale
heatmap = plt.imshow(monthly_temperature_table, cmap='YlOrRd', aspect='auto', norm=norm)

Aggiungere la barra dei colori per rappresentare la temperatura
colorbar = plt.colorbar(heatmap, orientation='horizontal')
colorbar.set_label('Temperature (°C)', labelpad=10)

Etichettare gli assi
plt.xlabel('Day of the Month')
plt.ylabel('Month')

Impostare le tacche dell'asse y per visualizzare i nomi dei mesi invece dei numeri
plt.yticks(ticks=np.arange(len(month_names)), labels=month_names)

Aggiungere un titolo alla mappa di calore
plt.title('Monthly Temperature Heatmap (Sequential Colormap)')

Visualizzare il grafico
plt.grid(False)
plt.show()

Esempio di visualizzazione delle colormaps sequenziali di Matplotlib. Immagine dell’Autore

Colormaps divergenti

Le mappe di colori divergenti evidenziano i dati con deviazioni da un valore centrale in entrambe le direzioni. Le mappe di colori divergenti hanno colori contrastanti per le direzioni positive e negative. Un’applicazione comune delle mappe di colori divergenti è nei dati finanziari per rappresentare profitto e perdita.

# Imposta 'Month' come indice
profit_loss_df.set_index('Month', inplace=True)

# Imposta la dimensione della figura
plt.figure(figsize=(8, 4))

# Crea una mappa di colori divergente
cmap = plt.cm.RdYlGn

# Visualizza i dati come una mappa di calore utilizzando imshow
im = plt.imshow(profit_loss_df.T, cmap=cmap, aspect='auto', vmin=-np.max(np.abs(profit_loss_data)), vmax=np.max(np.abs(profit_loss_data)))

# Aggiungi una barra dei colori con etichetta
cbar = plt.colorbar(im)
cbar.set_label('Profit/Loss ($)')

# Aggiungi annotazioni a ogni cella
for i, month in enumerate(profit_loss_df.index):
    plt.text(i, 0, f'{profit_loss_df.loc[month, "Profit/Loss"]:.2f}', ha='center', va='center', color='black')

# Imposta etichette e tick per gli assi x e y
plt.xlabel('Month')
plt.ylabel('')  # Non è necessario un'etichetta per l'asse y
plt.xticks(ticks=range(len(profit_loss_df.index)), labels=profit_loss_df.index, rotation=45)
plt.yticks([])  # Nascondi i tick dell'asse y poiché abbiamo solo una riga

# Aggiungi un titolo
plt.title('Profit/Loss Heatmap (Diverging Colormap)')

# Regola il layout per una migliore visualizzazione
plt.tight_layout()

# Mostra il grafico
plt.show()

Esempio di visualizzazione della mappa di colori divergente di Matplotlib. Immagine dell’Autore.

Mappe di colori cicliche

Le mappe di colori cicliche sono utili per visualizzare dati che rappresentano un modello ripetitivo o ciclico, come angoli, fasi d’onda o orario del giorno. Un esempio di utilizzo di una mappa di colori ciclica è la visualizzazione delle fasi di una funzione periodica, come un’onda sinusoidale.

# Creare dati per un'onda sinusoidale
x = np.linspace(0, 2 * np.pi, 100)  # Valori X da 0 a 2π (un ciclo completo)
y = np.sin(x)  # Valori Y (sinusoide di X)

# Creare una figura e un asse
plt.figure(figsize=(10, 6))

# Creare un grafico a dispersione con una mappa di colori ciclica
# Colorare i punti in base alla loro posizione nel ciclo dell'onda sinusoidale
points = plt.scatter(x, y, c=x, cmap='twilight', edgecolor='black')

# Aggiungere una barra dei colori per mostrare la fase dell'onda
cbar = plt.colorbar(points)
cbar.set_label('Wave Phase (Radians)', rotation=270, labelpad=15)

# Etichettare gli assi
plt.xlabel('Angle (Radians)')
plt.ylabel('Sine Value')

# Aggiungere un titolo
plt.title('Sine Wave with Cyclic Colormap (Twilight)')

# Visualizzare il grafico
plt.grid(True)
plt.show()

Esempio di visualizzazione della mappa di colori ciclica con Matplotlib. Immagine dell’autore.

Mappe di colori qualitative

Le colormaps qualitative sono ideali per rappresentare dati categorici senza un ordine particolare delle categorie. Un caso d’uso comune delle colormaps qualitative è il grafico a torta dove ogni segmento rappresenta una categoria diversa che può essere facilmente distinta.

# Dati categorici di esempio
categories = ['Category A', 'Category B', 'Category C', 'Category D', 'Category E']
values = [20, 35, 25, 10, 10]

# Impostare la dimensione della figura
plt.figure(figsize=(8, 8))

# Definire una colormap qualitativa manualmente
colors = ['#8dd3c7', '#ffffb3', '#bebada', '#fb8072', '#80b1d3']  # Codici esadecimali di colori selezionati manualmente

# Creare un grafico a torta
plt.pie(values, labels=categories, autopct='%1.1f%%', startangle=90, colors=colors)

# Rapporto di aspettativa uguale garantisce che la torta sia disegnata come un cerchio
plt.axis('equal')

# Aggiungere un titolo
plt.title('Pie Chart with Qualitative Colormap')

# Visualizzare il grafico
plt.show()

Esempio di visualizzazione della colormap qualitativa di Matplotlib. Immagine dell’Autore.

Colormaps arcobaleno

Le colormaps arcobaleno come hsv sono utilizzate quando è necessario un ampio intervallo di sfumature.

Genera dati ciclici
x = np.linspace(0, 2 * np.pi, 500)
y = np.sin(x)

Crea un grafico con la mappa dei colori arcobaleno
plt.scatter(x, y, c=x, cmap='hsv', s=50)

Aggiungi una barra dei colori
plt.colorbar(label='Phase')

Aggiungi etichette e titolo
plt.xlabel('Angle (radians)')
plt.ylabel('Sine Value')
plt.title('Cyclic Data Visualization using HSV Colormap')

Mostra il grafico
plt.show()

Esempio di visualizzazione della mappa dei colori arcobaleno di Matplotlib. Immagine dell’autore.

Mappe dei colori uniformi percettivamente

Mappe dei colori come inferno e plasma offrono una migliore visibilità attraverso diversi supporti di visualizzazione.

Genera dati sintetici di altitudine
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2)) * 100  Dati di altitudine

Plotta i dati di altitudine utilizzando la mappa dei colori 'plasma'
plt.contourf(X, Y, Z, cmap='plasma')

Aggiungi una barra dei colori
plt.colorbar(label='Elevation (m)')

Aggiungi titolo e etichette
plt.title('Topographic Map (Plasma Colormap)')
plt.xlabel('X Coordinate')
plt.ylabel('Y Coordinate')

Mostra il grafico
plt.show()

Esempio di visualizzazione della mappa dei colori uniforme percettiva Matplotlib. Immagine dell’Autore.

Creazione e Modifica delle Mappa dei Colori Matplotlib

Nonostante Matplotlib disponga di una vasta gamma di mappe dei colori predefinite, ci sono scenari in cui si potrebbe desiderare personalizzare i propri colori. Gli strumenti chiave per creare mappe dei colori personalizzate in Matplotlib sono ListedColormap e LinearSegmentedColormap.

Creare una mappa dei colori personalizzata con ListedColormap

ListedColormap ti permette di creare una mappa dei colori da un elenco di colori specifici. Questo metodo è utile quando si assegnano colori specifici a categorie distincte nei dati categorici.

from matplotlib.colors import ListedColormap

# Dati categorici
categories = ['Category A', 'Category B', 'Category C', 'Category D']
values = [25, 40, 35, 30]

# Elenco di colori personalizzati per la mappa dei colori (ad esempio, sfumature di blu, verde, rosso e viola)
custom_colors = ['#1f77b4', '#2ca02c', '#d62728', '#9467bd']

# Creare un ListedColormap utilizzando i colori personalizzati
custom_cmap = ListedColormap(custom_colors)

# Impostare la dimensione della figura
plt.figure(figsize=(8, 6))

# Creare un grafico a barre con la mappa dei colori personalizzata
bars = plt.bar(categories, values, color=custom_cmap.colors)

# Aggiungere un titolo
plt.title('Bar Chart with Custom ListedColormap')

# Etichettare gli assi
plt.xlabel('Categories')
plt.ylabel('Values')

# Visualizzare il grafico
plt.show()

Matplotlib custom colormap con ListedColormap. Immagine dell’Autore.

Creare una mappa dei colori personalizzata con LinearSegmentedColormap

LinearSegmentedColormap permette di creare mappe dei colori che transitano平滑 tra i colori. Questo è utile da sapere perché i dati continui spesso richiedono cambiamenti di gradiente di colore. Qui, sto anche specificando il numero di intervalli che voglio per la mia visualizzazione.

from matplotlib.colors import LinearSegmentedColormap

# Creare una griglia di valori per una funzione gaussiana 2D
x = np.linspace(-2, 2, 500)
y = np.linspace(-2, 2, 500)
X, Y = np.meshgrid(x, y)
Z = np.exp(- (X**2 + Y**2))

# Definire una colormap personalizzata che passa dal blu al bianco al rosso
colors = ['blue', 'white', 'red']
custom_cmap = LinearSegmentedColormap.from_list('blue_white_red', colors)

# Regolare il numero di classi di colore (livelli discreti)
# Specificare il numero di livelli (ad es, 10 per 10 bande di colore distinte)
num_classes = 10
levels = np.linspace(Z.min(), Z.max(), num_classes)

# Impostare la dimensione della figura
plt.figure(figsize=(8, 6))

# Tracciare la funzione gaussiana 2D con la mappa di colore regolata
contour = plt.contourf(X, Y, Z, levels=levels, cmap=custom_cmap)

# Aggiungere una barra di colore per mostrare le classi di colore discrete# Aggiungere una barra di colore per mostrare le classi di colore discrete. classi di colore discrete
plt.colorbar(contour, label='Gaussian Function Value')

# Aggiungere le etichette per gli assi
plt.xlabel('X')
plt.ylabel('Y')

# Aggiungere un titolo
plt.title(f'2D Gaussian with {num_classes} Discrete Color Classes')

# Visualizzare il grafico
plt.show()

Matplotlib regola in modo personalizzato il numero di classi di colore. Immagine d’autore.

Personalizzazione delle gamme di colore e dell’intensità

È possibile controllare l’intensità o la gamma dei colori in una mappa dei colori esistente manipolandone la normalizzazione o tagliandola per utilizzare un sottoinsieme dei colori disponibili. Nell’esempio seguente, le gamme di colori sono tagliate per mostrare temperature tra 16 e 40 gradi Celsius.

# Configurare il grafico per la mappa di calore
plt.figure(figsize=(12, 8))

# Definire una normalizzazione personalizzata per l'intervallo di temperature
norm = mcolors.Normalize(vmin=16, vmax=40)

# Creare la mappa di calore con una mappa dei colori sequenziale
heatmap = plt.imshow(monthly_temperature_table, cmap='YlOrRd', aspect='auto', norm=norm)

# Aggiungere la barra dei colori per rappresentare la temperatura
colorbar = plt.colorbar(heatmap, orientation='horizontal')
colorbar.set_label('Temperature (°C)', labelpad=10)

# Etichettare gli assi
plt.xlabel('Day of the Month')
plt.ylabel('Month')

# Impostare le tacche dell'asse y per visualizzare i nomi dei mesi invece dei numeri
plt.yticks(ticks=np.arange(len(month_names)), labels=month_names)

# Aggiungere un titolo alla mappa di calore
plt.title('Monthly Temperature Heatmap (Sequential Colormap)')

# Visualizzare il grafico
plt.grid(False)
plt.show()

Matplotlib personalizzazione delle gamme di colori e intensità. Immagine dell’Autore.

Combinare mappe dei colori esistenti

È possibile anche combinare le mappe di colori esistenti mescolando più mappe di colori per creare visualizzazioni più complesse.

from matplotlib.colors import LinearSegmentedColormap, Normalize

# Creare dati sintetici di elevazione
x = np.linspace(-180, 180, 500)  # Longitudine
y = np.linspace(-90, 90, 250)    # Latitudine
X, Y = np.meshgrid(x, y)
Z = 5000 * np.sin(np.sqrt(X**2 + Y**2) * np.pi / 180)  # Dati sintetici di elevazione

# Definire le mappe di colori di base ('viridis' e 'cividis')
cmap1 = plt.get_cmap('viridis')
cmap2 = plt.get_cmap('cividis')

# Creare una mappa di colori personalizzata mescolando le due mappe di colori di base
def blend_colormaps(cmap1, cmap2, blend_ratio=0.5):
    """Blend two colormaps together."""
    c1 = cmap1(np.linspace(0, 1, 256))
    c2 = cmap2(np.linspace(0, 1, 256))
    blended_colors = (1 - blend_ratio) * c1 + blend_ratio * c2
    return LinearSegmentedColormap.from_list('blended_cmap', blended_colors)

# Creare la mappa di colori mescolata
custom_cmap = blend_colormaps(cmap1, cmap2, blend_ratio=0.5)

# Normalizzare i dati per la visualizzazione
norm = Normalize(vmin=-5000, vmax=5000)

# Impostare la dimensione della figura
plt.figure(figsize=(12, 6))

# Tracciare i dati sintetici di elevazione con la mappa di colori mescolata
contour = plt.contourf(X, Y, Z, levels=100, cmap=custom_cmap, norm=norm)

# Aggiungere una barra dei colori per mostrare la mappatura dei colori mescolati
plt.colorbar(contour, label='Elevation (meters)')

# Aggiungere etichette per gli assi
plt.xlabel('Longitude')
plt.ylabel('Latitude')

# Aggiungere un titolo
plt.title('Geographical Elevation Data with Blended Colormap (Viridis + Cividis)')

# Visualizzare il grafico
plt.show()

Matplotlib Combinazione delle colormap esistenti. Immagine dell’Autore.

Inversione delle colormap utilizzando il suffisso _r

È possibile invertire qualsiasi colormap in Matplotlib aggiungendo il suffisso _r al suo nome.

# Impostazione del grafico per la mappa di calore
plt.figure(figsize=(12, 8))

# Creazione di una normalizzazione personalizzata per l'intervallo dei colori
norm = mcolors.Normalize(vmin=16, vmax=40)

# Plot della mappa di calore utilizzando imshow con la colormap sequenziale
im = plt.imshow(monthly_temperature_table, cmap='YlOrRd_r', norm=norm, aspect='equal')

# Aggiunta di una barra dei colori con orientazione orizzontale
cbar = plt.colorbar(im, orientation='horizontal', pad=0.1)
cbar.set_label('Temperature (°C)', labelpad=10)

# Aggiunta di etichette per gli assi
plt.xlabel('Day of the Month')
plt.ylabel('Month')

# Impostazione delle etichette y per visualizzare i nomi dei mesi invece dei numeri
plt.yticks(ticks=np.arange(len(month_names)), labels=month_names)

# Aggiunta di un titolo
plt.title('Temperature Heatmap (Sequential Colormap)')

# Visualizzazione del grafico
plt.show()

Matplotlib Inversione delle colormap utilizzando il suffisso _r. Immagine dell’Autore.

Gestione degli errori comuni nelle colormap di Matplotlib

Quando si lavora con le mappe dei colori in Matplotlib, potresti incontrare errori che influenzano il tuo flusso di lavoro. Di seguito sono riportati alcuni di questi errori e come risolverli.

AttributeError: module ‘matplotlib’ has no attribute ‘colormaps’

Questo errore si verifica quando utilizzi versioni di Matplotlib precedenti alla 3.4.0 per accedere a matplotlib.colormaps. L’attributo colormaps è stato introdotto in Matplotlib 3.4.0. Per iniziare a risolvere questo errore, verifica la tua versione di Matplotlib utilizzando il codice riportato di seguito.

import matplotlib
print(matplotlib.__version__)

Aggiorna utilizzando il seguente comando pip.

pip install --upgrade matplotlib

Se hai problemi ad aggiornare la tua versione di Matplotlib, prova il seguente metodo per accedere alle mappe dei colori.

plt.get_cmap('viridis')  # invece di matplotlib.colormaps['viridis']

Assegnazioni di colore errate

Puoi sperimentare assegnazioni di colore errate quando passi un valore fuori dall’intervallo previsto o quando la mappa dei colori viene applicata in modo errato. L’assegnazione errata del colore potrebbe anche insorgere se la mappa dei colori è destinata a dati continui ma viene applicata a dati categorici o viceversa.

Per assicurarti che i tuoi dati siano all’interno dell’intervallo previsto, normalizza o scala sempre i dati utilizzando i parametri vmax e vmin.

import matplotlib.colors as mcolors

# Crea un set di dati di temperatura di esempio
data = np.random.rand(10, 10) * 100  # Regola l'intervallo per adattarlo ai tuoi dati

# Crea una istanza di normalizzazione dei colori per scalare i dati all'intervallo della mappa dei colori
norm = mcolors.Normalize(vmin=0, vmax=100)

# Crea una mappa di calore utilizzando la mappa dei colori 'viridis' e la normalizzazione specificata
plt.imshow(data, cmap='viridis', norm=norm, interpolation='nearest')
plt.colorbar()
plt.show()

Per un controllo più fine, puoi definire esplicitamente i confini dei colori utilizzando i parametri boundaries o norm nelle funzioni di tracciamento.

Artefatti visivi e risultati inaspettati

Lavorando con dati discreti o a bassa risoluzione, potresti sperimentare bande di colore indesiderate, eccessivo contrasto o sfumature di colore. Il problema si verifica quando i tuoi dati hanno un intervallo limitato ma vengono visualizzati con una mappa dei colori continua.

Per risolvere questo problema, utilizza più punti dati o aggiusta il numero di livelli di colore per smussare le transizioni.

# Aumenta il numero di bin nella mappa dei colori
cmap = plt.get_cmap('viridis', 256)
plt.imshow(data, cmap=cmap)

È possibile suddividere la mappa dei colori in livelli fissi per gestire i dati discreti laddove appropriato.

cmap = plt.get_cmap('inferno', 10)  # Dividi la mappa dei colori in 10 livelli discreti
plt.imshow(data, cmap=cmap)

Puoi anche controllare le impostazioni di visualizzazione e regolare la risoluzione, specialmente quando salvi le visualizzazioni, per evitare grafici a bassa risoluzione

plt.savefig('plot.png', dpi=300)  # Salva l'immagine con una risoluzione più alta

Distorsione del colore dovuta al taglio

La distorsione del colore si verifica quando i dati contengono valori estremi al di fuori dell’intervallo di colore atteso. Questo causes parties dei dati a essere tagliati e assegnati il colore minimo o massimo nella mappa dei colori.

Per evitare la distorsione del colore, regola i limiti di colore utilizzando vmin e vmax per corrispondere all’intervallo dei tuoi dati, prevenendo il taglio.

plt.imshow(data, cmap='plasma', vmin=0, vmax=100)

Dovresti anche utilizzare una scala robusta per gestire gli outliers impostando limiti personalizzati che escludano valori estremi.

import numpy as np
robust_vmin, robust_vmax = np.percentile(data, [2, 98])  # Usa i percentili per rimuovere outliers estremi
plt.imshow(data, cmap='inferno', vmin=robust_vmin, vmax=robust_vmax)

La mappa dei colori non si visualizza correttamente nei grafici 3D

Se c’è un problema con il modo in cui i dati sono mappati sulla superficie 3D, le mappe dei colori potrebbero non visualizzarsi correttamente nelle visualizzazioni 3D. Per risolvere, assicurati che i dati dell’asse z siano normalizzati per adattarsi all’intervallo atteso della mappa dei colori. Inoltre, utilizza i limiti appropriati della mappa dei colori per catturare l’intero intervallo dei valori z.

from mpl_toolkits.mplot3d import Axes3D

Generare dati di esempio per un grafico tridimensionale di superficie
X, Y = np.meshgrid(np.linspace(-5, 5, 50), np.linspace(-5, 5, 50))
Z = np.sin(np.sqrt(X**2 + Y**2))

Creare un oggetto di assi tridimensionale
ax = plt.axes(projection='3d')

Tracciare la superficie utilizzando la mappa dei colori 'viridis' e regolando i limiti di colore
ax.plot_surface(X, Y, Z, cmap='viridis', vmin=np.min(Z), vmax=np.max(Z))
plt.show()

Conclusione

Scegliere la giusta mappa dei colori è un passo importante perché davvero influisce su come gli utenti vedono e comprendono i tuoi dati. A mio avviso, spendere molto tempo sull’analisi dei dati ma essere superficiali nell’ultima fase, che è quella in cui comunichi le tue scoperte, è un grande errore.

Fortunatamente, Matplotlib offre molte opzioni per assicurarti che le tue visualizzazioni raccontino una storia avvincente. Iscriviti al nostro corso, Introduzione alla Visualizzazione dei Dati con Matplotlib, per diventare un esperto. Inoltre, se sei un utente Python che utilizza anche Seaborn per la visualizzazione (è ottimo conoscere entrambi), leggi la nostra Guida Rapida per Scegliere i Colori in Seaborn e segui con il nostro Introduzione alla Visualizzazione dei Dati con Seaborn corso.