Come visualizzare i dati di un file CSV in grafici e diagrammi con pandas

La visualizzazione dei dati di un file CSV utilizzando Pandas è una tecnica fondamentale per svolgere analisi dei dati e prendere decisioni in modo rapido ed efficiente. Rappresentando i dati visivamente, è possibile individuare facilmente tendenze e modelli, motivo per cui questa tecnica è ampiamente utilizzata nell’analisi aziendale, nella ricerca scientifica e nei progetti accademici. In questo articolo, cominceremo con le operazioni di base per leggere i dati CSV con Pandas, per poi passare all’uso di librerie come Matplotlib e Seaborn, che permettono di visualizzare i dati in modo interessante e comprensibile. Approfitta di queste informazioni per migliorare le tue competenze nell’analisi dei dati con Python.

Indice

Caricamento del file CSV e verifica dei dati

Utilizzando Pandas, è possibile iniziare un’analisi dei dati in modo efficiente. Segui questi passaggi per caricare un file CSV e verificare un riassunto dei dati.

Caricamento del file CSV

Per caricare un file CSV, utilizziamo la funzione read_csv() di Pandas. Ad esempio, per caricare un file chiamato data.csv, usa il seguente codice:

import pandas as pd

# Caricare il file CSV
df = pd.read_csv('data.csv')

# Visualizzare le prime righe del DataFrame
print(df.head())

Questo codice carica i dati CSV in un DataFrame di Pandas e mostra le prime 5 righe dei dati.

Verifica dei dati

Per comprendere la struttura dei dati e ottenere alcune informazioni statistiche di base, puoi utilizzare i seguenti metodi.

Verifica delle dimensioni del DataFrame

   print(df.shape)
   # Output: (numero di righe, numero di colonne)

   print(df['colonna'].unique())  # Visualizzare i valori unici della colonna
   print(df['colonna'].value_counts())  # Conteggio delle occorrenze di ogni valore

Utilizzando questi metodi, puoi comprendere rapidamente il contenuto del tuo dataset e prepararti per il prossimo passo di visualizzazione.

Creazione di grafici di base con Matplotlib

Combinando Pandas e Matplotlib, puoi visualizzare facilmente i dati CSV. Qui ti mostrerò come creare grafici di base.

Installazione di Matplotlib

Per prima cosa, importa Matplotlib. Utilizzando il modulo pyplot, puoi creare rapidamente grafici.

import matplotlib.pyplot as plt

# Usando df già caricato
df = pd.read_csv('data.csv')

Creazione di un grafico a linee

Un grafico a linee è utile per visualizzare dati temporali o continui.

# Tracciare i dati "data" sull'asse delle ascisse e "sales" sull'asse delle ordinate
plt.plot(df['data'], df['sales'])
plt.title('Andamento delle vendite')
plt.xlabel('Data')
plt.ylabel('Vendite')
plt.xticks(rotation=45)  # Ruotare le etichette sull'asse delle ascisse
plt.show()

Creazione di un grafico a barre

Per visualizzare i valori per categoria, è più adatto un grafico a barre.

# Raggruppa le vendite per categoria e crea un grafico a barre
category_sales = df.groupby('categoria')['sales'].sum()
category_sales.plot(kind='bar', color='skyblue')
plt.title('Vendite per categoria')
plt.xlabel('Categoria')
plt.ylabel('Vendite')
plt.show()

Creazione di un grafico a dispersione

Un grafico a dispersione è utile per visualizzare la correlazione tra due variabili.

# Tracciare la relazione tra prezzo e vendite
plt.scatter(df['prezzo'], df['sales'], alpha=0.7, color='green')
plt.title('Correlazione tra prezzo e vendite')
plt.xlabel('Prezzo')
plt.ylabel('Vendite')
plt.show()

Creazione di un istogramma

Per esaminare la distribuzione dei dati, un istogramma è una scelta efficace.

# Tracciare la distribuzione delle vendite
df['sales'].plot(kind='hist', bins=20, color='orange', edgecolor='black')
plt.title('Distribuzione delle vendite')
plt.xlabel('Vendite')
plt.ylabel('Frequenza')
plt.show()

Questi grafici ti aiuteranno a comprendere visivamente le caratteristiche dei tuoi dati. Il prossimo passo sarà imparare a usare Seaborn per visualizzazioni più avanzate.

Uso avanzato dei grafici con Seaborn

Seaborn è una libreria che lavora bene con Pandas e Matplotlib, permettendo di creare grafici di alta qualità in modo semplice. Qui vedremo come utilizzare Seaborn per visualizzazioni più sofisticate.

Installazione di Seaborn

Prima di tutto, importa Seaborn e configura lo stile.

import seaborn as sns

# Impostare lo stile
sns.set(style="whitegrid")  
df = pd.read_csv('data.csv')  # Carica i dati

Visualizzazione dei dati per categoria: Boxplot

Un boxplot è utile per visualizzare la distribuzione dei dati per ogni categoria.

# Visualizza la distribuzione delle vendite per categoria
sns.boxplot(x='categoria', y='sales', data=df, palette='pastel')
plt.title('Distribuzione delle vendite per categoria')
plt.xlabel('Categoria')
plt.ylabel('Vendite')
plt.show()

Visualizzazione della correlazione: Scatterplot con retta di regressione

Seaborn offre regplot, che consente di aggiungere una retta di regressione a un grafico a dispersione.

# Tracciare la correlazione tra prezzo e vendite
sns.regplot(x='prezzo', y='sales', data=df, scatter_kws={'alpha':0.6}, line_kws={'color':'red'})
plt.title('Correlazione tra prezzo e vendite')
plt.xlabel('Prezzo')
plt.ylabel('Vendite')
plt.show()

Visualizzazione della distribuzione dei dati: Heatmap

Per visualizzare una matrice di correlazione, usa una heatmap.

# Calcolare la matrice di correlazione
correlation_matrix = df.corr()

# Creare una heatmap
sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', fmt='.2f')
plt.title('Heatmap della matrice di correlazione')
plt.show()

Relazione tra categorie e valori numerici: Violin plot

Un violin plot è utile per rappresentare in modo fluido la distribuzione dei dati per ogni categoria.

# Tracciare la distribuzione delle vendite per categoria con violin plot
sns.violinplot(x='categoria', y='sales', data=df, palette='muted', inner='quartile')
plt.title('Distribuzione delle vendite per categoria (Violin Plot)')
plt.xlabel('Categoria')
plt.ylabel('Vendite')
plt.show()

Enfatizzare le tendenze dei dati: Count plot

Per visualizzare la frequenza di occorrenza di ciascuna categoria, usa un count plot.

# Tracciare la frequenza delle categorie di prodotto
sns.countplot(x='categoria', data=df, palette='viridis')
plt.title('Frequenza delle categorie di prodotto')
plt.xlabel('Categoria')
plt.ylabel('Frequenza')
plt.show()

Utilizzando i grafici avanzati di Seaborn, puoi ottenere una comprensione più profonda dei dati. Ora, esploreremo come visualizzare i dati filtrando colonne specifiche.

Visualizzazione dei dati filtrati per colonna

Nell’analisi dei dati, è spesso necessario estrarre i dati da colonne o condizioni specifiche. Qui mostriamo come filtrare i dati con Pandas e creare grafici appropriati.

Filtrare le colonne specifiche e creare un grafico

Se vuoi visualizzare solo i dati di una colonna, specifica il nome della colonna nel DataFrame.

# Visualizzare solo i dati delle vendite in un istogramma
df['sales'].plot(kind='hist', bins=15, color='skyblue', edgecolor='black')
plt.title('Distribuzione delle vendite')
plt.xlabel('Vendite')
plt.ylabel('Frequenza')
plt.show()

Creare grafici combinati con più colonne

Per visualizzare la correlazione tra più colonne, puoi combinare più colonne in un grafico di dispersione.

# Visualizzare la relazione tra vendite e prezzo in un grafico a dispersione
plt.scatter(df['prezzo'], df['sales'], color='green', alpha=0.6)
plt.title('Correlazione tra prezzo e vendite')
plt.xlabel('Prezzo')
plt.ylabel('Vendite')
plt.show()

Visualizzazione dei dati filtrati in base a una condizione

Puoi anche filtrare i dati in base a condizioni specifiche per analizzare gruppi di dati specifici.

# Filtrare i dati con vendite maggiori o uguali a 1000 e visualizzarli
high_sales = df[df['sales'] >= 1000]
plt.plot(high_sales['data'], high_sales['sales'], marker='o', color='orange')
plt.title('Vendite superiori a 1000 (per data)')
plt.xlabel('Data')
plt.ylabel('Vendite')
plt.xticks(rotation=45)
plt.show()

Raggruppare i dati per categoria e visualizzare i risultati

Puoi anche raggruppare i dati per categoria o altri attributi e visualizzare i risultati in un grafico.

# Calcolare la media delle vendite per categoria
category_avg_sales = df.groupby('categoria')['sales'].mean()

# Visualizzare con un grafico a barre
category_avg_sales.plot(kind='bar', color='coral')
plt.title('Vendite medie per categoria')
plt.xlabel('Categoria')
plt.ylabel('Vendite medie')
plt.show()

Filtrare i dati con più condizioni

Filtrare i dati in base a più condizioni ti permette di restringere ulteriormente l’analisi.

# Filtrare i dati con vendite maggiori o uguali a 1000 e prezzo inferiore a 500
filtered_data = df[(df['sales'] >= 1000) & (df['prezzo'] < 500)]

# Visualizzare con un grafico a dispersione
plt.scatter(filtered_data['prezzo'], filtered_data['sales'], color='purple', alpha=0.7)
plt.title('Vendite >= 1000 e prezzo < 500')
plt.xlabel('Prezzo')
plt.ylabel('Vendite')
plt.show()

Questo ti consente di focalizzarti su particolari gruppi di dati per individuare pattern importanti. Il prossimo passo è visualizzare i dati temporali.

Metodi di visualizzazione dei dati temporali

I dati temporali sono essenziali per analizzare tendenze e stagionalità. In questa sezione vedremo come rappresentare graficamente i dati temporali con Pandas e librerie di visualizzazione.

Preparazione dei dati temporali

Per lavorare con dati temporali in Pandas, convertili in formato datetime per poter sfruttare le funzionalità di Pandas dedicate al tempo.

# Convertire la colonna data in formato datetime
df['data'] = pd.to_datetime(df['data'])

# Ordinare il DataFrame per data
df = df.sort_values('data')

# Impostare la data come indice (opzionale)
df.set_index('data', inplace=True)

Visualizzazione di un singolo dato temporale

Puoi visualizzare i dati temporali in un grafico a linee.

# Tracciare i dati delle vendite nel tempo
df['sales'].plot(figsize=(10, 5), color='blue', linewidth=2)
plt.title('Andamento delle vendite nel tempo')
plt.xlabel('Data')
plt.ylabel('Vendite')
plt.grid(True)
plt.show()

Confronto tra più dati temporali

Puoi sovrapporre più serie temporali nello stesso grafico per un confronto.

# Tracciare le vendite e i profitti nel tempo
df[['sales', 'profit']].plot(figsize=(10, 5), linewidth=2)
plt.title('Vendite e profitti nel tempo')
plt.xlabel('Data')
plt.ylabel('Importo')
plt.legend(['Vendite', 'Profitti'])
plt.grid(True)
plt.show()

Analisi di stagionalità e tendenze

I dati temporali possono contenere stagionalità o tendenze, che puoi separare e analizzare.

from statsmodels.tsa.seasonal import seasonal_decompose

# Decomposizione della stagionalità delle vendite
decomposition = seasonal_decompose(df['sales'], model='additive', period=12)

# Tracciare i singoli componenti (tendenza, stagionalità, residui)
decomposition.plot()
plt.show()

Visualizzazione di un intervallo di tempo specifico

Puoi filtrare i dati per un periodo specifico e tracciarli.

# Filtrare i dati per l'anno 2023
df_2023 = df['2023']
df_2023['sales'].plot(figsize=(10, 5), color='green', linewidth=2)
plt.title('Vendite nel 2023')
plt.xlabel('Data')
plt.ylabel('Vendite')
plt.grid(True)
plt.show()

Personalizzazione del grafico

Puoi aggiungere marker e annotazioni per evidenziare i punti chiave nei grafici temporali.

# Aggiungere marker sui dati delle vendite
plt.plot(df.index, df['sales'], marker='o', color='red', linewidth=2)
plt.title('Andamento delle vendite (con marker)')
plt.xlabel('Data')
plt.ylabel('Vendite')
plt.grid(True)

# Aggiungere un'annotazione per il

 picco delle vendite
peak_date = df['sales'].idxmax()  # Data del picco delle vendite
peak_value = df['sales'].max()
plt.annotate(f'Picco vendite: {peak_value}', xy=(peak_date, peak_value), xytext=(peak_date, peak_value + 100),
             arrowprops=dict(facecolor='black', arrowstyle='->'), fontsize=10)

plt.show()

Grafico temporale interattivo

Per creare grafici interattivi, puoi usare librerie come Plotly.

import plotly.express as px

# Grafico interattivo delle vendite nel tempo
fig = px.line(df.reset_index(), x='data', y='sales', title='Vendite nel tempo')
fig.show()

Utilizzando questi metodi, puoi visualizzare efficacemente i dati temporali e analizzare tendenze e stagionalità. Ora vedremo come tracciare più grafici contemporaneamente.

Come tracciare più grafici contemporaneamente

Durante l'analisi dei dati, è utile visualizzare più grafici contemporaneamente per confrontare i dati da diverse prospettive. Qui esploreremo come utilizzare Matplotlib e Seaborn per tracciare più grafici in parallelo.

Tracciare più grafici con Matplotlib

Matplotlib ti permette di tracciare più grafici in una singola figura usando subplot.

import matplotlib.pyplot as plt

# Creare una figura con 2 righe e 2 colonne di grafici
fig, axes = plt.subplots(2, 2, figsize=(12, 8))

# Grafico 1: Vendite nel tempo
axes[0, 0].plot(df.index, df['sales'], color='blue', linewidth=2)
axes[0, 0].set_title('Andamento delle vendite')
axes[0, 0].set_xlabel('Data')
axes[0, 0].set_ylabel('Vendite')

# Grafico 2: Profitti nel tempo
axes[0, 1].plot(df.index, df['profit'], color='green', linewidth=2)
axes[0, 1].set_title('Andamento dei profitti')
axes[0, 1].set_xlabel('Data')
axes[0, 1].set_ylabel('Profitti')

# Grafico 3: Distribuzione delle vendite (istogramma)
axes[1, 0].hist(df['sales'], bins=15, color='orange', edgecolor='black')
axes[1, 0].set_title('Distribuzione delle vendite')
axes[1, 0].set_xlabel('Vendite')
axes[1, 0].set_ylabel('Frequenza')

# Grafico 4: Correlazione tra prezzo e vendite (grafico a dispersione)
axes[1, 1].scatter(df['prezzo'], df['sales'], color='purple', alpha=0.7)
axes[1, 1].set_title('Correlazione tra prezzo e vendite')
axes[1, 1].set_xlabel('Prezzo')
axes[1, 1].set_ylabel('Vendite')

# Ottimizzare la disposizione dei grafici
plt.tight_layout()
plt.show()

Tracciare più grafici con Seaborn

Seaborn offre FacetGrid, che consente di creare più grafici suddivisi per categoria.

import seaborn as sns

# Tracciare vendite per categoria
g = sns.FacetGrid(df, col="categoria", col_wrap=3, height=4)
g.map(sns.lineplot, "data", "sales")
g.set_titles("{col_name}")
g.set_axis_labels("Data", "Vendite")
plt.show()

Sovrapporre grafici diversi in un'unica figura

Puoi anche sovrapporre diversi tipi di grafici per confrontare i dati.

fig, ax1 = plt.subplots(figsize=(10, 6))

# Tracciare le vendite come grafico a linee
ax1.plot(df.index, df['sales'], color='blue', label='Vendite')
ax1.set_xlabel('Data')
ax1.set_ylabel('Vendite', color='blue')
ax1.tick_params(axis='y', labelcolor='blue')

# Sovrapporre i profitti come grafico a barre
ax2 = ax1.twinx()  # Creare un secondo asse y
ax2.bar(df.index, df['profit'], color='orange', alpha=0.6, label='Profitti')
ax2.set_ylabel('Profitti', color='orange')
ax2.tick_params(axis='y', labelcolor='orange')

# Aggiungere il titolo e la legenda
fig.suptitle('Vendite e profitti a confronto')
fig.legend(loc='upper left', bbox_to_anchor=(0.1, 0.9))
plt.show()

Salvare i grafici separatamente

Per salvare ciascun grafico separatamente, puoi chiamare savefig() per ogni grafico.

# Salvare l'andamento delle vendite nel tempo
df['sales'].plot()
plt.title('Andamento delle vendite')
plt.savefig('sales_trend.png')
plt.clf()  # Pulisce la figura corrente

# Salvare la distribuzione delle vendite
df['sales'].plot(kind='hist', bins=15, color='orange', edgecolor='black')
plt.title('Distribuzione delle vendite')
plt.savefig('sales_distribution.png')
plt.clf()

Creare grafici interattivi

Utilizzando Plotly, puoi creare grafici interattivi e salvarli come file HTML.

import plotly.express as px

# Creare un grafico interattivo delle vendite
fig = px.line(df.reset_index(), x='data', y='sales', title='Vendite nel tempo')

# Salvare come file HTML
fig.write_html('interactive_sales_plot.html')

Verifica dei grafici salvati

Per visualizzare i grafici salvati, puoi aprirli direttamente nel tuo ambiente Python.

from PIL import Image

# Aprire l'immagine salvata
img = Image.open('sales_trend.png')
img.show()

Questi metodi ti permetteranno di salvare i grafici per la condivisione e la presentazione. Adesso, passiamo alla sintesi dell'articolo.

Sintesi

In questo articolo, abbiamo esplorato come visualizzare i dati CSV con la libreria Pandas in Python. Abbiamo coperto la lettura dei dati, la creazione di grafici di base, la visualizzazione di dati temporali, la creazione di più grafici e la personalizzazione dei grafici. Abbiamo anche esplorato come salvare i grafici creati per analisi future.

La visualizzazione dei dati è una competenza fondamentale per comunicare chiaramente le informazioni. Combinando Pandas, Matplotlib e Seaborn, puoi facilmente scoprire tendenze e modelli nei dati. Inoltre, puoi condividere i risultati utilizzando grafici interattivi o salvando i grafici come immagini.

Utilizza questi metodi per migliorare l'efficienza dell'analisi dei dati e delle presentazioni.