MENU
  1. Startseite
  2. Python
  3. Wie man Daten in Echtzeit mit Matplotlib plotten kann: Ein umfassender Leitfaden

Wie man Daten in Echtzeit mit Matplotlib plotten kann: Ein umfassender Leitfaden

Python

In der modernen Datenanalyse wird die Visualisierung von Daten in Echtzeit immer wichtiger. Matplotlib ist eine der am häufigsten verwendeten Bibliotheken zur Datenvisualisierung in Python, und mit seinen Funktionen kann auch das Plotten von Echtzeitdaten problemlos realisiert werden. In diesem Leitfaden erklären wir Schritt für Schritt, von den Grundlagen bis hin zu fortgeschrittenen Anwendungen, wie man Echtzeit-Plotting mit Matplotlib umsetzt – inklusive konkreter Code-Beispiele.

Inhaltsverzeichnis

Grundlagen des Echtzeit-Plotting

Echtzeit-Plotting ist eine Technik, bei der das Diagramm dynamisch entsprechend den Aktualisierungen der Daten verändert wird. Diese Technik ist in vielen Anwendungen wichtig, wie z.B. der Überwachung von Sensordaten oder Marktdaten. Grundsätzlich ist es notwendig, die Datenerfassung und die Aktualisierung des Plots regelmäßig durchzuführen. Um dies zu erreichen, kann man die Animationsfunktion oder Update-Schleifen von Matplotlib nutzen. Lassen Sie uns zunächst einen allgemeinen Überblick über den Ablauf und die notwendigen Elemente des Echtzeit-Plotting gewinnen.

Installation und Einrichtung von Matplotlib

Um Echtzeit-Plotting durchzuführen, muss zunächst Matplotlib installiert und eine grundlegende Konfiguration vorgenommen werden. Gehen Sie wie folgt vor, um die notwendigen Schritte abzuschließen.

Installation von Matplotlib

Da Matplotlib nicht zur Standardbibliothek von Python gehört, muss es mit pip installiert werden. Verwenden Sie dazu den folgenden Befehl:

pip install matplotlib

Installation weiterer benötigter Bibliotheken

Für die Implementierung des Echtzeit-Plotting werden häufig weitere Bibliotheken neben Matplotlib verwendet. Diese sollten ebenfalls mit pip installiert werden.

pip install numpy
pip install pandas

Grundlegende Einstellungen

Nachdem die Installation abgeschlossen ist, können die grundlegenden Einstellungen vorgenommen werden. Zuerst müssen die Bibliotheken in einem Python-Skript oder Jupyter Notebook importiert werden.

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

Funktionsprüfung

Um zu prüfen, ob die Installation und Konfiguration korrekt durchgeführt wurden, erstellen Sie einen einfachen Plot. Führen Sie den folgenden Code aus, um sicherzustellen, dass Matplotlib ordnungsgemäß funktioniert.

import matplotlib.pyplot as plt

plt.plot([1, 2, 3, 4], [1, 4, 9, 16])
plt.xlabel('x-Achsenbeschriftung')
plt.ylabel('y-Achsenbeschriftung')
plt.title('Test-Plot')
plt.show()

Wenn der Plot korrekt angezeigt wird, ist die Installation und Einrichtung abgeschlossen. Im nächsten Schritt sehen wir uns an, wie Echtzeitdaten erfasst werden können.

Methoden zur Datenerfassung

Um Echtzeit-Plotting zu realisieren, muss zunächst die Methode zur Echtzeit-Datenerfassung verstanden werden. Es gibt verschiedene Methoden zur Datenerfassung, von denen wir hier einige gängige vorstellen.

Erfassung von Sensordaten

Um Sensordaten in Echtzeit zu erfassen, benötigt man eine Bibliothek zur Kommunikation mit der Hardware. Wenn Sie z.B. Sensordaten mit Arduino oder Raspberry Pi sammeln möchten, verwenden Sie eine entsprechende Python-Bibliothek wie pyserial, um die Daten zu erhalten.

import serial

ser = serial.Serial('COM3', 9600)  # Geben Sie den Port und die Baudrate an
while True:
    data = ser.readline().decode('utf-8').strip()
    print(data)

Datenerfassung von einer API

Eine weitere Möglichkeit, Echtzeitdaten zu erfassen, ist die Verwendung einer API. Beispielsweise können Aktienkurse oder Wetterdaten über öffentliche APIs im Internet abgerufen werden. Die requests-Bibliothek wird verwendet, um Daten von einer API abzurufen.

import requests
import time

url = 'https://api.example.com/data'
while True:
    response = requests.get(url)
    data = response.json()
    print(data)
    time.sleep(5)  # Daten alle 5 Sekunden abrufen

Abrufen von Daten aus einer Datenbank

Zum Abrufen von Echtzeitdaten aus einer Datenbank wird ein Datenbank-Client verwendet. Im folgenden Beispiel wird gezeigt, wie Daten regelmäßig aus einer SQLite-Datenbank abgerufen werden können.

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)  # Daten alle 5 Sekunden abrufen

Generierung von Simulationsdaten

Zu Testzwecken können auch Echtzeitdaten simuliert werden. Das folgende Beispiel zeigt, wie man mit numpy zufällige Daten generiert.

import numpy as np
import time

while True:
    data = np.random.random()
    print(data)
    time.sleep(1)  # Alle Sekunde Zufallsdaten generieren

Mit diesen Methoden kann man Echtzeitdaten erfassen und im nächsten Schritt lernen, wie man diese in Echtzeit plottet.

Grundlegende Implementierung eines Echtzeit-Plots

Um ein Echtzeit-Plot zu implementieren, muss man die erfassten Daten regelmäßig aktualisieren und plotten. Hier zeigen wir, wie man mit Matplotlib ein grundlegendes Echtzeit-Plotting umsetzt.

Grundlegende Aktualisierung des Plots

In Matplotlib kann die FuncAnimation-Klasse verwendet werden, um den Plot in Echtzeit zu aktualisieren. Das folgende Beispiel zeigt, wie zufällige Daten in Echtzeit geplottet werden können.

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

# Liste zur Speicherung der Daten
x_data = []
y_data = []

# Einstellung des Diagramms
fig, ax = plt.subplots()
line, = ax.plot([], [], 'r-')

# Initialeinstellungen des Plots
def init():
    ax.set_xlim(0, 100)
    ax.set_ylim(0, 1)
    return line,

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

    # Entfernen alter Daten, wenn die Liste eine bestimmte Länge überschreitet
    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(x_data, y_data)
    return line,

# Einstellung der Animation
ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 200), init_func=init, blit=True)

plt.show()

Kombination von Datenerfassung und Plotting

Im nächsten Beispiel kombinieren wir die vorher beschriebene Methode zur Datenerfassung mit der Echtzeit-Plotting-Technik. Hier zeigen wir, wie man Daten, die über eine API abgerufen werden, in Echtzeit plotten kann.

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

# Liste zur Speicherung der Daten
x_data = []
y_data = []

# Einstellung des Diagramms
fig, ax = plt.subplots()
line, = ax.plot([], [], 'r-')

# Initialeinstellungen des Plots
def init():
    ax.set_xlim(0, 100)
    ax.set_ylim(0, 100)
    return line,

# Datenaktualisierungsfunktion
def update(frame):
    # Daten von der API abrufen
    response = requests.get('https://api.example.com/data')
    data = response.json()
    value = data['value']

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

    # Entfernen alter Daten, wenn die Liste eine bestimmte Länge überschreitet
    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

    line.set_data(x_data, y_data)
    return line,

# Einstellung der Animation
ani = animation.FuncAnimation(fig, update, frames=np.arange(0, 200), init_func=init, blit=True)

plt.show()

In diesem Code werden die von der API abgerufenen Daten in Echtzeit geplottet. Die update-Funktion ruft die Daten ab und aktualisiert den Plot, um das Echtzeit-Plotting zu realisieren. Im nächsten Abschnitt erklären wir, wie man fortgeschrittenere Animationen für Echtzeit-Plotting verwendet.

Echtzeit-Plotting mit Animation

Mit der Animationsfunktion von Matplotlib kann eine flüssigere und dynamischere Echtzeit-Plotting-Erfahrung erzielt werden. Hier erklären wir, wie man Echtzeitdaten mit FuncAnimation als Animation darstellt.

Grundlegende Einstellung der Animation

Zunächst sehen wir uns die grundlegende Verwendung von FuncAnimation an. Mit FuncAnimation kann der Plot regelmäßig aktualisiert werden.

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

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

# Initialisierungsfunktion
def init():
    ax.set_xlim(0, 10)
    ax.set_ylim(0, 1)
    return line,

# Aktualisierungsfunktion
def update(frame):
    x = np.linspace(0, 10, 100)
    y = np.sin(2 * np.pi * (x - 0.01 * frame))
    line.set_data(x, y)
    return line,

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

In diesem Beispiel wird eine Sinuskurve als Animation angezeigt. Die update-Funktion aktualisiert die Daten, und FuncAnimation ruft diese Funktion regelmäßig auf, um den Plot zu aktualisieren.

Echtzeit-Animation mit zufälligen Daten

Als nächstes zeigen wir ein Beispiel für das Echtzeit-Plotting von zufällig generierten Daten als Animation.

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-')

# Initialisierungsfunktion
def init():
    ax.set_xlim(0, 100)
    ax.set_ylim(0, 1)
    return line,

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

    # Entfernen alter Daten, wenn die Liste eine bestimmte Länge überschreitet
    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()

In diesem Code wird bei jedem Frame eine Zufallszahl generiert und der Plot aktualisiert. So kann man visuell verfolgen, wie sich die Daten in Echtzeit ändern.

Details der Animationskonfiguration

FuncAnimation bietet verschiedene Einstellungen, um die Animation anzupassen. Die wichtigsten Parameter sind:

  • frames: Anzahl der Frames der Animation oder eine Funktion zur Generierung der Frames
  • interval: Zeitverzögerung zwischen den Frames (in Millisekunden)
  • blit: Wenn auf True gesetzt, wird die Leistung der Darstellung durch partielles Aktualisieren verbessert

Beispielsweise kann der Aktualisierungsintervall auf 500 Millisekunden eingestellt werden:

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

Dadurch wird das Intervall für die Aktualisierung des Plots auf 0,5 Sekunden gesetzt. Im nächsten Abschnitt zeigen wir ein konkretes Anwendungsbeispiel für das Echtzeit-Plotting von Sensordaten.

Anwendungsbeispiel: Echtzeit-Plotting von Sensordaten

Das Echtzeit-Plotting von Sensordaten ist eine häufig genutzte Technik in IoT-Geräten oder in Überwachungssystemen. Hier zeigen wir ein Beispiel, in dem Temperaturdaten in Echtzeit geplottet werden.

Simulation von Sensordaten

Statt einen echten Sensor zu verwenden, simulieren wir hier die Sensordaten. Im folgenden Code wird die Temperatur simuliert und in Echtzeit geplottet.

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-')

# Initialisierungsfunktion
def init():
    ax.set_xlim(0, 100)
    ax.set_ylim(15, 30)  # Bereich für die Temperatur festlegen
    return line,

# Aktualisierungsfunktion
def update(frame):
    x_data.append(frame)
    # Zufällige Temperaturdaten generieren
    y_data.append(20 + random.uniform(-5, 5))

    # Entfernen alter Daten, wenn die Liste eine bestimmte Länge überschreitet
    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('Zeit')
plt.ylabel('Temperatur (°C)')
plt.title('Echtzeit-Temperatur-Plot')
plt.show()

Erfassung und Plotting von echten Sensordaten

Um echte Sensordaten zu erfassen, verwenden Sie die entsprechende Python-Bibliothek für die Sensorverbindung. Das folgende Beispiel zeigt, wie man Temperaturdaten von einem Arduino erfasst und in Echtzeit plottet.

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

# Konfiguration der seriellen Schnittstelle
ser = serial.Serial('COM3', 9600)

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

# Initialisierungsfunktion
def init():
    ax.set_xlim(0, 100)
    ax.set_ylim(15, 30)  # Bereich für die Temperatur festlegen
    return line,

# Aktualisierungsfunktion
def update(frame):
    x_data.append(frame)
    # Daten von der seriellen Schnittstelle lesen
    data = ser.readline().decode('utf-8').strip()
    y_data.append(float(data))

    # Entfernen alter Daten, wenn die Liste eine bestimmte Länge überschreitet
    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('Zeit')
plt.ylabel('Temperatur (°C)')
plt.title('Echtzeit-Temperatur-Plot')
plt.show()

In diesem Code sendet der Arduino Temperaturdaten über die serielle Schnittstelle, die dann in Echtzeit geplottet werden. Achten Sie bei der Verwendung von echten Sensoren auf die richtige Verbindung und Datenübertragung.

Speicherung und Protokollierung der Daten

Neben dem Echtzeit-Plotting ist es oft wichtig, die Daten in einer Datei zu speichern, um sie später analysieren zu können. Der folgende Code zeigt, wie man die Daten gleichzeitig plottet und in einer CSV-Datei speichert.

import csv

# CSV-Datei öffnen
with open('temperature_data.csv', mode='w', newline='') as file:
    writer = csv.writer(file)
    writer.writerow(['Zeit', 'Temperatur'])

    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)

        # Daten in die CSV-Datei schreiben
        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('Zeit')
    plt.ylabel('Temperatur (°C)')
    plt.title('Echtzeit-Temperatur-Plot')
    plt.show()

In diesem Code werden die geplotteten Daten in der Datei temperature_data.csv gespeichert. So wird sowohl die Echtzeit-Visualisierung als auch die langfristige Aufzeichnung der Daten ermöglicht.

Im nächsten Abschnitt erklären wir, wie man Echtzeit-Plotting für Börsendaten umsetzt.

Anwendungsbeispiel: Echtzeit-Plotten von Aktienkursdaten

Das Echtzeit-Plotten von Aktienkursdaten ist für Trader und Investoren äußerst nützlich. Hier zeigen wir, wie man mithilfe der Yahoo Finance API Echtzeit-Aktienkursdaten abruft und plottet.

Einrichtung der Yahoo Finance API

Zuerst installieren Sie die Bibliothek yfinance. Mit dieser Bibliothek können Sie ganz einfach Aktienkursdaten von Yahoo Finance abrufen.

pip install yfinance

Abrufen und Plotten von Echtzeitdaten

Im folgenden Code wird yfinance verwendet, um Echtzeitdaten einer bestimmten Aktie abzurufen und mit Matplotlib zu plotten.

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

# Vorbereitung der Listen zur Speicherung der Daten
x_data, y_data = [], []

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

# Initialisierungsfunktion
def init():
    ax.set_xlim(0, 100)
    ax.set_ylim(0, 500)  # Bereich des Aktienkurses festlegen
    return line,

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

    # Abruf der Aktienkursdaten von der Yahoo Finance API
    stock = yf.Ticker('AAPL')
    data = stock.history(period='1m')
    y_data.append(data['Close'][-1])

    # Wenn die Datenmenge eine bestimmte Größe überschreitet, werden alte Daten gelöscht
    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('Zeit')
plt.ylabel('Aktienkurs ($)')
plt.title('Echtzeit-Aktienkurs-Plot - AAPL')
plt.show()

In diesem Code werden jede Minute die Aktienkursdaten der Apple Inc. (AAPL) abgerufen und in Echtzeit geplottet. FuncAnimation ruft die Funktion update jede Minute auf, um das Diagramm zu aktualisieren.

Speichern und Protokollieren der Daten

Neben dem Echtzeit-Plotten der Aktienkurse ist es auch wichtig, die Daten zu speichern, um sie später analysieren zu können. Der folgende Code speichert die Daten gleichzeitig mit dem Plotten in einer CSV-Datei.

import csv

# Öffnen der CSV-Datei
with open('stock_data.csv', mode='w', newline='') as file:
    writer = csv.writer(file)
    writer.writerow(['Zeit', 'Aktienkurs'])

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

        # Abruf der Aktienkursdaten von der Yahoo Finance API
        stock = yf.Ticker('AAPL')
        data = stock.history(period='1m')
        price = data['Close'][-1]
        y_data.append(price)

        # Schreiben der Daten in die CSV-Datei
        writer.writerow([current_time, price])

        # Wenn die Datenmenge eine bestimmte Größe überschreitet, werden alte Daten

gelöscht
        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('Zeit')
    plt.ylabel('Aktienkurs ($)')
    plt.title('Echtzeit-Aktienkurs-Plot - AAPL')
    plt.show()

In diesem Code werden die geplotteten Daten in der Datei stock_data.csv gespeichert. Dadurch wird sowohl die Echtzeitvisualisierung als auch die fortlaufende Aufzeichnung der Daten ermöglicht.

Im nächsten Abschnitt wird detailliert erklärt, wie Sie die gespeicherten Daten speichern und teilen können.

Speichern und Teilen der Daten

Neben dem Echtzeit-Plotten ist es wichtig, die gesammelten Daten zu speichern, um sie später analysieren oder teilen zu können. Hier erläutern wir, wie Sie die Daten eines Echtzeit-Plots speichern und teilen können.

Methoden zum Speichern der Daten

Ein gängiges Format zum Speichern von Daten ist CSV (Comma Separated Values). In Python können Sie mit dem csv-Modul Daten einfach in eine CSV-Datei schreiben.

import csv

# Öffnen der CSV-Datei
with open('realtime_data.csv', mode='w', newline='') as file:
    writer = csv.writer(file)
    writer.writerow(['Zeit', 'Daten'])

    def update(frame):
        current_time = datetime.datetime.now().strftime('%H:%M:%S')
        x_data.append(current_time)
        value = np.random.random()  # Hier wird ein zufälliger Wert verwendet
        y_data.append(value)

        # Schreiben der Daten in die CSV-Datei
        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('Zeit')
    plt.ylabel('Datenwert')
    plt.title('Echtzeit-Daten-Plot')
    plt.show()

In diesem Code werden die in Echtzeit gesammelten Daten in der Datei realtime_data.csv gespeichert.

Methoden zum Teilen der Daten

Es gibt verschiedene Möglichkeiten, die gespeicherten Daten zu teilen. Nachfolgend sind einige gängige Methoden aufgeführt.

Teilen per E-Mail

Eine der einfachsten Möglichkeiten ist, die gespeicherte CSV-Datei per E-Mail-Anhang zu teilen.

Verwendung von Cloud-Speicher

Die Verwendung von Cloud-Speicherdiensten wie Google Drive oder Dropbox ist ebenfalls eine praktische Möglichkeit, um Daten mit anderen zu teilen.

Speichern in einer Datenbank

Eine weitere Möglichkeit besteht darin, die gesammelten Daten in einer Datenbank zu speichern, sodass darauf von Webanwendungen oder Datenanalysetools zugegriffen werden kann. Nachfolgend ein Beispiel zum Speichern der Daten in einer SQLite-Datenbank.

import sqlite3

# Verbindung zur Datenbank öffnen
conn = sqlite3.connect('realtime_data.db')
cursor = conn.cursor()

# Tabelle erstellen
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()  # Hier wird ein zufälliger Wert verwendet
    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('Zeit')
plt.ylabel('Datenwert')
plt.title('Echtzeit-Daten-Plot')
plt.show()

# Verbindung zur Datenbank schließen
conn.close()

In diesem Code werden die in Echtzeit gesammelten Daten in einer SQLite-Datenbank gespeichert.

Visualisierung und Analyse der Daten

Zum späteren Visualisieren und Analysieren der gespeicherten Daten können Sie die Pandas-Bibliothek verwenden. Nachfolgend ein Beispiel, wie Sie die gespeicherte CSV-Datei einlesen und plotten.

import pandas as pd

# Daten einlesen
df = pd.read_csv('realtime_data.csv')

# Daten plotten
plt.figure()
plt.plot(df['Zeit'], df['Daten'])
plt.xlabel('Zeit')
plt.ylabel('Datenwert')
plt.title('Plot der gespeicherten Daten')
plt.xticks(rotation=45, ha='right')
plt.show()

In diesem Code wird die gespeicherte CSV-Datei mit Pandas eingelesen und geplottet. So können Sie die historischen Daten analysieren und visualisieren.

Im nächsten Abschnitt werden häufig auftretende Probleme beim Echtzeit-Plotten und deren Lösungen erläutert.

Fehlerbehebung

Beim Echtzeit-Plotten können verschiedene Probleme auftreten. Hier werden häufige Probleme und deren Lösungen beschrieben.

Plot wird nicht aktualisiert

Wenn das Echtzeit-Plotten nicht aktualisiert wird, können folgende Ursachen vorliegen.

Ursache 1: Fehlerhafte Animationseinstellungen

Wenn die Einstellungen von FuncAnimation nicht korrekt sind, wird der Plot möglicherweise nicht aktualisiert. Stellen Sie sicher, dass init_func und update die Daten korrekt zurückgeben, wenn blit=True eingestellt ist.

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

Ursache 2: Verzögerung beim Datenabruf

Wenn der Datenabruf zu lange dauert, kann die Aktualisierung des Plots verzögert werden. Überprüfen Sie die Abruffrequenz und die Antwortzeit der API, um die Daten in angemessenen Abständen zu erhalten.

def update(frame):
    try:
        # Datenabruf
        data = requests.get('https://api.example.com/data').json()
        # Datenaktualisierung
    except Exception as e:
        print(f"Datenabruf-Fehler: {e}")
    return line,

Flimmern des Plots

Wenn der Plot flimmert, kann das Setzen von blit=True für eine teilweise Aktualisierung der Darstellung helfen.

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

Problem mit Speicherlecks

Beim Langzeit-Echtzeit-Plotten kann die Speichernutzung zunehmen. Es ist wichtig, unnötige Daten zu löschen und den Speicherverbrauch zu verwalten.

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

    # Löschen alter Daten
    if len(x_data) > 100:
        x_data.pop(0)
        y_data.pop(0)

   

 line.set_data(x_data, y_data)
    return line,

Fehler beim Datenabruf

Beim Echtzeit-Datenabruf können Netzwerkfehler oder API-Ausfälle auftreten. Eine geeignete Fehlerbehandlung und ein erneuter Versuch bei Problemen sind sinnvoll.

import time

def update(frame):
    try:
        # Datenabruf
        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"Datenabruf-Fehler: {e}")
        time.sleep(5)  # 5 Sekunden warten und erneut versuchen
    return line,

Anpassung des Anzeigeumfangs

Wenn die Werte der Daten dynamisch variieren, ist eine dynamische Anpassung des Anzeigebereichs im Plot erforderlich.

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)  # Dynamische Anpassung des Anzeigebereichs
    ax.set_ylim(min(y_data), max(y_data))    # Y-Achse an Datenbereich anpassen
    return line,

Glättung der Daten

Wenn Echtzeitdaten stark rauschen, kann eine Glättung der Daten die visuelle Darstellung verbessern. Im folgenden Beispiel wird ein gleitender Durchschnitt zur Glättung verwendet.

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,

Diese Tipps zur Fehlerbehebung helfen Ihnen dabei, Probleme beim Echtzeit-Plotten zu lösen und eine flüssigere Datenvisualisierung zu erreichen.

Im nächsten Abschnitt fassen wir die Inhalte zusammen.

Zusammenfassung

Das Plotten von Echtzeitdaten ist eine wichtige Technik für verschiedene Anwendungen, wie z.B. die Überwachung von Sensordaten oder die Verfolgung von Aktienkursen. Mit Matplotlib können Sie in Python einfach Echtzeit-Plotting umsetzen.

In dieser Anleitung haben wir folgende Punkte ausführlich erklärt:

  • Grundlegende Konzepte des Echtzeit-Plotting
  • Installation und Einrichtung von Matplotlib
  • Möglichkeiten zum Abrufen von Daten aus Sensoren oder APIs
  • Grundlegende Implementierung eines Echtzeit-Plots mit FuncAnimation
  • Erweiterte Einstellungen für animierte Plots
  • Konkrete Anwendungsbeispiele für Sensordaten und Aktienkursdaten
  • Methoden zur Speicherung und zum Teilen von Daten
  • Häufige Probleme und deren Lösungen

Durch das Verständnis und die Umsetzung dieser Schritte können Sie die Visualisierung von Echtzeitdaten effektiver gestalten. Die Datenvisualisierung ist ein leistungsstarkes Werkzeug, um Trends und Anomalien in den Daten schnell zu erkennen. Nutzen Sie dieses Wissen in Ihren zukünftigen Projekten und Studien.

Python
Aktienkurs-Diagramm API-Datenabruf Datenaufbewahrung Datenvisualisierung Echtzeit-Diagramm Echtzeitanalyse FuncAnimation Matplotlib Python Sensordaten
Inhaltsverzeichnis