Tutorial Matplotlib: grafici a linee, barre e dispersione in Python

In questo tutorial vedrai come creare grafici a linee, a barre e a dispersione in Matplotlib usando dati di borsa. Il tutorial presuppone una certa familiarità con gli array NumPy e i DataFrame di pandas. Spiegherò cosa fa ogni chiamata di libreria quando compare, ma il focus principale qui è Matplotlib.

TL;DR

• Matplotlib è la libreria di grafici fondamentale di Python — installa con pip install matplotlib e importa con import matplotlib.pyplot as plt

• Crea grafici a linee con plt.plot(x, y), a barre con plt.bar(x, height) e a dispersione con plt.scatter(x, y)

• Chiama sempre plt.show() per visualizzare il grafico, oppure plt.savefig('filename.png') per salvarlo

• Personalizza con plt.title(), plt.xlabel(), plt.ylabel() e il parametro color

• Usa le mappe di colori (cmap) per dati continui e plt.legend() per grafici con più serie

Che cos'è Matplotlib?

Matplotlib è la libreria di visualizzazione dei dati più utilizzata in Python, con oltre 50 milioni di download mensili nel 2026. Crea grafici statici, interattivi e animati, tra cui linee, barre, dispersioni, istogrammi e altro. La maggior parte delle altre librerie di visualizzazione in Python (Seaborn, il plotting di pandas e persino parti di Plotly) si basano su Matplotlib.

Matplotlib offre un controllo dettagliato su ogni elemento visivo, il che richiede più codice anche per grafici di base. Se la priorità sono grafici esplorativi rapidi, Seaborn fornisce impostazioni di livello più alto che hanno un buon aspetto subito. Per grafici interattivi sul web, Plotly Express è un'altra opzione da considerare.

Alla fine di questo tutorial saprai creare grafici a linee, a barre e a dispersione come quello qui sotto, insieme alle basi della personalizzazione: scelta dei colori, aggiunta di etichette e titoli, impostazione dei limiti degli assi e salvataggio delle figure su file.

Primi passi con Matplotlib

Senza ulteriori indugi, carichiamo Matplotlib e diamo un'occhiata rapida al dataset usato in questo tutorial.

Caricare Matplotlib

Prima di creare qualsiasi grafico, devi importare la libreria. Il sottomodulo pyplot fornisce tutte le funzioni di plotting usate in questo tutorial.

La convenzione è dare a pyplot l'alias plt. Importo anche pandas, NumPy e datetime perché serviranno più avanti.

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from datetime import datetime

Caricare il dataset dell'indice DJIA

Matplotlib è progettata per funzionare con array NumPy e dataframe pandas. La libreria rende semplice costruire grafici a partire da dati tabellari. In questo tutorial useremo i prezzi storici del Dow Jones Industrial Average (DJIA) dal 2022-01-01 al 2022-12-31 (disponibili qui). Puoi impostare l'intervallo di date sulla pagina e quindi cliccare sul pulsante “download a spreadsheet”.

Caricheremo il file CSV, chiamato HistoricalPrices.csv, usando la libreria pandas e visualizzeremo le prime righe con il metodo .head().

import pandas as pd

djia_data = pd.read_csv('HistoricalPrices.csv')
djia_data.head()

Vediamo che i dati includono 4 colonne: Date, Open, High, Low e Close. Le ultime 4 sono relative al prezzo dell'indice durante la giornata di contrattazioni. Di seguito una breve spiegazione di ciascuna variabile.

• Date: Il giorno a cui si riferiscono le informazioni sul prezzo.
• Open: Il prezzo del DJIA alle 9:30 AM ET all'apertura del mercato.
• High: Il prezzo più alto raggiunto dal DJIA durante la giornata.
• Low: Il prezzo più basso raggiunto dal DJIA durante la giornata.
• Close: Il prezzo del DJIA alla chiusura del mercato alle 4:00 PM ET.

Come rapido step di pulizia, useremo anche il metodo rename() in pandas, dato che il dataset scaricato ha uno spazio extra nei nomi delle colonne.

djia_data = djia_data.rename(columns = {' Open': 'Open', ' High': 'High', ' Low': 'Low', ' Close': 'Close'})

Convertiamo inoltre la colonna Date in tipo datetime e ordiniamo in ordine crescente per data. Per saperne di più sulla conversione dei tipi di dato, vedi il tutorial Conversione dei tipi di dato in Python.

djia_data['Date'] = pd.to_datetime(djia_data['Date'])
djia_data = djia_data.sort_values(by = 'Date')

Disegnare grafici a linee con Matplotlib

I grafici a linee mostrano come i valori cambiano su una dimensione continua, più spesso nel tempo. Sono i grafici di riferimento per le serie temporali perché i punti collegati rivelano trend, stagionalità e anomalie a colpo d'occhio.

Grafici a linee con una singola linea

Possiamo creare un grafico a linee in matplotlib usando il metodo plt.plot(), dove il primo argomento è la variabile x e il secondo è la variabile y. Ogni volta che creiamo un grafico, dobbiamo ricordarci di chiamare plt.show() per visualizzarlo. Visualizzeremo il prezzo di chiusura del DJIA nel tempo.

plt.plot(djia_data['Date'], djia_data['Close'])
plt.show()

Si vede che nel corso dell'anno il prezzo dell'indice è partito dal suo valore più alto, seguito da alcune oscillazioni su e giù durante l'anno. Notiamo il valore più basso intorno a ottobre, seguito da un forte aumento verso fine anno.

Grafici a linee con più linee

Possiamo visualizzare più linee nello stesso grafico aggiungendo un'altra chiamata a plt.plot() prima della funzione plt.show().

plt.plot(djia_data['Date'], djia_data['Open'])
plt.plot(djia_data['Date'], djia_data['Close'])


plt.show()

Nell'arco dell'anno, i prezzi di apertura e chiusura del DJIA sono stati relativamente vicini tra loro per ciascun giorno, senza un chiaro schema di uno sempre sopra o sotto l'altro.

Aggiungere una legenda

Se vogliamo distinguere quale linea rappresenta quale colonna, possiamo aggiungere una legenda. Questo crea un'etichetta colorata in un angolo del grafico. Possiamo farlo con plt.legend() e aggiungendo parametri label a ciascuna chiamata plt.plot().

plt.plot(djia_data['Date'], djia_data['Open'], label = 'Open')
plt.plot(djia_data['Date'], djia_data['Close'], label = 'Close')
plt.legend()
plt.show()

Ora vediamo una legenda con le etichette specificate nella posizione predefinita in alto a destra (la posizione può essere impostata con l'argomento loc in plt.legend()).

Disegnare grafici a barre con Matplotlib

I grafici a barre sono molto utili per confrontare valori numerici tra categorie. Sono particolarmente efficaci per individuare le categorie con valori massimi e minimi.

Per questa sezione, aggreghiamo i dati in medie mensili usando pandas .groupby() così da poter confrontare l'andamento mensile del DJIA. Per approfondire le operazioni di raggruppamento, vedi il tutorial Pandas GroupBy.

# Import the calendar package 
from calendar import month_name

# Order by months by chronological order
djia_data['Month'] = pd.Categorical(djia_data['Date'].dt.month_name(), month_name[1:])

# Group metrics by monthly averages
djia_monthly_mean = djia_data \
    .groupby('Month') \
    .mean(numeric_only=True) \
    .reset_index()

djia_monthly_mean.head(6)

Grafici a barre verticali

Partiamo creando un grafico a barre con barre verticali. Si fa con il metodo plt.bar(), con il primo argomento come variabile dell'asse x (Month) e il parametro height come variabile dell'asse y (Close). Quindi ricordiamoci di chiamare plt.show() per mostrare il grafico.

plt.bar(djia_monthly_mean['Month'], height = djia_monthly_mean['Close'])
plt.show()

Si vede che la maggior parte dei prezzi di chiusura del DJIA sono stati simili, con il valore medio di chiusura più basso a giugno e quello più alto a gennaio.

Riordinare le barre nei grafici a barre

Se vogliamo mostrare queste barre in ordine dal prezzo medio di chiusura più alto al più basso, possiamo ordinare le barre con il metodo sort_values() di pandas e poi usare lo stesso metodo plt.bar().

djia_monthly_mean_srtd = djia_monthly_mean.sort_values(by = 'Close', ascending = False)

plt.bar(djia_monthly_mean_srtd['Month'], height = djia_monthly_mean_srtd['Close'])
plt.show()

Come vedi, è molto più semplice capire quali mesi hanno avuto il prezzo medio di chiusura del DJIA più alto e quali i più bassi. È anche più facile confrontare e classificare i mesi.

Grafici a barre orizzontali

A volte è più facile interpretare i grafici a barre e leggere le etichette quando usiamo barre orizzontali. Possiamo farlo con il metodo plt.barh().

plt.barh(djia_monthly_mean_srtd['Month'], width = djia_monthly_mean_srtd['Close'])
plt.show()

Come puoi vedere, le etichette di ogni categoria (mese) sono più facili da leggere rispetto a quando le barre erano verticali. Possiamo comunque confrontare agevolmente i gruppi. Questo grafico orizzontale è particolarmente utile quando le categorie sono molte.

Disegnare grafici a dispersione con Matplotlib

I grafici a dispersione mostrano la relazione tra due variabili numeriche. Ogni punto rappresenta un'osservazione e l'andamento generale rivela se esiste una relazione lineare, non lineare o nessuna relazione, informando direttamente la scelta della tecnica di modellazione.

Creare un grafico a dispersione di base

Come per gli altri grafici, un grafico a dispersione si crea con pyplot.scatter(), dove il primo argomento è la variabile sull'asse x e il secondo è la variabile sull'asse y. In questo esempio, osserveremo la relazione tra i prezzi di apertura e chiusura del DJIA.

plt.scatter(djia_data['Open'], djia_data['Close'])
plt.show()

Sull'asse x abbiamo il prezzo di apertura del DJIA, e sull'asse y il prezzo di chiusura. Come prevedibile, all'aumentare del prezzo di apertura, vediamo una forte relazione con l'aumento del prezzo di chiusura.

Aggiungere una linea di tendenza

Ora aggiungeremo una linea di tendenza al grafico per mostrare in modo più esplicito la relazione lineare tra le variabili open e close. Per farlo useremo i metodi polyfit() e poly1d() di numpy. Il primo restituisce un fit polinomiale ai minimi quadrati in cui il primo argomento è la variabile x, il secondo è la variabile y e il terzo è il grado del fit (1 per lineare). Il secondo restituisce una classe polinomiale monodimensionale che possiamo usare per creare una linea di tendenza con plt.plot().

z = np.polyfit(djia_data['Open'], djia_data['Close'], 1)
p = np.poly1d(z)


plt.scatter(djia_data['Open'], djia_data['Close'])
plt.plot(djia_data['Open'], p(djia_data['Open']))
plt.show()

Come si vede, la linea sullo sfondo segue da vicino l'andamento dello scatterplot, poiché la relazione tra prezzo di apertura e di chiusura è fortemente lineare. All'aumentare del prezzo di apertura, il prezzo di chiusura aumenta in genere a un ritmo simile e lineare.

Impostare titolo del grafico ed etichette degli assi

Titoli ed etichette degli assi aiutano chi guarda a capire quali dati sta osservando. Matplotlib fornisce plt.title(), plt.xlabel() e plt.ylabel() per annotare un grafico. Ecco lo scatterplot precedente con tutti e tre aggiunti:

plt.scatter(djia_data['Open'], djia_data['Close'])
plt.title('DJIA 2022: Open vs. Close Price')
plt.xlabel('Open Price ($)')
plt.ylabel('Close Price ($)')
plt.show()

Cambiare i colori

Le scelte di colore influiscono sia sulla leggibilità sia sull'enfasi. In Matplotlib, i colori possono essere specificati in tre modi:

• Colori nominali: "red", "blue", "steelblue"

• Codici esadecimali: "#f4db9a", "#383c4a"

• Tuple RGB: (0.49, 0.39, 0.15), (0.12, 0.21, 0.47)

Cambiare il colore della linea

Per un grafico a linee possiamo cambiare il colore usando l'attributo color in plt.plot(). Sotto, cambiamo il colore della linea del prezzo di apertura in “black” e quella del prezzo di chiusura in “red”.

plt.plot(djia_data['Date'], djia_data['Open'], color = 'black')
plt.plot(djia_data['Date'], djia_data['Close'], color = 'red')
plt.show()

Cambiare il colore delle barre

Per le barre, possiamo passare una lista all'attributo color per specificare il colore di ciascuna barra. Diciamo che vogliamo evidenziare il prezzo medio di gennaio per sostenere un punto sulla forza del prezzo medio di chiusura. Possiamo farlo assegnando a quella barra un colore unico per attirare l'attenzione.

plt.bar(djia_monthly_mean_srtd['Month'], height = djia_monthly_mean_srtd['Close'], color = ['blue', 'gray', 'gray', 'gray', 'gray', 'gray'])
plt.show()

Cambiare il colore dei punti

Infine, per i grafici a dispersione, possiamo cambiare il colore usando l'attributo color di plt.scatter(). Coloreremo tutti i punti di gennaio in blu e tutti gli altri in grigio per mostrare una storia simile alla visualizzazione sopra.

plt.scatter(djia_data[djia_data['Month'] == 'January']['Open'], djia_data[djia_data['Month'] == 'January']['Close'], color = 'blue')

plt.scatter(djia_data[djia_data['Month'] != 'January']['Open'], djia_data[djia_data['Month'] != 'January']['Close'], color = 'gray')

plt.show()

Usare le mappe di colori

Le mappe di colori sono scale cromatiche integrate in Matplotlib che mappano valori numerici su un gradiente di colore (documentazione ufficiale). Per un approfondimento, vedi il nostro tutorial sulle mappe di colori in Matplotlib. Le colormap tendono ad avere un aspetto gradevole e aiutano a raccontare un'evoluzione dei valori.

Nell'esempio seguente usiamo una colormap passando il prezzo di chiusura (variabile y) all'attributo c e la colormap plasma tramite cmap. Si vede che all'aumentare dei valori il colore associato diventa più brillante e giallo, mentre l'estremo inferiore è viola e più scuro.

plt.scatter(djia_data['Open'], djia_data['Close'], c=djia_data['Close'], cmap = plt.cm.plasma)

plt.show()

Impostare i limiti degli assi

A volte è utile osservare un intervallo specifico di valori in un grafico. Per esempio, se il DJIA sta attualmente scambiando intorno ai $30.000, potremmo interessarci solo al comportamento attorno a quel prezzo. Possiamo passare una tupla a plt.xlim() e plt.ylim() per impostare rispettivamente i limiti di x e y. Il primo valore della tupla è il limite inferiore e il secondo è il limite superiore.

plt.scatter(djia_data['Open'], djia_data['Close'])
plt.xlim((29000, 34000))
plt.ylim((29000, 34000))
plt.title('DJIA Open vs Close (Zoomed In)')
plt.xlabel('Open Price ($)')
plt.ylabel('Close Price ($)')
plt.show()

Salvare i grafici

Una volta ottenuto un grafico soddisfacente, puoi salvarlo su file. Matplotlib supporta formati come PNG, PDF, SVG e altri tramite plt.savefig(). Il formato è dedotto dall'estensione del file.

Possiamo infine salvare i grafici creati in matplotlib con il metodo plt.savefig(). Possiamo salvare il file in molti formati diversi, tra cui “png”, “pdf” e “svg”. Il primo argomento è il nome del file. Il formato è dedotto dall'estensione (oppure puoi forzarlo con l'argomento format).

plt.scatter(djia_data['Open'], djia_data['Close'])
plt.savefig('DJIA 2022 Scatterplot Open vs. Close.png')

Considerazioni finali

Questo tutorial ha trattato grafici a linee, a barre e a dispersione, i tre tipi di grafico che userai più spesso. Matplotlib richiede più codice rispetto a librerie di livello più alto come Seaborn o Plotly, ma quella verbosità ti dà un controllo al livello del singolo pixel su ogni elemento della figura.

Da qui ti consiglio di esplorare istogrammi, grafici a torta e mappe di colori come prossimi passi. Se vuoi un percorso strutturato, il corso Introduction to Data Visualization with Matplotlib copre subplot, stile e condivisione delle figure in quattro ore.