[PYTHON] Plotten Anwenden von Diagrammen mit Schiebereglern

Einführung

Dies ist ein Memo, da ich häufig Diagramme mit Schiebereglern mit Plotly erstelle.

Da der Code offiziell zum Verschieben eines Diagramms mit einem Schieberegler verwendet wird, beschreibe ich eine kleine Anwendung, z. B. wenn Sie mehrere Diagramme gleichzeitig verschieben möchten.

Offizielle Seite (Slider Erklärung Seite) Sliders | Python | Plotly

Umgebung

Mac OS python 3.8.5 plotly 4.12.0

pip, import Installieren Sie Folgendes von pip: Ich habe es zusammen installiert, um numpy im Artikel zu verwenden.

pip install plotly
pip install numpy

import numpy as np
import plotly.offline as offline
import plotly.graph_objs as go

Plotly Slider Grundlagen

Obwohl es vorerst offiziell gelistet ist

See the Pen simple slider by shunta-m (@shunta-m) on CodePen.

Es wird in der Reihenfolge der Trace- (Plot-) Erstellung-> Layout-Erstellung-> Graph-Erstellung geschrieben

import numpy as np
import plotly.offline as offline
import plotly.graph_objs as go

#Liste zum Speichern von Plots
data = []
x = np.linspace(0, 10, 101)
#Plot erstellen
# 0, 0.1, ... ,Erstellen Sie Diagramme bis zu 5
for step in np.linspace(0, 5, 51):
    y = np.sin(step * x)

    trace = go.Scatter(
        x=x,
        y=y,
        name="sin step{:.1f}".format(step),
        line=dict(color="red", width=3),
        visible=False, )  #Mach es unsichtbar
    data.append(trace)

#Machen Sie das 10. Diagramm als Ausgangszustand sichtbar
data[10].visible = True

#Wo soll durch die Position des Schiebereglers angezeigt werden/Liste zum Ausblenden oder Speichern
steps = []
"""
Entscheiden Sie, wo in der for-Anweisung angezeigt werden soll
Wenn der Schieberegler beispielsweise auf 10 steht, möchte ich nur das 10. Diagramm sehen.
Verstecke alles einmal->Setzen Sie im 10. Diagramm sichtbar auf Wahr, um es sichtbar zu machen
"""
for s in range(len(data)):
    step = dict(method="update",
                args=[{"visible": [False] * len(data)},  #Verstecke alles einmal
                      {"title": "Simple slider step: {}".format(s)}]  #Ändern Sie den Titel abhängig von der Position des Schiebereglers
                )
    step["args"][0]["visible"][s] = True  #Machen Sie nur die entsprechenden sichtbar
    #Es wurde ein in ↑ erstelltes Layout hinzugefügt, bei dem nur das etw für Schritte sichtbar ist
    steps.append(step)

sliders = [dict(
    active=10,  #Anfangswert des Schiebereglers
    currentvalue=dict(prefix="Frequency: "),
    pad=dict(t=50),  #Belegungsbereich des Schiebereglers,Je größer der Wert, desto größer der Bereich des Schiebereglers.
    steps=steps)]  #Zeigen Sie an, dass Schritte haben/Verwenden Sie versteckte Informationen

layout = go.Layout(
    title="Simple slider step: 10",  #Ersttitel
    xaxis=dict(title="x"),
    yaxis=dict(title="y"),
    font=dict(family="Meiryo", size=16),  #Ändern Sie die Schriftart in der Grafik in Meirio und die Größe in 16
    #Schwebemodus (wie die Zahlen aussehen, wenn sich der Cursor in der Nähe des Diagramms befindet)
    #Die Zeichenfolge, die angegeben werden kann"x", "y", "closest", False, "x unified", "y unified"
    hovermode="x unified",
    hoverlabel=dict(font_size=16),  #Einstellung der Schriftgröße im Schwebemodus
    sliders=sliders,  #Schieberegler hinzufügen
    showlegend=True)  #Legendenanzeige auf True gesetzt

fig = dict(data=data, layout=layout)

#Ausgabe
offline.plot(fig, auto_open=True, include_plotlyjs="cdn", filename="simple_slider.html")

Verschieben Sie mehrere Diagramme

Bewegen wir sowohl die Sin-Welle als auch die Cos-Welle.

plots.gif

import numpy as np
import plotly.offline as offline
import plotly.graph_objs as go

# sin,Speichern Sie die Cos-Wave-Spuren separat
sin_data, cos_data = [], []
x = np.linspace(0, 10, 101)

for step in np.linspace(0, 5, 51):
    y = np.sin(step * x)
    y2 = np.cos(step * x)

    sin_trace = go.Scatter(
        x=x,
        y=y,
        name="sin {:.1f}Hz".format(step),
        line=dict(color="red", width=3),
        visible=False, )

    cos_trace = go.Scatter(
        x=x,
        y=y2,
        name="cos {:.1f}Hz".format(step),
        line=dict(color="blue", width=3),
        visible=False, )

    sin_data.append(sin_trace)
    cos_data.append(cos_trace)

sin_data[10].visible = True
cos_data[10].visible = True

data = sin_data + cos_data

steps = []
"""
sin_data, cos_Anzeige von Daten/Wird separat ausgeblendet, dann kombiniert und zum sichtbaren Schlüssel hinzugefügt
Wenn der Schieberegler beispielsweise 2 ist,
sin_visible = [False, False, True, False,...]
cos_visible = [False, False, True, False,...]
Durch die Kombination der beiden nach,Ermöglicht beiden cos, die Ablaufverfolgung an Adresse 2 anzuzeigen
"""
for s in range(len(sin_data)):
    # sin_data, cos_Alle Daten einmal ausblenden
    sin_visible, cos_visible = [False] * len(sin_data), [False] * len(cos_data)
    #Machen Sie nur das etw sichtbar
    sin_visible[s], cos_visible[s] = True, True
    step = dict(method="update",
                args=[{"visible": sin_visible + cos_visible},
                      {"title": "Simple slider step: {}".format(s)}]
                )
    steps.append(step)

sliders = [dict(
    active=10,
    currentvalue=dict(prefix="Frequency: "),
    pad=dict(t=50),
    steps=steps)]

layout = go.Layout(
    title="Simple slider step: 10",
    xaxis=dict(title="x"),
    yaxis=dict(title="y"),
    font=dict(family="Meiryo", size=16),
    hovermode='x unified',
    hoverlabel=dict(font_size=16),
    sliders=sliders,
    showlegend=True)

fig = dict(data=data, layout=layout)

offline.plot(fig, include_plotlyjs="cdn", filename="plots.html")

Verschieben Sie einige Grundstücke

Wenn es Dinge gibt, die Sie mit dem Schieberegler verschieben möchten, und Dinge, die Sie nicht im selben Diagramm verschieben möchten

plots2.gif

import numpy as np
import plotly.offline as offline
import plotly.graph_objs as go

data = []
sin_data, cos_data = [], []
x = np.linspace(0, 10, 101)

#Feste Handlung
trace = go.Scatter(
    x=x,
    y=2 * np.cos(x),
    name="2 * cos",
    line=dict(color="green", width=3),
    visible=True, )
data.append(trace)  #Die 0. Daten sind feste Plotinformationen

#Slider-Plot
for step in np.linspace(0, 5, 51):
    y = np.sin(step * x)
    y2 = np.cos(step * x)
    sin_trace = go.Scatter(
        x=x,
        y=y,
        name="sin {:.1f}Hz".format(step),
        line=dict(color="red", width=3),
        visible=False, )

    cos_trace = go.Scatter(
        x=x,
        y=y2,
        name="cos {:.1f}Hz".format(step),
        line=dict(color="blue", width=3),
        visible=False, )

    sin_data.append(sin_trace)
    cos_data.append(cos_trace)

sin_data[10].visible = True
cos_data[10].visible = True

data += sin_data + cos_data
steps = []
"""
Zeigen Sie immer feste Diagramme an, machen Sie sie also immer wahr
    ->0te Daten(Feste Handlung)Um wahr zu sein
"""
for s in range(len(sin_data)):
    sin_visible, cos_visible = [False] * len(sin_data), [False] * len(cos_data)
    sin_visible[s], cos_visible[s] = True, True
    step = dict(method="update",
                args=[{"visible": [True] + sin_visible + cos_visible},  #0 ist immer wahr
                      {"title": "Simple slider step: {}".format(s)}]
                )
    steps.append(step)

sliders = [dict(
    active=10,
    currentvalue=dict(prefix="Frequency: "),
    pad=dict(t=50),
    steps=steps)]

layout = go.Layout(
    title="Simple slider step: 10",
    xaxis=dict(title="x"),
    yaxis=dict(title="y"),
    font=dict(family="Meiryo", size=16),
    hovermode='x unified',
    hoverlabel=dict(font_size=16),
    sliders=sliders,
    showlegend=True)

fig = dict(data=data, layout=layout)

offline.plot(fig, include_plotlyjs="cdn", filename="plot2.html")

Verstecke dich vor der Mitte

Cos verschwindet, wenn der Schieberegler 40 oder mehr erreicht.

plots3.gif

Wenn es 40 oder mehr ist, werden die x- und y-Werte von cos_trace einfach auf None gesetzt.

import numpy as np
import plotly.offline as offline
import plotly.graph_objs as go

x = np.linspace(0, 10, 101)

data = []
sin_data, cos_data = [], []

trace = go.Scatter(
    x=x,
    y=2 * np.cos(x),
    name="2 * cos",
    line=dict(color="green", width=3),
    visible=True, )
data.append(trace)

for step in np.linspace(0, 5, 51):
    y = np.sin(step * x)
    y2 = np.cos(step * x)
    sin_trace = go.Scatter(
        x=x,
        y=y,
        name="sin {:.1f}Hz".format(step),
        line=dict(color="red", width=3),
        visible=False, )

    if step < 4:
        cos_trace = go.Scatter(
            x=x,
            y=y2,
            name="cos {:.1f}Hz".format(step),
            line=dict(color="blue", width=3),
            visible=False, )
    else:
        cos_trace = go.Scatter(x=None, y=None)  #4 oder mehr ist Keine

    sin_data.append(sin_trace)
    cos_data.append(cos_trace)

sin_data[10].visible = True
cos_data[10].visible = True

data += sin_data + cos_data

steps = []
for s in range(len(sin_data)):
    sin_visible, cos_visible = [False] * len(sin_data), [False] * len(cos_data)
    sin_visible[s], cos_visible[s] = True, True
    step = dict(method="update",
                args=[{"visible": [True] + sin_visible + cos_visible},
                      {"title": "Simple slider step: {}".format(s)}]
                )
    steps.append(step)

sliders = [dict(
    active=10,
    currentvalue=dict(prefix="Frequency: "),
    pad=dict(t=50),
    steps=steps)]

layout = go.Layout(
    title="Simple slider step: 10",
    xaxis=dict(title="x"),
    yaxis=dict(title="y"),
    font=dict(family="Meiryo", size=16),
    hovermode='x unified',
    hoverlabel=dict(font_size=16),
    sliders=sliders,
    showlegend=True)

fig = dict(data=data, layout=layout)

offline.plot(fig, include_plotlyjs="cdn", filename="plots3.html")

Referenzseite

Offizielle Seite Plotly Python Graphing Library | Python | Plotly

codepen Überprüfen Sie das Zeichnungsergebnis mit Plotly, indem Sie CodePen in Qiita - Qiita einbetten CodePen kann jetzt in Artikel mit Qiita-Qiita eingebettet werden

Recommended Posts

Plotten Anwenden von Diagrammen mit Schiebereglern
Veröffentlichen Sie schöne Grafiken online mit plotly
Kerzenbeine mit Plot + Jupyter
Überlagern Sie Diagramme mit Sympy
Anwendung von Python 3 vars
Einführung in das Potenzial von Plotlys Streudiagramm anhand praktischer Beispiele
Kerzendiagrammplot mit Plotly
Verwenden Sie Richtungsdiagramme mit networkx
Entwicklung von Webanwendungen mit Flask
WebSocket-Anwendung mit Flask-Socket IO
Echtzeitdiagramm mit Plotly (Python)
Erstellen Sie eine Webanwendung mit Django
Parallele Verarbeitung mit Parallel von Scikit-Learn
Anwendung der CNN2-Bilderkennung
Vorhersage des Nikkei-Durchschnitts mit Pytorch 2
Erinnerungen an den Kampf mit Selen
Vorhersage des Nikkei-Durchschnitts mit Pytorch
Webanwendung mit Python + Flask ② ③
Animieren Sie mehrere Diagramme mit matplotlib
Erstellen Sie eine Rails-Anwendung mit Docker
Webanwendung mit Python + Flask ④
[Verständnis und Anwendung mit Syntax] Flexibles Umschalten des Python-Standardausgabeziels
[Sprechen Sie über die Zeichnungsstruktur von plotly] Dynamische Visualisierung mit plotly [Python]
Führen Sie einen Anwendungstest für Migrationsdateien mit Django + PostgreSQL (Evil Edition) durch.