Zeichnen Sie Live-Diagramme mit Python Dash und Plotly

Python bietet leistungsstarke Tools wie Dash und Plotly zum Erstellen interaktiver und dynamischer Visualisierungen, mit denen wir Live-Diagramme erstellen können, um Daten in Echtzeit zu visualisieren, was für die Gewinnung wertvoller Erkenntnisse unerlässlich ist. In diesem Artikel wird erläutert, wie Sie Live-Diagramme mit Python Dash und Plotly zeichnen.

Wir erfahren, wie Sie eine Dash-Anwendung einrichten, das Layout definieren und das Diagramm mithilfe von Rückrufen dynamisch aktualisieren. Durch die Nutzung der umfassenden Visualisierungsfunktionen von Plotly und der Flexibilität von Dash können wir Echtzeitdiagramme erstellen, die auf sich ändernde Daten reagieren. Ob es darum geht, Sensordaten zu überwachen, Finanztrends zu verfolgen oder Live-Analysen zu visualisieren, Python Dash und Plotly bieten eine effiziente Lösung für interaktive Diagramme.

Wie zeichne ich Live-Diagramme mit Python Dash und Plotly?

Im Folgenden finden Sie die Schritte, die wir befolgen werden, um Live-Diagramme mit Python Dash und Plotly − zu zeichnen

  • Importieren Sie die erforderlichen Module −

    • `dash` und `plotly.graph_objs` werden aus den Paketen „dash“ und „plotly“ importiert.

    • `dcc` und `html` werden aus dem Paket `dash` zum Erstellen von Komponenten importiert.

    • `Output`, `Input` und `Interval` werden aus dem Modul `dash.dependencies` importiert, um Rückrufe zu definieren und Komponenten zu aktualisieren.

  • Initialisieren Sie die Dash-App:

    • Erstellen Sie eine Instanz der Klasse `Dash` und weisen Sie sie der Variablen `app` zu.

  • Definieren Sie das Layout der App:

    • Verwenden Sie die Komponente `html.Div`, um einen Container für den Inhalt der App zu erstellen.

    • Fügen Sie innerhalb des `Div` eine `html.H2`-Komponente hinzu, um den Titel „Live Graph“ anzuzeigen.

    • Fügen Sie eine `dcc.Graph`-Komponente mit der `id` von "live-graph" hinzu, um das Diagramm anzuzeigen. Setzen Sie `animate` auf „True“, um Live-Updates zu aktivieren.

    • Fügen Sie eine `dcc.Interval`-Komponente mit der „id“ „graph-update“ ein, um das Intervall zu definieren, in dem das Diagramm aktualisiert wird.

  • Definieren Sie die Callback-Funktion:

    • Verwenden Sie den Dekorator `@app.callback`, um die Funktion anzugeben, die das Diagramm aktualisiert.

    • Die Callback-Funktion verwendet die Eigenschaft `n_intervals` der Komponente „graph-update“ als Eingabe. Diese Eigenschaft gibt an, wie oft das Intervall verstrichen ist.

    • Generieren Sie innerhalb der Funktion Zufallsdaten für die x- und y-Achsenwerte. Im folgenden Programmbeispiel reicht die x-Achse von 0 bis 9 und die y-Achsenwerte sind zufällig generierte Ganzzahlen zwischen 0 und 100.

    • Erstellen Sie ein `go.Scatter`-Objekt, um die Diagrammspur darzustellen. Passen Sie das Erscheinungsbild mithilfe der bereitgestellten Parameter an.

    • Erstellen Sie ein `go.Layout`-Objekt, um das Layout des Diagramms zu definieren. Hier legen wir den Titel fest und geben die Bereiche für die x- und y-Achse basierend auf den generierten Daten an.

    • Gibt ein Wörterbuch mit den Komponenten `data` und `layout` zurück, die die anzuzeigende Diagrammfigur darstellen.

  • Führen Sie die App aus:

    • Verwenden Sie den Block `if __name__ == "__main__":`, um sicherzustellen, dass die App nur ausgeführt wird, wenn das Skript direkt ausgeführt wird (nicht als Modul importiert).

    • Rufen Sie innerhalb des Blocks die Methode `run_server` der Instanz `app` auf, um den Dash-Server zu starten. Setzen Sie `debug` zu Debugzwecken auf `True` und geben Sie die ``Port`-Nummer an, auf der der Server ausgeführt werden soll. Hier ist es auf 8051 eingestellt.

Wenn wir diese Schritte befolgen, können wir mit Dash und Plotly Live-Diagramme zeichnen. Wir können die Diagrammdaten, das Erscheinungsbild und das Layout entsprechend Ihren Anforderungen anpassen. Denken Sie daran, die erforderlichen Abhängigkeiten (`dash` und `plotly`) mit zu installieren

pip install dash plotly

Bevor Sie das Programm ausführen.

Beispiel

import dash
from dash import dcc, html
from dash.dependencies import Output, Input
import plotly.graph_objs as go
import random

# Initialize the Dash app
app = dash.Dash(__name__)

# Define the layout of the app
app.layout = html.Div(
   [
      html.H2("Live Graph"),
      dcc.Graph(id="live-graph", animate=True),
      dcc.Interval(id="graph-update", interval=1000, n_intervals=0),
   ]
)

# Callback function to update the graph
@app.callback(Output("live-graph", "figure"), [Input("graph-update", "n_intervals")])
def update_graph(n):
   # Generate random data
   x_data = list(range(10))
   y_data = [random.randint(0, 100) for _ in range(10)]

   # Create the graph trace
   trace = go.Scatter(
      x=x_data,
      y=y_data,
      mode="lines+markers",
      name="Data",
      line={"color": "rgb(0, 255, 0)"},
      marker={"color": "rgb(0, 255, 0)", "size": 8},
   )

   # Create the graph layout
   layout = go.Layout(
      title="Live Graph",
      xaxis=dict(range=[min(x_data), max(x_data)]),
      yaxis=dict(range=[min(y_data), max(y_data)]),
   )

   # Return the graph figure
   return {"data": [trace], "layout": layout}

if __name__ == "__main__":
   app.run_server(debug=True, port=8051)

Ausgabe

C:\Users\Tutorialspoint>python image.py
Dash is running on http://127.0.0.1:8051/

 * Serving Flask app 'image'
 * Debug mode: on

Abschluss

Zusammenfassend lässt sich sagen, dass Python Dash und Plotly eine leistungsstarke Kombination zum Erstellen von Live-Diagrammen bieten, die Daten dynamisch visualisieren. Indem wir die in diesem Artikel beschriebenen Schritte befolgen, können wir ganz einfach eine Dash-Anwendung einrichten, das Layout definieren und das Diagramm in Echtzeit aktualisieren.

Mit der Möglichkeit, das Erscheinungsbild und Verhalten der Diagramme anzupassen, ermöglichen Python Dash und Plotly Datenanalysten und Entwicklern die Erstellung interaktiver und aufschlussreicher Visualisierungen, die sich an sich ändernde Daten anpassen. Ob zur Überwachung, Analyse oder Berichterstellung, dieser Ansatz bietet eine vielseitige Lösung zum Zeichnen von Live-Diagrammen in Python.

Verwandte Artikel