MENU
  1. Accueil
  2. Python
  3. Méthode complète pour tracer des données en temps réel avec Matplotlib

Méthode complète pour tracer des données en temps réel avec Matplotlib

Python

Dans l’analyse de données moderne, la visualisation de données en temps réel devient de plus en plus importante. Matplotlib est l’une des bibliothèques de visualisation de données les plus largement utilisées en Python, et en utilisant ses fonctionnalités, il est facile de tracer des données en temps réel. Dans ce guide, nous allons expliquer étape par étape comment réaliser des tracés en temps réel avec Matplotlib, en fournissant des exemples de code concrets, de la base aux applications avancées.

Sommaire

Principes de base des tracés en temps réel

Les tracés en temps réel permettent de mettre à jour dynamiquement les graphiques en fonction des nouvelles données. Cette technique est importante dans de nombreuses applications, telles que la surveillance de données de capteurs ou de données de marché. En termes de base, il est nécessaire de récupérer les données et de mettre à jour le tracé régulièrement. Pour y parvenir, nous utilisons les fonctionnalités d’animation ou de boucle de mise à jour de Matplotlib. Commençons par comprendre le flux global et les éléments nécessaires pour un tracé en temps réel.

Installation et configuration de Matplotlib

Pour effectuer des tracés en temps réel, il est d’abord nécessaire d’installer et de configurer Matplotlib. Suivez les étapes ci-dessous.

Installation de Matplotlib

Matplotlib n’est pas inclus dans la bibliothèque standard de Python, il est donc nécessaire de l’installer en utilisant pip. Utilisez la commande suivante pour installer Matplotlib.

pip install matplotlib

Installation d’autres bibliothèques nécessaires

Pour implémenter des tracés en temps réel, il est souvent nécessaire d’utiliser d’autres bibliothèques en plus de Matplotlib. Installez-les également avec pip.

pip install numpy
pip install pandas

Configuration de base

Une fois l’installation terminée, effectuez les configurations de base. Commencez par importer les bibliothèques dans votre script Python ou dans un Jupyter Notebook.

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

Vérification du fonctionnement

Pour vérifier que l’installation et la configuration ont été effectuées correctement, créons un tracé simple. Exécutez le code suivant pour vous assurer que Matplotlib fonctionne correctement.

import matplotlib.pyplot as plt

plt.plot([1, 2, 3, 4], [1, 4, 9, 16])
plt.xlabel('Étiquette de l'axe x')
plt.ylabel('Étiquette de l'axe y')
plt.title('Tracé de test')
plt.show()

Si le tracé s’affiche correctement, l’installation et la configuration sont terminées. Dans l’étape suivante, nous examinerons comment obtenir des données en temps réel.

Méthodes de récupération de données

Pour réaliser un tracé en temps réel, il est d’abord nécessaire de comprendre comment récupérer des données en temps réel. Il existe plusieurs méthodes pour récupérer des données, et nous allons en présenter quelques-unes ici.

Récupération de données de capteurs

Pour obtenir des données en temps réel à partir d’un capteur, une bibliothèque pour communiquer avec le matériel est nécessaire. Par exemple, pour collecter des données de capteurs à l’aide d’Arduino ou de Raspberry Pi, utilisez une bibliothèque Python appropriée (telle que pyserial) pour récupérer les données.

import serial

ser = serial.Serial('COM3', 9600)  # Spécifiez le port et le débit en bauds
while True:
    data = ser.readline().decode('utf-8').strip()
    print(data)

Récupération de données depuis une API

Une autre méthode consiste à obtenir des données en temps réel à partir d’une API. Par exemple, vous pouvez récupérer des données telles que les prix des actions ou les informations météorologiques à partir d’API publiques sur Internet. Voici comment utiliser la bibliothèque requests pour récupérer des données à partir d’une 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)  # Récupération des données toutes les 5 secondes

Récupération de données depuis une base de données

Pour récupérer des données en temps réel depuis une base de données, utilisez une bibliothèque cliente pour accéder à la base de données. Voici un exemple de récupération de données périodique à partir d’une base de données SQLite.

import sqlite3
import time

conn = sqlite3.connect('example.db')
cursor = conn.cursor()

while True:
    cursor.execute("SELECT * FROM data_table ORDER BY timestamp DESC LIMIT 1")
    data = cursor.fetchone()
    print(data)
    time.sleep(5)  # Récupération des données toutes les 5 secondes

Génération de données simulées

Pour des tests, il est également possible de simuler des données en temps réel. Voici un exemple de génération de données aléatoires avec numpy.

import numpy as np
import time

while True:
    data = np.random.random

()
    print(data)
    time.sleep(1)  # Génère des données aléatoires toutes les secondes

Utilisez ces méthodes pour obtenir des données en temps réel, puis dans l’étape suivante, nous verrons comment les tracer en temps réel.

Implémentation de base d’un tracé en temps réel

Pour implémenter un tracé en temps réel, il est nécessaire de mettre à jour régulièrement le tracé avec les nouvelles données récupérées. Ici, nous présenterons une méthode de base pour le faire avec Matplotlib.

Mise à jour de base du tracé

Avec Matplotlib, vous pouvez utiliser la classe FuncAnimation pour mettre à jour un tracé en temps réel. Voici un exemple de tracé de données aléatoires en temps réel.

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np

# Préparez des listes pour stocker les données
x_data = []
y_data = []

# Configuration du graphique
fig, ax = plt.subplots()
line, = ax.plot([], [], 'r-')

# Initialisation du tracé
def init():
    ax.set_xlim(0, 100)
    ax.set_ylim(0, 1)
    return line,

# Fonction de mise à jour des données
def update(frame):
    x_data.append(frame)
    y_data.append(np.random.random())

    # Supprime les anciennes données lorsque la liste dépasse une certaine longueur
    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(x_data, y_data)
    return line,

# Configuration de l'animation
ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 200), init_func=init, blit=True)

plt.show()

Combinaison de la récupération de données et du tracé

Voici un exemple de combinaison des méthodes de récupération de données avec le tracé en temps réel. Ici, nous illustrons la façon de tracer des données récupérées depuis une API en temps réel.

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import requests
import numpy as np

# Préparez des listes pour stocker les données
x_data = []
y_data = []

# Configuration du graphique
fig, ax = plt.subplots()
line, = ax.plot([], [], 'r-')

# Initialisation du tracé
def init():
    ax.set_xlim(0, 100)
    ax.set_ylim(0, 100)
    return line,

# Fonction de mise à jour des données
def update(frame):
    # Récupère des données depuis l'API
    response = requests.get('https://api.example.com/data')
    data = response.json()
    value = data['value']

    x_data.append(frame)
    y_data.append(value)

    # Supprime les anciennes données lorsque la liste dépasse une certaine longueur
    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(x_data, y_data)
    return line,

# Configuration de l'animation
ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 200), init_func=init, blit=True)

plt.show()

Dans ce code, les données récupérées depuis une API sont tracées en temps réel. En mettant à jour les données dans la fonction update, nous réalisons un tracé en temps réel. Dans l’étape suivante, nous allons explorer des méthodes de tracé en temps réel plus avancées utilisant des animations.

Tracé en temps réel avec animations

Avec la fonction d’animation de Matplotlib, il est possible de créer des tracés en temps réel plus fluides et dynamiques. Ici, nous allons introduire la méthode pour tracer des données en temps réel en utilisant FuncAnimation.

Configuration de base de l’animation

Tout d’abord, examinons les bases de FuncAnimation. Cette fonction est utilisée pour mettre à jour périodiquement le tracé.

Dans cet exemple, nous affichons une onde sinusoïdale en animation. La fonction update met à jour les données, et FuncAnimation appelle cette fonction à intervalles réguliers pour rafraîchir le tracé.

Animation des données en temps réel

Ensuite, voyons comment tracer des données en temps réel de manière animée. Dans cet exemple, nous générons des données aléatoires pour les tracer en temps réel.

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np

fig, ax = plt.subplots()
x_data, y_data = [], []
line, = ax.plot([], [], 'b-')

# Fonction d'initialisation
def init():
    ax.set_xlim(0, 100)
    ax.set_ylim(0, 1)
    return line,

# Fonction de mise à jour
def update(frame):
    x_data.append(frame)
    y_data.append(np.random.random())

    # Supprimer les anciennes données si la liste dépasse 100 points
    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(x_data, y_data)
    return line,

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

Dans ce code, nous générons des données aléatoires à chaque image et mettons à jour le tracé en conséquence. Cela permet de visualiser les données qui évoluent en temps réel.

Options avancées de configuration d’animation

FuncAnimation offre de nombreuses options pour personnaliser l’animation. Voici les principales options :

  • frames : le nombre de trames ou une fonction de génération de trames
  • interval : l’intervalle entre les trames en millisecondes
  • blit : améliore les performances en ne redessinant que les parties modifiées du tracé

Par exemple, pour définir l’intervalle de mise à jour à 500 millisecondes, utilisez le code suivant :

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

Cela met à jour le tracé toutes les 0,5 secondes. Dans la section suivante, nous expliquerons un exemple pratique de tracé en temps réel de données de capteurs.

Exemple d’application : Tracé en temps réel des données de capteurs

Le tracé en temps réel des données de capteurs est couramment utilisé dans les dispositifs IoT et les systèmes de surveillance en temps réel. Dans cet exemple, nous allons tracer les données d’un capteur de température en temps réel.

Simulation de données de capteur

Au lieu d’utiliser un capteur réel, nous allons ici simuler des données de température. Le code suivant génère des données de température simulées et les trace en temps réel.

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np
import random

fig, ax = plt.subplots()
x_data, y_data = [], []
line, = ax.plot([], [], 'r-')

# Initialisation du tracé
def init():
    ax.set_xlim(0, 100)
    ax.set_ylim(15, 30)  # Plage de température
    return line,

# Fonction de mise à jour
def update(frame):
    x_data.append(frame)
    # Génère des données de température aléatoires
    y_data.append(20 + random.uniform(-5, 5))

    # Supprimer les anciennes données si la liste dépasse 100 points
    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(x_data, y_data)
    return line,

ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 200), init_func=init, blit=True)
plt.xlabel('Temps')
plt.ylabel('Température (°C)')
plt.title('Tracé en temps réel de la température')
plt.show()

Récupération et tracé des données de capteur réelles

Pour récupérer les données d’un capteur réel, vous pouvez utiliser la bibliothèque Python adaptée à votre matériel. Voici un exemple pour lire des données de température envoyées par un capteur connecté à un Arduino via un port série.

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import serial

# Configuration du port série
ser = serial.Serial('COM3', 9600)

fig, ax = plt.subplots()
x_data, y_data = [], []
line, = ax.plot([], [], 'r-')

# Initialisation du tracé
def init():
    ax.set_xlim(0, 100)
    ax.set_ylim(15, 30)  # Plage de température
    return line,

# Fonction de mise à jour
def update(frame):
    x_data.append(frame)
    # Lire les données depuis le port série
    data = ser.readline().decode('utf-8').strip()
    y_data.append(float(data))

    # Supprimer les anciennes données si la liste dépasse 100 points
    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(x_data, y_data)
    return line,

ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 200), init_func=init, blit=True)
plt.xlabel('Temps')
plt.ylabel('Température (°C)')
plt.title('Tracé en temps réel de la température')
plt.show()

Dans ce code, les données de température envoyées par l’Arduino via le port série sont tracées en temps réel. Assurez-vous que le capteur est correctement connecté et que les données sont lues correctement dans l’environnement réel.

Enregistrement des données et journalisation

En plus de visualiser les données en temps réel, il peut être utile de les enregistrer dans un fichier pour une analyse ultérieure. Voici comment enregistrer les données dans un fichier CSV pendant qu’elles sont tracées.

import csv

# Ouvrir le fichier CSV
with open('temperature_data.csv', mode='w', newline='') as file:
    writer = csv.writer(file)
    writer.writerow(['Temps', 'Température'])

    def update(frame):
        x_data.append(frame)
        data = ser.readline().decode('utf-8').strip()
        y_data.append(float(data))

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

        # Écrire les données dans le fichier CSV
        writer.writerow([frame, float(data)])

        line.set_data(x_data, y_data)
        return line,

    ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 200), init_func=init, blit=True)
    plt.xlabel('Temps')
    plt.ylabel('Température (°C)')
    plt.title('Tracé en temps réel de la température')
    plt.show()

Ce code enregistre les données de température dans un fichier temperature_data.csv tout en les traçant en temps réel. Cela permet de visualiser les données en temps réel et de les stocker pour une analyse future.

Dans la prochaine section, nous verrons comment tracer en temps réel les données de marché, comme les prix des actions.

Exemple d’application : Traçage en temps réel des données boursières

Le traçage en temps réel des données boursières est très utile pour les traders et les investisseurs. Ici, nous allons expliquer comment obtenir et tracer les données boursières en temps réel en utilisant l’API Yahoo Finance.

Configuration de l’API Yahoo Finance

Tout d’abord, installez la bibliothèque yfinance. Cette bibliothèque permet d’obtenir facilement des données boursières depuis Yahoo Finance.

pip install yfinance

Obtention et traçage des données en temps réel

Le code suivant utilise yfinance pour obtenir les données en temps réel d’une action spécifique et les tracer avec Matplotlib.

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

# Préparation des listes pour stocker les données
x_data, y_data = [], []

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

# Fonction d'initialisation
def init():
    ax.set_xlim(0, 100)
    ax.set_ylim(0, 500)  # Définir la plage des prix
    return line,

# Fonction de mise à jour
def update(frame):
    current_time = datetime.datetime.now().strftime('%H:%M:%S')
    x_data.append(current_time)

    # Obtenir les données de l'API Yahoo Finance
    stock = yf.Ticker('AAPL')
    data = stock.history(period='1m')
    y_data.append(data['Close'][-1])

    # Supprimer les anciennes données si elles dépassent une certaine 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('Heure')
plt.ylabel('Prix de l'action ($)')
plt.title('Traçage en temps réel des prix - AAPL')
plt.show()

Ce code obtient le prix de l’action Apple (AAPL) toutes les minutes et le trace en temps réel. La fonction FuncAnimation appelle la fonction update chaque minute pour actualiser le traçage.

Sauvegarde et enregistrement des données

En plus de tracer les prix en temps réel, il est important de sauvegarder les données pour les analyser ultérieurement. Le code suivant sauvegarde les données dans un fichier CSV en même temps qu’il les trace.

import csv

# Ouvrir un fichier CSV
with open('stock_data.csv', mode='w', newline='') as file:
    writer = csv.writer(file)
    writer.writerow(['Heure', 'Prix'])

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

        # Obtenir les données de l'API Yahoo Finance
        stock = yf.Ticker('AAPL')
        data = stock.history(period='1m')
        price = data['Close'][-1]
        y_data.append(price)

        # Écrire les données dans le fichier CSV
        writer.writerow([current_time, price])

        # Supprimer les anciennes données si elles dépassent une certaine 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('Heure')
    plt.ylabel('Prix de l'action ($)')
    plt.title('Traçage en temps réel des prix - AAPL')
    plt.show()

Ce code enregistre les données tracées en temps réel dans le fichier stock_data.csv. Cela permet à la fois la visualisation en temps réel et l’enregistrement continu des données.

Dans la section suivante, nous détaillerons la sauvegarde et le partage des données.

Sauvegarde et partage des données

En plus de tracer les données en temps réel, il est également important de sauvegarder les données collectées pour les analyser ou les partager ultérieurement. Ici, nous expliquons comment sauvegarder et partager les données issues des traçages en temps réel.

Méthodes de sauvegarde des données

Le format de fichier le plus couramment utilisé pour sauvegarder des données est le CSV (Comma Separated Values). En Python, il est facile d’écrire des données dans un fichier CSV en utilisant le module csv.

import csv

# Ouvrir un fichier CSV
with open('realtime_data.csv', mode='w', newline='') as file:
    writer = csv.writer(file)
    writer.writerow(['Heure', 'Donnée'])

    def update(frame):
        current_time = datetime.datetime.now().strftime('%H:%M:%S')
        x_data.append(current_time)
        value = np.random.random()  # Utilisation de données aléatoires ici
        y_data.append(value)

        # Écrire les données dans le fichier 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('Heure')
    plt.ylabel('Valeur de la donnée')
    plt.title('Traçage des données en temps réel')
    plt.show()

Ce code sauvegarde les données obtenues en temps réel dans le fichier realtime_data.csv.

Méthodes de partage des données

Il existe plusieurs façons de partager les données sauvegardées. Voici quelques méthodes courantes.

Partager par e-mail

La méthode la plus simple est de joindre le fichier CSV sauvegardé à un e-mail et de l’envoyer.

Utiliser le stockage en nuage

Il est également pratique d’utiliser des services de stockage en nuage tels que Google Drive ou Dropbox pour partager les données avec d’autres personnes.

Sauvegarder dans une base de données

Une autre option consiste à sauvegarder les données dans une base de données pour y accéder depuis des applications Web ou des outils d’analyse de données. Voici un exemple de sauvegarde dans une base de données SQLite.

import sqlite3

# Connexion à la base de données
conn = sqlite3.connect('realtime_data.db')
cursor = conn.cursor()

# Création de la table
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()  # Utilisation de données aléatoires ici
    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('Heure')
plt.ylabel('Valeur de la donnée')
plt.title('Traçage des données en temps réel')
plt.show()

# Fermeture de la connexion à la base de données
conn.close()

Ce code sauvegarde les données obtenues en temps réel dans une base de données SQLite.

Visualisation et analyse des données

Pour visualiser et analyser les données sauvegardées, vous pouvez utiliser la bibliothèque Pandas. Voici un exemple pour lire un fichier CSV sauvegardé et le tracer.

import pandas as pd

# Charger les données
df = pd.read_csv('realtime_data.csv')

# Tracer les données
plt.figure()
plt.plot(df['Heure'], df['Donnée'])
plt.xlabel('Heure')
plt.ylabel('Valeur de la donnée')
plt.title('Traçage des données sauvegardées')
plt.xticks(rotation=45, ha='right')
plt.show()

Ce code charge les données du fichier CSV avec Pandas et les trace. Cela permet d’analyser et de visualiser les données historiques.

Dans la prochaine section, nous aborderons les problèmes courants et les solutions lors de l’utilisation du traçage en temps réel.

Dépannage

Lors du traçage en temps réel, divers problèmes peuvent survenir. Ici, nous décrivons les problèmes fréquents et leurs solutions.

Le traçage ne se met pas à jour

Si le traçage en temps réel ne se met pas à jour, cela peut être dû aux raisons suivantes :

Raison 1 : Mauvaise configuration de l’animation

Si la configuration de FuncAnimation est incorrecte, le traçage peut ne pas se mettre à jour. Assurez-vous que init_func et la fonction update renvoient correctement les données si blit=True est activé.

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

Raison 2 : Délai dans l’obtention des données

Un délai dans l’obtention des données peut entraîner un retard dans la mise à jour du traçage. Révisez la fréquence de récupération des données et le temps de réponse de l’API pour garantir un intervalle approprié pour la collecte des données.

def update(frame):
    try:
        # Récupération des données
        data = requests.get('https://api.example.com/data').json()
        # Mise à jour des données
    except Exception as e:
        print(f"Erreur de récupération des données : {e}")
    return line,

Le traçage scintille

Si le traçage scintille, vous pouvez utiliser blit=True pour améliorer la mise à jour partielle du dessin.

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

Problème de fuite de mémoire

Avec un traçage en temps réel sur une longue durée, la consommation de mémoire peut augmenter. Il est essentiel de supprimer les anciennes données pour gérer efficacement la mémoire.

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

    # Supprimer les anciennes données
    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(x_data, y_data)
    return line,

Gestion des erreurs de récupération des données

Lors de l’obtention des données en temps réel, des erreurs réseau ou des pannes d’API peuvent survenir. Utilisez une gestion appropriée des erreurs pour réessayer en cas de problème.

import time

def update(frame):
    try:
        # Récupération des données
        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"Erreur de récupération des données : {e}")
        time.sleep(5)  # Attendre 5 secondes avant de réessayer
    return line,

Ajustement de la plage d’affichage

Si les valeurs des données changent dynamiquement, il peut être nécessaire d’ajuster dynamiquement la plage d’affichage du traçage.

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)  # Ajustement dynamique de la plage d'affichage
    ax.set_ylim(min(y_data), max(y_data))    # Ajustement de la plage Y en fonction des données
    return line,

Lissage des données

Si les données en temps réel sont bruyantes, le lissage des données peut améliorer l’effet visuel. Voici un exemple d’utilisation de la moyenne mobile pour lisser les données.

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,

En suivant ces conseils de dépannage, vous pourrez résoudre les problèmes de traçage en temps réel et obtenir une visualisation des données plus fluide.

Dans la section suivante, nous résumerons le contenu abordé.

Conclusion

Le traçage des données en temps réel est une technique importante pour de nombreuses applications, comme la surveillance des données de capteurs ou le suivi des prix boursiers. En utilisant Matplotlib, il est possible de réaliser facilement des traçages en temps réel avec Python.

Dans ce guide, nous avons abordé les points suivants :

  • Les concepts de base du traçage en temps réel
  • Installation et configuration de Matplotlib
  • Obtention des données à partir de capteurs ou d’API
  • Mise en œuvre de traçages en temps réel avec FuncAnimation
  • Paramètres avancés de traçage avec animation
  • Exemples d’application pour les données de capteurs et les données boursières
  • Méthodes de sauvegarde et de partage des données
  • Les problèmes courants et leurs solutions

En comprenant et en suivant ces étapes, vous pourrez réaliser une visualisation des données en temps réel de manière plus efficace. La visualisation des données est un outil puissant pour détecter rapidement les tendances et les anomalies dans les données. N’hésitez pas à l’utiliser dans vos projets et recherches futurs.

Python
Python Stockage de Données Matplotlib Visualisation de Données Données de Capteur FuncAnimation Visualisation en Temps Réel Récupération de Données API Graphique de Cours d'Actions Analyse en Temps Réel
Sommaire