Corso
Analisi esplorativa dei dati in Python
4 ore
119.3K
Tipi comuni di grafici dei dati in Python
Partiamo dai grafici più comuni, ampiamente usati in molti ambiti e realizzabili nella maggior parte delle librerie di visualizzazione dati in Python (tranne alcune molto specialistiche).
Grafico a barre
Il grafico a barre è la visualizzazione più comune per mostrare i valori numerici di dati categorici e confrontare varie categorie tra loro. Le categorie sono rappresentate da barre rettangolari di uguale larghezza e con altezze (per grafici verticali) o lunghezze (per grafici orizzontali) proporzionali ai valori numerici corrispondenti.
Per creare un grafico a barre di base in matplotlib, usiamo la funzione matplotlib.pyplot.bar(), come segue:
# Data preparation
penguins_grouped = penguins[['species', 'bill_length_mm']].groupby('species').mean().reset_index()
# Creating a bar chart
plt.bar(penguins_grouped['species'], penguins_grouped['bill_length_mm'])
plt.title('Average penguin bill length by species')
plt.show()
Possiamo personalizzare ulteriormente la larghezza e il colore delle barre, lo spessore e il colore dei bordi, aggiungere etichette, riempire le barre con pattern, ecc.
Grafico a linee
Un grafico a linee mostra la progressione di una variabile da sinistra a destra lungo l'asse x tramite punti dati connessi da segmenti di linea retti. Tipicamente, si rappresenta il cambiamento di una variabile nel tempo. Infatti, i grafici a linee sono spesso usati per visualizzare serie storiche, come discusso nel tutorial su grafici a linee per serie temporali in Matplotlib.
Possiamo creare un grafico a linee di base in matplotlib usando la funzione matplotlib.pyplot.plot(), come segue:
# Data preparation
flights_grouped = flights[['year', 'passengers']].astype({'year': 'string'}).groupby('year').sum().reset_index()
# Creating a line plot
plt.plot(flights_grouped['year'], flights_grouped['passengers'])
plt.title('Total number of passengers by year')
plt.show()
È possibile regolare spessore, stile, colore e trasparenza della linea, aggiungere e personalizzare i marker, ecc.
Il tutorial Line Plots in MatplotLib with Python offre più spiegazioni ed esempi su come creare e personalizzare un grafico a linee in matplotlib. Per imparare a creare e personalizzare un grafico a linee in seaborn, leggi Python Seaborn Line Plot Tutorial: Create Data Visualizations.
Grafico a dispersione (scatter)
Un grafico a dispersione mostra le relazioni tra due variabili tracciate come punti sul piano cartesiano. Si usa per verificare se le due variabili sono correlate, quanto è forte la correlazione e se ci sono cluster distinti nei dati.
Il codice seguente illustra come creare un grafico a dispersione di base in matplotlib usando la funzione matplotlib.pyplot.scatter():
# Creating a scatter plot
plt.scatter(penguins['bill_length_mm'], penguins['bill_depth_mm'])
plt.title('Penguin bill length vs. bill depth')
plt.show()
Possiamo regolare dimensione, stile, colore e trasparenza dei punti, spessore e colore dei bordi, ecc.
Puoi leggere di più sui grafici a dispersione (e non solo!) in questo tutorial: Data Demystified: visualizzazioni che catturano le relazioni.
Istogramma
Un istogramma rappresenta la distribuzione di frequenza dei valori di una variabile numerica. Suddivide i dati in intervalli di valori chiamati bin, conta i punti in ciascun bin e mostra ogni bin come una barra verticale, con altezza proporzionale al conteggio. Si può considerare un tipo specifico di grafico a barre, ma le barre adiacenti sono attaccate senza spazi, dato il carattere continuo dei bin.
Possiamo creare facilmente un istogramma di base in matplotlib usando la funzione matplotlib.pyplot.hist():
# Creating a histogram
plt.hist(penguins['bill_length_mm'])
plt.title('Penguin bill length distribution')
plt.show()
È possibile personalizzare molti aspetti: colore e stile, numero di bin, estremi dei bin, range inferiore e superiore, istogramma regolare o cumulativo, ecc.
Per altri esempi di istogrammi, vedi Istogrammi in Matplotlib e Come creare un istogramma con Plotly.
Box plot
Un box plot mostra un set di cinque statistiche descrittive dei dati: valori minimo e massimo (escludendo gli outlier), mediana e primo e terzo quartile. Opzionalmente, può mostrare anche la media. È la scelta giusta se ti interessano solo queste statistiche, senza esplorare la reale distribuzione sottostante.
Nel tutorial 11 tecniche di visualizzazione dei dati per ogni caso d'uso con esempi trovi, tra le altre cose, spiegazioni più dettagliate sul tipo di informazioni statistiche che puoi ottenere da un box plot.
Possiamo creare un box plot di base in matplotlib usando la funzione matplotlib.pyplot.boxplot(), come sotto:
# Data preparation
penguins_cleaned = penguins.dropna()
# Creating a box plot
plt.boxplot(penguins_cleaned['bill_length_mm'])
plt.title('Penguin bill length distribution')
plt.show()
C'è ampio margine di personalizzazione: larghezza e orientamento della box, posizione di box e baffi, visibilità e stile dei vari elementi, ecc.
Nota che per creare un box plot con questa funzione dobbiamo prima assicurarci che i dati non contengano valori mancanti. Nell'esempio sopra abbiamo rimosso i missing prima del plot. Per confronto, Seaborn non ha questa limitazione e gestisce i valori mancanti internamente, come segue:
# Creating a box plot
sns.boxplot(data=penguins, y='bill_length_mm')
plt.title('Penguin bill length distribution')
plt.show()
Grafico a torta
Un grafico a torta è una visualizzazione rappresentata da un cerchio diviso in settori, dove ogni settore corrisponde a una categoria dei dati categorici e l'angolo di ciascun settore riflette la proporzione di quella categoria sul totale. A differenza dei grafici a barre, i grafici a torta dovrebbero rappresentare le categorie che costituiscono un intero, ad esempio i passeggeri di una nave.
I grafici a torta hanno alcuni svantaggi:
- Gli angoli sono più difficili da interpretare per l'occhio umano rispetto alle lunghezze e possono essere fuorvianti.
- Sono meno efficaci in presenza di cinque o più categorie.
- Non possono mostrare più di un set di dati categorici. In altre parole, non possono essere raggruppati, a differenza dei grafici a barre.
- Non rivelano facilmente i valori reali.
- Non sono informativi quando le categorie hanno differenze di valore ridotte.
Quindi i grafici a torta vanno usati con parsimonia e cautela.
Per creare un grafico a torta di base in matplotlib, usiamo la funzione matplotlib.pyplot.pie(), come segue:
# Data preparation
titanic_grouped = titanic.groupby('class')['pclass'].count().reset_index()
# Creating a pie chart
plt.pie(titanic_grouped['pclass'], labels=titanic_grouped['class'])
plt.title('Number of passengers by class')
plt.show()
Se necessario, possiamo regolare il grafico a torta: cambiare i colori degli spicchi, aggiungere un offset ad alcuni (di solito quelli molto piccoli), modificare il raggio del cerchio, personalizzare il formato delle etichette, riempire alcuni o tutti gli spicchi con pattern, ecc.
Per approfondire i grafici a torta, inclusa l'aggiunta di percentuali e spicchi "esplosi", leggi Python Pie Chart: Build and Style with Pandas and Matplotlib.
Tipi avanzati di grafici dei dati in Python
In questa sezione esploriamo vari grafici avanzati. Alcuni sono variazioni più sofisticate dei tipi comuni visti prima, altri sono tipologie a sé.
Grafico a barre raggruppate
Mentre un comune grafico a barre mostra i valori numerici di una variabile categorica per categoria, un grafico a barre raggruppate serve allo stesso scopo ma su due variabili categoriche. Graficamente, abbiamo più gruppi di barre: ogni gruppo è legato a una categoria della prima variabile e ogni barra del gruppo a una categoria della seconda. Funzionano meglio quando la seconda variabile ha non più di tre categorie; altrimenti diventano troppo affollati e meno utili.
Come per il grafico a barre, possiamo crearne uno raggruppato con matplotlib. Tuttavia, Seaborn offre una funzionalità più comoda con la sua funzione seaborn.barplot(). Vediamo un esempio di grafico a barre raggruppate per la lunghezza del becco dei pinguini in base a specie e sesso.
# Creating a grouped bar chart
sns.barplot(data=penguins, x='species', y='bill_length_mm', hue='sex')
plt.title('Penguin bill length by species and sex')
plt.show()
La seconda variabile categorica è introdotta tramite il parametro hue. Altri parametri opzionali permettono di cambiare orientamento, larghezza e colore delle barre, l'ordine delle categorie, lo stimatore statistico, ecc.
Per approfondire il plotting con Seaborn, considera questo corso: Intermediate Data Visualization with Seaborn.
Grafico ad area impilata
Un grafico ad area impilata estende un comune grafico ad area (un grafico a linee con l'area sotto la linea colorata o riempita con un pattern) con più aree, ciascuna corrispondente a una variabile, impilate una sull'altra. È utile quando dobbiamo seguire sia l'andamento complessivo di un insieme di variabili sia il contributo individuale di ciascuna. Come i grafici a linee, in genere riflettono il cambiamento nel tempo.
È importante ricordare la principale limitazione dei grafici ad area impilata: aiutano soprattutto a cogliere il trend generale, non i valori esatti delle aree impilate.
Per costruire un grafico ad area impilata di base in matplotlib, usiamo la funzione matplotlib.pyplot.stackplot(), come sotto:
# Data preparation
flights_grouped = flights.groupby(['year', 'month']).mean().reset_index()
flights_49_50 = pd.DataFrame(list(zip(flights_grouped.loc[:11, 'month'].tolist(), flights_grouped.loc[:11, 'passengers'].tolist(), flights_grouped.loc[12:23, 'passengers'].tolist())), columns=['month', '1949', '1950'])
# Creating a stacked area chart
plt.stackplot(flights_49_50['month'], flights_49_50['1949'], flights_49_50['1950'], labels=['1949', '1950'])
plt.title('Number of passengers in 1949 and 1950 by month')
plt.legend()
plt.show()
Alcune proprietà personalizzabili sono i colori e la trasparenza delle aree, i pattern di riempimento, lo spessore, lo stile, il colore e la trasparenza delle linee, ecc.
Box plot multipli
Nella sezione sui tipi comuni abbiamo definito il box plot come un tipo che mostra un set di cinque statistiche descrittive. Talvolta potremmo volerle mostrare e confrontare separatamente per ciascuna categoria di una variabile categorica. In tal caso, tracciamo più box nella stessa area, cosa che possiamo fare facilmente con la funzione seaborn.boxplot(), come segue:
# Creating multiple box plots
sns.boxplot(data=penguins, x='bill_length_mm', y='species')
plt.title('Penguin bill length distribution by species')
plt.show()
È possibile cambiare l'ordine dei box, l'orientamento, colore, trasparenza, larghezza, le proprietà dei vari elementi, aggiungere un'altra variabile categorica nell'area del grafico, ecc.
Grafico a violino
Un grafico a violino è simile a un box plot e mostra le stesse statistiche generali, ma in più visualizza la forma della distribuzione dei dati. Come per i box plot, possiamo creare un singolo violino o, più spesso, più violini, ognuno per una categoria di una variabile categorica.
Seaborn offre più possibilità per creare e personalizzare i grafici a violino rispetto a matplotlib. Per costruirne uno di base in seaborn, usiamo la funzione seaborn.violinplot(), come sotto:
# Creating a violin plot
sns.violinplot(data=penguins, x='bill_length_mm', y='species')
plt.title('Penguin bill length distribution by species')
plt.show()
Possiamo modificare l'ordine e l'orientamento dei violini, colore, trasparenza, larghezza, le proprietà dei vari elementi, estendere la distribuzione oltre i valori estremi, aggiungere un'altra variabile categorica all'area del grafico, scegliere come rappresentare i punti dati all'interno del violino, ecc.
Heatmap
Una heatmap è una visualizzazione in forma di tabella in cui ogni punto numerico è rappresentato in base a una scala di colori e secondo l'ampiezza del suo valore all'interno del dataset. L'idea è mettere in evidenza potenziali hot e cold spot nei dati che meritano attenzione.
Spesso i dati richiedono del preprocessing prima di creare una heatmap, di solito pulizia e normalizzazione.
Il codice seguente mostra come creare una heatmap di base (dopo il necessario preprocessing) usando la funzione seaborn.heatmap():
# Data preparation
from sklearn import preprocessing
car_crashes_cleaned = car_crashes.drop(labels='abbrev', axis=1).iloc[0:10]
min_max_scaler = preprocessing.MinMaxScaler()
car_crashes_normalized = pd.DataFrame(min_max_scaler.fit_transform(car_crashes_cleaned.values), columns=car_crashes_cleaned.columns)
# Creating a heatmap
sns.heatmap(car_crashes_normalized, annot=True)
plt.title('Car crash heatmap for the first 10 car crashes')
plt.show()
Alcune possibili modifiche includono la scelta della colormap, la definizione di valori di ancoraggio, la formattazione delle annotazioni, la personalizzazione delle linee di separazione, l'applicazione di una maschera, ecc.
Per una guida più dettagliata alle heatmap, inclusi colormap e annotazioni personalizzate, leggi Seaborn Heatmaps: A Guide to Data Visualization.
Tipi non convenzionali di grafici dei dati in Python
Infine, vediamo alcuni tipi di visualizzazioni raramente usati o poco conosciuti. Molti hanno almeno un analogo tra i grafici più popolari. Tuttavia, in alcuni casi specifici, queste visualizzazioni non convenzionali possono svolgere un lavoro più efficace dei grafici comuni.
Grafico a stelo (stem)
Un grafico a stelo è, in pratica, un altro modo di rappresentare un grafico a barre: invece di barre piene, è composto da linee sottili con (opzionali) marker in cima a ciascuna. Pur sembrando una variante ridondante del grafico a barre, è un'alternativa migliore quando si visualizzano molte categorie. Il vantaggio è un migliore rapporto data-ink e quindi una maggiore leggibilità.
Per creare un grafico a stelo di base in matplotlib, usiamo la funzione matplotlib.pyplot.stem(), come segue:
# Data preparation
fmri_grouped = fmri.groupby('subject')[['subject', 'signal']].max()
# Creating a stem plot
plt.stem(fmri_grouped['subject'], fmri_grouped['signal'])
plt.title('FMRI maximum signal by subject')
plt.show()
Possiamo intervenire sui parametri opzionali per cambiare l'orientamento e personalizzare proprietà di steli, linea di base e marker.
Strip e swarm plot
Questi due tipi, molto simili, possono essere considerati l'implementazione di un grafico a dispersione per una variabile categorica: entrambi mostrano l'interno della distribuzione dei dati, incluse dimensione del campione e posizione dei singoli punti, ma non le statistiche descrittive. La differenza principale è che nello strip plot i punti possono sovrapporsi, mentre nello swarm plot no: in quest'ultimo i punti si dispongono lungo l'asse categoriale.
Ricorda che sia gli strip sia gli swarm plot sono utili solo per dataset relativamente piccoli.
Ecco come creare uno strip plot con la funzione seaborn.stripplot():
# Creating a strip plot
sns.stripplot(data=penguins, x='bill_length_mm', y='species')
plt.title('Penguin bill length distribution by species')
plt.show()
Ora creiamo uno swarm plot con la funzione seaborn.swarmplot() sugli stessi dati e osserviamo la differenza:
# Creating a swarm plot
sns.swarmplot(data=penguins, x='bill_length_mm', y='species')
plt.title('Penguin bill length distribution by species')
plt.show()
Le funzioni seaborn.stripplot() e seaborn.swarmplot() hanno una sintassi molto simile. Proprietà personalizzabili in entrambe sono ordine e orientamento del grafico e caratteristiche dei marker, come stile, dimensione, colore, trasparenza, ecc. Regolare la trasparenza aiuta a mitigare la sovrapposizione dei punti in uno strip plot.
Treemap
Un treemap è un grafico che visualizza i valori numerici dei dati categorici per categoria come un insieme di rettangoli all'interno di una cornice rettangolare, con l'area di ciascun rettangolo proporzionale al valore della categoria corrispondente. Per scopo, i treemap sono identici ai grafici a barre e a torta. Come i grafici a torta, sono pensati soprattutto per rappresentare le categorie che costituiscono un intero. Possono risultare efficaci e d'impatto quando ci sono fino a dieci categorie con differenze di valore ben distinguibili.
Gli svantaggi dei treemap sono molto simili a quelli dei grafici a torta:
- Le aree sono più difficili da interpretare rispetto alle lunghezze e possono essere fuorvianti.
- Sono meno efficaci con più di dieci categorie.
- Non possono mostrare più di un set di dati categorici. In altre parole, non possono essere raggruppati, a differenza dei grafici a barre.
- Non rivelano facilmente i valori reali.
- Non sono informativi quando le categorie hanno differenze di valore ridotte.
Tenendo a mente questi punti, usiamo i treemap con parsimonia e solo quando sono davvero la scelta migliore.
Per costruire un treemap in Python, dobbiamo prima installare e importare la libreria squarify: pip install squarify, poi import squarify. Il codice seguente crea un treemap di base:
import squarify
# Data preparation
diamonds_grouped = diamonds[['cut', 'price']].groupby('cut').mean().reset_index()
# Creating a treemap
squarify.plot(sizes=diamonds_grouped['price'], label=diamonds_grouped['cut'])
plt.title('Average diamond price by cut')
plt.show()
Possiamo personalizzare colori e trasparenza dei rettangoli, riempirli con pattern, regolare le proprietà dei bordi, aggiungere un piccolo spazio tra i rettangoli e affinare le proprietà del testo delle etichette.
Un altro approccio per creare un treemap in Python è usare la libreria plotly. Puoi saperne di più nel tutorial What is Data Visualization? A Guide for Data Scientists.
Word cloud
Una word cloud è una visualizzazione di testi in cui la dimensione del font di ogni parola corrisponde alla frequenza della sua apparizione in un testo di input. Le word cloud aiutano a individuare le parole più importanti in un testo.
Sebbene siano sempre accattivanti e intuitive per qualsiasi pubblico, bisogna essere consapevoli di alcune limitazioni intrinseche di questo tipo di grafico:
- La creazione richiede spesso una preparazione dei dati dispendiosa in termini di tempo.
- Come la maggior parte degli strumenti di text mining, le word cloud mancano di contesto e possono prestarsi a interpretazioni errate. Per esempio, non colgono sarcasmo, negazione o significati non letterali.
- Non consentono un ranking chiaro delle parole: è facile distinguere la parola più frequente, la seconda, la terza, forse la quarta; poi diventa difficile.
- Non rivelano valori precisi delle frequenze.
- Creano un'illusione ottica per cui le parole più lunghe sembrano più grandi di quelle più corte con la stessa frequenza.
- Avere molte parole verticali o applicare una maschera riduce la leggibilità.
Un'applicazione interessante e meno nota è costruire word cloud basate non sulla frequenza, ma su un altro attributo assegnato a ciascuna parola. Ad esempio, possiamo creare un dizionario di paesi, assegnare a ciascuno il valore della popolazione e visualizzare questi dati.
Per creare una word cloud in Python, serve la libreria specializzata wordcloud. Prima va installata (pip install wordcloud), poi si importano la classe WordCloud e le stopwords: from wordcloud import WordCloud, STOPWORDS. Il codice seguente genera una word cloud di base:
from wordcloud import WordCloud, STOPWORDS
text = 'cat cat cat cat cat cat dog dog dog dog dog panda panda panda panda koala koala koala rabbit rabbit fox'
# Creating a word cloud
wordcloud = WordCloud().generate(text)
plt.imshow(wordcloud)
plt.title('Words by their frequency in the text')
plt.axis('off')
plt.show()
È possibile regolare le dimensioni della word cloud, cambiare il colore di sfondo, assegnare una colormap per le parole, preferire parole orizzontali rispetto alle verticali, limitare il numero massimo di parole visualizzate, aggiornare la lista di stopword, limitare le dimensioni dei font, considerare le collocazioni, garantire la riproducibilità del grafico, ecc.
Se vuoi saperne di più sulle word cloud in Python, ecco una lettura utile: Generating WordClouds in Python Tutorial.
Argomenti
