MENU
  1. ホーム
  2. Python
  3. Guida Completa alla Creazione di Grafici in Tempo Reale con Matplotlib

Guida Completa alla Creazione di Grafici in Tempo Reale con Matplotlib

Python

Nel campo moderno dell’analisi dei dati, la visualizzazione in tempo reale dei dati sta diventando sempre più importante. Matplotlib è una delle librerie di visualizzazione dati più utilizzate in Python e, sfruttando le sue funzionalità, è possibile creare facilmente grafici in tempo reale. In questa guida, esploreremo passo dopo passo come realizzare grafici in tempo reale con Matplotlib, dai concetti di base alle applicazioni avanzate, utilizzando esempi di codice concreti.

Indice

Nozioni di base sui grafici in tempo reale

I grafici in tempo reale sono una tecnica per aggiornare dinamicamente i grafici in base ai nuovi dati. Questo è fondamentale in molte applicazioni, come il monitoraggio dei dati dei sensori o dei mercati finanziari. Il concetto di base consiste nel raccogliere dati e aggiornare periodicamente il grafico. Per farlo, sfrutteremo la funzione di animazione e i cicli di aggiornamento di Matplotlib. Iniziamo comprendendo il flusso generale e gli elementi necessari per la creazione di grafici in tempo reale.

Installazione e configurazione di Matplotlib

Per creare grafici in tempo reale, è innanzitutto necessario installare Matplotlib e configurarlo correttamente. Segui i passaggi seguenti per procedere.

Installazione di Matplotlib

Poiché Matplotlib non è incluso nella libreria standard di Python, è necessario installarlo utilizzando pip. Utilizza il seguente comando per installare la libreria.

pip install matplotlib

Installazione di altre librerie necessarie

Per implementare grafici in tempo reale, spesso sono necessarie altre librerie oltre a Matplotlib. Assicurati di installarle con pip.

pip install numpy
pip install pandas

Configurazione di base

Dopo l’installazione, procedi con la configurazione di base. Importa le librerie nello script Python o nel Jupyter Notebook.

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

Verifica del funzionamento

Per verificare che l’installazione e la configurazione siano corrette, prova a creare un semplice grafico. Esegui il seguente codice e controlla che Matplotlib funzioni correttamente.

import matplotlib.pyplot as plt

plt.plot([1, 2, 3, 4], [1, 4, 9, 16])
plt.xlabel('Etichetta asse x')
plt.ylabel('Etichetta asse y')
plt.title('Grafico di test')
plt.show()

Se il grafico viene visualizzato correttamente, l’installazione e la configurazione sono completate. Nel prossimo passaggio, esamineremo in dettaglio i metodi per acquisire dati in tempo reale.

Metodi di acquisizione dei dati

Per realizzare grafici in tempo reale, è fondamentale comprendere come acquisire dati in tempo reale. Esistono diversi metodi per ottenere dati, ma qui ne presenteremo alcuni dei più comuni.

Acquisizione di dati da sensori

Per ottenere dati in tempo reale da un sensore, è necessaria una libreria per comunicare con l’hardware. Ad esempio, per raccogliere dati da sensori utilizzando Arduino o Raspberry Pi, puoi utilizzare librerie Python compatibili (come pyserial) per leggere i dati.

import serial

ser = serial.Serial('COM3', 9600)  # Specifica la porta e il baud rate
while True:
    data = ser.readline().decode('utf-8').strip()
    print(data)

Acquisizione di dati da API

Un altro metodo consiste nell’utilizzare API per ottenere dati in tempo reale. Ad esempio, puoi utilizzare API pubbliche su Internet per ottenere dati come quotazioni di borsa o informazioni meteorologiche. Di seguito è riportato un esempio di come utilizzare la libreria requests per ottenere dati da un’API.

import requests
import time

url = 'https://api.example.com/data'
while True:
    response = requests.get(url)
    data = response.json()
    print(data)
    time.sleep(5)  # Ottieni i dati ogni 5 secondi

Acquisizione di dati da database

Se desideri acquisire dati in tempo reale da un database, puoi utilizzare una libreria client per database. Ecco un esempio di come ottenere dati periodicamente da un database SQLite.

Esempio di Applicazione: Grafico in Tempo Reale dei Prezzi delle Azioni

Il grafico in tempo reale dei prezzi delle azioni è molto utile per trader e investitori. In questa sezione, mostreremo come ottenere e visualizzare i dati in tempo reale dei prezzi delle azioni utilizzando Yahoo Finance API.

Configurazione dell’API di Yahoo Finance

Prima di tutto, installiamo la libreria yfinance. Con questa libreria, è possibile ottenere facilmente i dati dei prezzi delle azioni da Yahoo Finance.

pip install yfinance

Ottenimento e Grafico dei Dati in Tempo Reale

Nel codice seguente, utilizziamo yfinance per ottenere i dati in tempo reale di un’azione specifica e li visualizziamo con Matplotlib.

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import yfinance as yf
import datetime

# Prepara una lista per i dati
x_data, y_data = [], []

fig, ax = plt.subplots()
line, = ax.plot([], [], 'g-')

# Funzione di inizializzazione
def init():
    ax.set_xlim(0, 100)
    ax.set_ylim(0, 500)  # Imposta l'intervallo dei prezzi
    return line,

# Funzione di aggiornamento
def update(frame):
    current_time = datetime.datetime.now().strftime('%H:%M:%S')
    x_data.append(current_time)

    # Ottieni i dati dei prezzi da Yahoo Finance API
    stock = yf.Ticker('AAPL')
    data = stock.history(period='1m')
    y_data.append(data['Close'][-1])

    # Rimuovi i dati più vecchi se si supera una certa quantità
    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(range(len(x_data)), y_data)

    ax.set_xticks(range(0, len(x_data), 10))
    ax.set_xticklabels(x_data[::10], rotation=45, ha='right')

    return line,

ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 100), init_func=init, blit=True, interval=60000)
plt.xlabel('Tempo')
plt.ylabel('Prezzo delle Azioni ($)')
plt.title('Grafico in Tempo Reale dei Prezzi - AAPL')
plt.show()

In questo codice, i dati dei prezzi delle azioni di Apple (AAPL) vengono aggiornati ogni minuto e visualizzati in tempo reale. La funzione FuncAnimation richiama la funzione update ogni minuto per aggiornare il grafico.

Salvataggio dei Dati e Log

Oltre a visualizzare i prezzi in tempo reale, è importante salvare i dati per analisi future. Il codice seguente mostra come salvare i dati in un file CSV durante la visualizzazione in tempo reale.

import csv

# Apri un file CSV
with open('stock_data.csv', mode='w', newline='') as file:
    writer = csv.writer(file)
    writer.writerow(['Tempo', 'Prezzo'])

    def update(frame):
        current_time = datetime.datetime.now().strftime('%H:%M:%S')
        x_data.append(current_time)

        # Ottieni i dati dei prezzi da Yahoo Finance API
        stock = yf.Ticker('AAPL')
        data = stock.history(period='1m')
        price = data['Close'][-1]
        y_data.append(price)

        # Scrivi i dati nel file CSV
        writer.writerow([current_time, price])

        # Rimuovi i dati più vecchi se si supera una certa quantità
        if len(x_data) > 100:
            x_data.pop(0)
            y_data.pop(0)

        line.set_data(range(len(x_data)), y_data)

        ax.set_xticks(range(0, len(x_data), 10))
        ax.set_xticklabels(x_data[::10], rotation=45, ha='right')

        return line,

    ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 100), init_func=init, blit=True, interval=60000)
    plt.xlabel('Tempo')
    plt.ylabel('Prezzo delle Azioni ($)')
    plt.title('Grafico in Tempo Reale dei Prezzi - AAPL')
    plt.show()

In questo codice, i dati visualizzati in tempo reale vengono salvati nel file stock_data.csv, consentendo sia la visualizzazione in tempo reale sia la registrazione persistente dei dati.

Nella prossima sezione, spiegheremo come salvare e condividere i dati.

Salvataggio e Condivisione dei Dati

Oltre a visualizzare i dati in tempo reale, è importante salvare i dati raccolti per analisi o condivisione futura. In questa sezione, spiegheremo come salvare e condividere i dati del grafico in tempo reale.

Metodo di Salvataggio dei Dati

Il formato più comunemente usato per salvare i dati è CSV (Comma Separated Values). In Python, è possibile scrivere facilmente i dati in un file CSV utilizzando il modulo csv.

import csv

# Apri un file CSV
with open('realtime_data.csv', mode='w', newline='') as file:
    writer = csv.writer(file)
    writer.writerow(['Tempo', 'Dati'])

    def update(frame):
        current_time = datetime.datetime.now().strftime('%H:%M:%S')
        x_data.append(current_time)
        value = np.random.random()  # Qui si utilizza un dato casuale
        y_data.append(value)

        # Scrivi i dati nel file CSV
        writer.writerow([current_time, value])

        if len(x_data) > 100:
            x_data.pop(0)
            y_data.pop(0)

        line.set_data(range(len(x_data)), y_data)

        ax.set_xticks(range(0, len(x_data), 10))
        ax.set_xticklabels(x_data[::10], rotation=45, ha='right')

        return line,

    ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 100), init_func=init, blit=True, interval=1000)
    plt.xlabel('Tempo')
    plt.ylabel('Valore dei Dati')
    plt.title('Graf

ico in Tempo Reale dei Dati')
    plt.show()

Questo codice salva i dati acquisiti in tempo reale nel file realtime_data.csv.

Metodo di Condivisione dei Dati

Ci sono diversi modi per condividere i dati salvati. Di seguito vengono presentati alcuni metodi comuni.

Condivisione tramite Email

Allegare il file CSV salvato a un’email è uno dei metodi più semplici per condividerlo.

Uso di Cloud Storage

È possibile utilizzare servizi di cloud storage come Google Drive o Dropbox per condividere i dati con altre persone.

Salvataggio in un Database

Un altro metodo consiste nel salvare i dati raccolti in un database, permettendo l’accesso tramite applicazioni web o strumenti di analisi dei dati. Di seguito è riportato un esempio di salvataggio dei dati in un database SQLite.

import sqlite3

# Apri la connessione al database
conn = sqlite3.connect('realtime_data.db')
cursor = conn.cursor()

# Crea una tabella
cursor.execute('''CREATE TABLE IF NOT EXISTS data (timestamp TEXT, value REAL)''')

def update(frame):
    current_time = datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    value = np.random.random()  # Qui si utilizza un dato casuale
    cursor.execute("INSERT INTO data (timestamp, value) VALUES (?, ?)", (current_time, value))
    conn.commit()

    x_data.append(current_time)
    y_data.append(value)

    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(range(len(x_data)), y_data)

    ax.set_xticks(range(0, len(x_data), 10))
    ax.set_xticklabels(x_data[::10], rotation=45, ha='right')

    return line,

ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 100), init_func=init, blit=True, interval=1000)
plt.xlabel('Tempo')
plt.ylabel('Valore dei Dati')
plt.title('Grafico in Tempo Reale dei Dati')
plt.show()

# Chiudi la connessione al database
conn.close()

Questo codice salva i dati acquisiti in tempo reale in un database SQLite.

Visualizzazione e Analisi dei Dati

Per visualizzare e analizzare i dati salvati successivamente, è possibile utilizzare la libreria Pandas. Di seguito è riportato un esempio di caricamento e visualizzazione di un file CSV salvato.

import pandas as pd

# Carica i dati
df = pd.read_csv('realtime_data.csv')

# Visualizza i dati
plt.figure()
plt.plot(df['Tempo'], df['Dati'])
plt.xlabel('Tempo')
plt.ylabel('Valore dei Dati')
plt.title('Grafico dei Dati Salvati')
plt.xticks(rotation=45, ha='right')
plt.show()

In questo codice, il file CSV salvato viene caricato con Pandas e visualizzato in un grafico, permettendo l’analisi dei dati storici.

Nella prossima sezione, discuteremo i problemi comuni e le loro soluzioni per il grafico in tempo reale.

Risoluzione dei Problemi

Durante il grafico in tempo reale, possono sorgere diversi problemi. Qui elenchiamo i problemi comuni e le loro soluzioni.

Il Grafico non si Aggiorna

Se il grafico in tempo reale non si aggiorna, le cause possibili sono le seguenti.

Causa 1: Configurazione Errata dell’Animazione

Se la configurazione di FuncAnimation non è corretta, il grafico potrebbe non aggiornarsi. Assicurarsi che init_func e update restituiscano correttamente i dati se blit=True è impostato.

ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 100), init_func=init, blit=True, interval=1000)

Causa 2: Ritardo nel Recupero dei Dati

Se il recupero dei dati richiede troppo tempo, l’aggiornamento del grafico potrebbe essere ritardato. Verificare la frequenza di recupero dei dati e il tempo di risposta dell’API per assicurarsi che i dati vengano acquisiti a intervalli adeguati.

def update(frame):
    try:
        # Recupero dei dati
        data = requests.get('https://api.example.com/data').json()
        # Aggiornamento dei dati
    except Exception as e:
        print(f"Errore nel recupero dei dati: {e}")
    return line,

Il Grafico Lampeggia

Se il grafico lampeggia, è possibile migliorare la situazione impostando blit=True per aggiornare solo le parti del grafico necessarie.

ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 100), init_func=init, blit=True, interval=1000)

Problemi di Memoria

In un grafico in tempo reale a lungo termine, l’uso della memoria può aumentare. È importante rimuovere i dati inutilizzati per gestire il consumo di memoria.

def update(frame):
    x_data.append(frame)
    y_data.append(np.random.random())

    # Rimuovi i dati più vecchi
    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(x_data, y_data)
    return line,

Gestione degli Errori di Recupero Dati

Quando si recuperano dati in tempo reale, possono verificarsi errori di rete o malfunzionamenti dell’API. È importante gestire correttamente gli errori e riprovare in caso di problemi.

import time

def update(frame):
    try:
        # Recupero dei dati
        response = requests.get('https://api.example.com/data')
        response.raise_for_status()
        data = response.json()
        y_data.append(data['value'])
    except requests.exceptions.RequestException as e:
        print(f"Errore nel recupero dei dati: {e}")
        time.sleep(5)  # Attendi 5 secondi e riprova
    return line,

Regolazione dell’Intervallo di Visualizzazione

Quando i valori dei dati cambiano dinamicamente, può essere necessario regolare l’intervallo di visualizzazione del grafico.

def update(frame):
    x_data.append(frame)
    y_data.append(np.random.random())

    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(x_data, y_data)
    ax.set_xlim(max(0, frame - 100), frame)  # Regola dinamicamente l'intervallo di visualizzazione
    ax.set_ylim(min(y_data), max(y_data))    # Regola l'intervallo dell'asse Y in base ai dati
    return line,

Smussatura dei Dati

Se i dati in tempo reale sono rumorosi, è possibile migliorare l’effetto visivo applicando una smussatura dei dati. L’esempio seguente utilizza una media mobile per smussare i dati.

def smooth(data, window_size):
    return np.convolve(data, np.ones(window_size)/window_size, mode='valid')

def update(frame):
    x_data.append(frame)
    y_data.append(np.random.random())

    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    smoothed_data = smooth(y_data, window_size=5)
    line.set_data(range(len(smoothed_data)), smoothed_data)

    ax.set_xlim(0, len(smoothed_data))
    ax.set_ylim(min(smoothed_data), max(smoothed_data))
    return line,

Seguendo questi suggerimenti di risoluzione dei problemi, è possibile risolvere i problemi del grafico in tempo reale e migliorare la visualizzazione dei dati.

Nella prossima sezione, riepilogheremo i contenuti trattati.

Conclusione

Il grafico dei dati in tempo reale è una tecnologia importante per diverse applicazioni, come il monitoraggio dei dati dei sensori o il tracciamento dei prezzi delle azioni. Utilizzando Matplotlib, è possibile implementare facilmente un grafico in tempo reale in Python.

In questa guida, abbiamo approfondito i seguenti punti:

  • Concetti di base del grafico in tempo reale
  • Installazione e configurazione di Matplotlib
  • Come ottenere dati da sensori o API
  • Implementazione di un grafico in tempo reale di base usando FuncAnimation
  • Impostazioni avanzate per il grafico animato
  • Esempi pratici con dati di sensori e prezzi delle azioni
  • Metodi di salvataggio e condivisione dei dati
  • Problemi comuni e loro soluzioni

Comprendendo e mettendo in pratica questi passaggi, sarà possibile effettuare una visualizzazione efficace dei dati in tempo reale. La visualizzazione dei dati è uno strumento potente per cogliere rapidamente tendenze o anomalie nei dati. Provatelo nei vostri prossimi progetti o ricerche!

Python
Analisi in Tempo Reale Archiviazione Dati Dati Sensore FuncAnimation Matplotlib Python Recupero Dati API Tracciamento in Tempo Reale Tracciato Azioni Visualizzazione Dati
Indice