Dash-Datenvisualisierung mit Plotly-Integration

Im Bereich der Datenwissenschaft und Analytik ist die Datenvisualisierung eine entscheidende Komponente. Durch Visualisierung können wir Daten intuitiver verstehen und Muster und Trends darin aufdecken.

Die zentralen Visualisierungsfunktionen von Dash basieren auf Plotly, einer leistungsstarken Open-Source-Bibliothek für Datenvisualisierung. Plotly bietet eine große Vielfalt an Diagrammtypen und hochgradig anpassbare Optionen, sodass sich interaktive Diagramme einfach erstellen lassen.

Dash lässt sich nahtlos über die Komponente dcc.Graph in Plotly integrieren, sodass Benutzer Plotly-Diagramme direkt in Dash-Anwendungen einbetten können.

Was ist Plotly?

Plotly ist eine JavaScript-basierte Open-Source-Bibliothek zur Datenvisualisierung, die mehrere Programmiersprachen unterstützt, darunter Python, R, Julia und andere.

Plotly bietet eine breite Palette an Diagrammtypen wie Liniendiagramme, Balkendiagramme, Streudiagramme, Heatmaps und mehr und unterstützt interaktive Funktionen wie Zoomen, Verschieben und Hover-Tooltips.

Plotly-Funktionen:

  • Vielfältige Diagrammtypen: Liniendiagramme, Balkendiagramme, Streudiagramme, Kreisdiagramme, Heatmaps, 3D-Diagramme und mehr.

  • Interaktivität: Unterstützt interaktive Funktionen wie Zoomen, Verschieben und Hover-Tooltips.

  • Hochgradig anpassbar: Ermöglicht die Anpassung von Diagrammfarben, Layout, Anmerkungen und mehr.

  • Nahtlose Integration mit Dash: durchdcc.GraphKomponente bettet Plotly-Diagramme direkt in Dash-Anwendungen ein.

Plotlys zentrale Vorteile

  • Interaktivität: Plotly-Diagramme unterstützen umfangreiche interaktive Funktionen, sodass Benutzer durch Mausoperationen mit Diagrammen interagieren können.
  • Vielfalt: Plotly bietet mehrere Diagrammtypen, die für unterschiedliche Anforderungen an die Datenvisualisierung geeignet sind.
  • Benutzerfreundlichkeit: Das API-Design von Plotly ist prägnant und ermöglicht einen einfachen Einstieg, unterstützt aber auch erweiterte Anpassungen.

Dash- und Plotly-Integration

1. Dash und Plotly installieren

Bevor wir beginnen, müssen wir Dash und Plotly installieren. Dies kann mit den folgenden Befehlen erfolgen:

pip install dash plotly
或
pip3 install dash plotly

dcc.GraphEs ist eine Komponente in Dash, die zum Anzeigen von Plotly-Diagrammen verwendet wird. Ihr Kernparameter ist figure, der die Daten und das Layout des Diagramms angibt.

figure-Parameter:

  • data: Der Datenteil des Diagramms, bei dem es sich um eine Liste von Dictionaries handelt, wobei jedes Dictionary eine Datenreihe repräsentiert.

  • layout: Der Layout-Teil des Diagramms, der verwendet wird, um Titel, Achsen, Legende und mehr festzulegen.

Beispiel

import dash
from dash import dcc, html
import plotly.express as px

# Dash-App erstellen
app = dash.Dash(__name__)

# Layout definieren
app.layout = html.Div([
    dcc.Graph(
        id='example-graph',
        figure={
            'data': [{'x': [1, 2, 3], 'y': [4, 1, 2], 'type': 'bar', 'name': 'Data 1'}],
            'layout': {'title': 'Example Chart'}
        }
    )
])

# Die App ausführen
if __name__ == '__main__':
    app.run_server(debug=True)

Die Anzeige sieht wie folgt aus:

2. Eine einfache Dash-Anwendung erstellen

Zuerst erstellen wir eine einfache Dash-Anwendung, die ein grundlegendes Plotly-Diagramm anzeigt.

Beispiel

import dash
from dash import dcc, html
import plotly.express as px
import pandas as pd

# Einen Beispieldatensatz erstellen
df = pd.DataFrame({
    "Fruit": ["Apples", "Oranges", "Bananas", "Apples", "Oranges", "Bananas"],
    "Amount": [4, 1, 2, 2, 4, 5],
    "City": ["SF", "SF", "SF", "NYC", "NYC", "NYC"]
})

# Ein Plotly-Diagramm erstellen
fig = px.bar(df, x="Fruit", y="Amount", color="City", barmode="group")

# Dash-Anwendung initialisieren
app = dash.Dash(__name__)

# Anwendungslayout definieren
app.layout = html.Div(children=[
    html.H1(children='Hallo Dash'),

    html.Div(children='''
        Dash: Ein Webanwendungs-Framework für Python.
    '''
),

    dcc.Graph(
        id='example-graph',
        figure=fig
    )
])

# Die App ausführen
if __name__ == '__main__':
    app.run_server(debug=True)

Codeanalyse:

  • Datensatzerstellung: Wir verwendenpandasEinen einfachen Datensatz erstelltdf, der Obst-, Mengen- und Stadtinformationen enthält.
  • Diagrammerstellung: Verwenden Sieplotly.expressvonpx.barDie Funktion erstellt ein Balkendiagramm, das die Mengen verschiedener Obstsorten in verschiedenen Städten zeigt.
  • Dash-Anwendungslayout: Verwendenhtml.Divunddcc.GraphDefinierte das Anwendungslayout, in demdcc.GraphWird zum Einbetten von Plotly-Diagrammen verwendet.
  • Anwendung ausführen: Überapp.run_server(debug=True)Starten Sie die Anwendung und aktivieren Sie den Debug-Modus.

Die Anzeige sieht wie folgt aus:

3. Interaktive Funktionalität hinzufügen

Die Stärke von Dash liegt in seinen interaktiven Funktionen; wir können Diagramminhalte dynamisch über den Callback-Mechanismus von Dash aktualisieren.

Beispiel

from dash.dependencies import Input, Output

# Aktualisieren Sie das Layout der Anwendung, um ein Dropdown-Menü hinzuzufügen
app.layout = html.Div(children=[
    html.H1(children='Hallo Dash'),

    html.Div(children='''
        Dash: Ein Webanwendungs-Framework für Python.
    '''
),

    dcc.Dropdown(
        id='city-dropdown',
        options=[
            {'label': 'San Francisco', 'value': 'SF'},
            {'label': 'New York City', 'value': 'NYC'}
        ],
        value='SF'
    ),

    dcc.Graph(
        id='example-graph',
    )
])

# Die Callback-Funktion definieren
@app.callback(
    Output('example-graph', 'figure'),
    [Input('city-dropdown', 'value')]
)
def update_graph(selected_city):
    filtered_df = df[df['City'] == selected_city]
    fig = px.bar(filtered_df, x="Fruit", y="Amount", color="City", barmode="group")
    return fig

# Die App ausführen
if __name__ == '__main__':
    app.run_server(debug=True)

Codeanalyse:

  • Dropdown-Menü: Hinzugefügt wurde einedcc.DropdownKomponente, mit der Benutzer verschiedene Städte auswählen können.
  • Callback-Funktion: Verwenden Sie@app.callbackDer Dekorator definiert eine Callback-Funktionupdate_graph, wenn der Benutzer eine andere Stadt auswählt, wird das Diagramm dynamisch aktualisiert.
  • Diagramm-Aktualisierung: Die Callback-Funktion filtert den Datensatz basierend auf der vom Benutzer ausgewählten Stadt und aktualisiert das Diagramm.

Die Anzeige sieht wie folgt aus:


Plotly Express

Plotly Express ist Plotlys High-Level-Schnittstelle, mit der sich komplexe Diagramme mit minimalem Code erstellen lassen. Sie eignet sich gut für schnelles Prototyping.

Gängige Diagrammtypen

1. Liniendiagramm (px.line):

import plotly.express as px
df = px.data.iris()
fig = px.line(df, x='sepal_width', y='sepal_length', title='折线图示例')

2. Balkendiagramm (px.bar):

fig = px.bar(df, x='species', y='sepal_length', title='柱状图示例')

3. Streudiagramm (px.scatter):

fig = px.scatter(df, x='sepal_width', y='sepal_length', color='species', title='散点图示例')

4. Kreisdiagramm (px.pie):

fig = px.pie(df, names='species', values='sepal_length', title='饼图示例')

5. Heatmap (px.imshow):

import numpy as np
data = np.random.rand(10, 10)
fig = px.imshow(data, title='热力图示例')

Das Folgende ist ein vollständiges Beispiel einer Dash-Anwendung, die Plotly Express zum Erstellen von Diagrammen verwendet:

Beispiel

from dash import Dash, dcc, html
import plotly.express as px
import pandas as pd

# Beispieldaten erstellen
df = pd.DataFrame({
    'city': ['Beijing', 'Shanghai', 'Guangzhou', 'Shenzhen'],
    'Bevölkerung': [2171, 2424, 1490, 1303]
})

# Dash-App erstellen
app = Dash(__name__)

# Plotly Express zum Erstellen eines Balkendiagramms verwenden
fig = px.bar(df, x='city', y='Population', title=Bevölkerungsdaten der Stadt)

# Layout definieren
app.layout = html.Div([
    dcc.Graph(id='example-graph', figure=fig)
])

# Die App ausführen
if __name__ == '__main__':
    app.run_server(debug=True)

Wird folgendermaßen angezeigt:


Verwendung von Plotly Graph Objects

Plotly Graph Objects ist die Low-Level-Schnittstelle von Plotly, bietet eine feinere Steuerung und eignet sich für Szenarien, die ein hohes Maß an Anpassung erfordern.

Gängige Diagrammtypen

1. Liniendiagramm (go.Scatter):

import plotly.graph_objects as go
fig = go.Figure(data=go.Scatter(x=[1, 2, 3], y=[4, 1, 2], mode='lines'))

2. Balkendiagramm (go.Bar):

fig = go.Figure(data=go.Bar(x=['A', 'B', 'C'], y=[10, 20, 30]))

3. Streudiagramm (go.Scatter):

fig = go.Figure(data=go.Scatter(x=[1, 2, 3], y=[4, 1, 2], mode='markers'))

4. Kreisdiagramm (go.Pie):

fig = go.Figure(data=go.Pie(labels=['A', 'B', 'C'], values=[10, 20, 30]))

Das Folgende ist ein vollständiges Beispiel einer Dash-Anwendung, die Plotly Graph Objects verwendet, um Diagramme zu erstellen:

Beispiel

from dash import Dash, dcc, html
import plotly.graph_objects as go

# Dash-App erstellen
app = Dash(__name__)

# Verwenden von Plotly Graph Objects zum Erstellen von Balkendiagrammen
fig = go.Figure(data=go.Bar(x=['Beijing', 'Shanghai', 'Guangzhou', 'Shenzhen'], y=[2171, 2424, 1490, 1303]))

# Diagrammlayout festlegen
fig.update_layout(title=Stadtbevölkerungsdaten, xaxis_title='Stadt', yaxis_title='Bevölkerung')

# Layout definieren
app.layout = html.Div([
    dcc.Graph(id='example-graph', figure=fig)
])

# Die App ausführen
if __name__ == '__main__':
    app.run_server(debug=True)

Wird folgendermaßen angezeigt:

Weitere Erweiterungen