[PYTHON] Erstellen Sie ein Diagramm mit der Plot-Schaltfläche und dem Schieberegler

Was du machen willst

--Erstellen Sie eine Schaltfläche im Diagramm und drücken Sie die Schaltfläche, um das Layout wie Ein- / Ausblenden von Plot und Titel zu steuern.

button_slider_plotly.gif

Umgebung

pip

python


pip install plotly
pip install numpy

Button Review

button_plotly.gif

python


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

#Holen Sie sich die Linienfarbe
colors = plotly.colors.DEFAULT_PLOTLY_COLORS

x = np.linspace(-5, 5, 11)
data = []
for i in range(1, 4):
    trace = go.Scatter(
        x=x,
        y=x ** i,
        name="y{}".format(i),
        mode="lines",
        line=dict(color=colors[i], width=6),
        visible=False,
        showlegend=True
    )

    data.append(trace)
#Machen Sie den 0. Datenwert als Ausgangszustand sichtbar
data[0].visible = True

"""
Ort der Schaltflächenerstellung
Schlüsselbeschreibung
active:Geben Sie die im Ausgangszustand gedrückte Taste an und geben Sie den Listenindex des Tastenwertes der Tasten ein
type:Dropdown oder Schaltfläche( "dropdown" | "buttons" ), default="dropdown"
buttons:Tasteneinstellungen
"""
buttons = []
for ii in range(len(data)):
    visible = [False] * len(data)  # len(data)=Weil 3, visible=[False, False, False]
    visible[ii] = True  #Setzen Sie nur den iith auf True, ex) [True, False, False]
    button = dict(label=data[ii].name,
                  method="update",  #So aktualisieren Sie das Layout"update"
                  args=[dict(visible=visible),  #Es ist nur die Spur des Teils zu sehen, der auf True gesetzt wurde
                        dict(title="button_plotly_{}".format(data[ii].name),  #Titelaktualisierung
                             yaxis=dict(title="yaxis_{}".format(data[ii].name), showspikes=True))])  #Aktualisierung der y-Achsenbeschriftung
    buttons.append(button)

updatemenus = [dict(active=0, type="buttons", buttons=buttons)]

layout = go.Layout(
    title="button_plotly_y1",
    xaxis=dict(title="xaxis", showspikes=True, domain=[0.05, 1.0]),
    yaxis=dict(title="yaxis_y1", showspikes=True),
    font=dict(size=16),
    updatemenus=updatemenus,
    showlegend=True)

fig = dict(data=data, layout=layout)
offline.plot(fig, auto_open=True, include_plotlyjs="cdn", filename=r"./button_plotly.html")

Unten wird die Schaltfläche erstellt. updatemenus = [dict (aktiv = 0, type =" Tasten "," Tasten "= Tasten)] "Tasten" = Tasten` erstellt Informationen (Ein- / Ausblenden usw.), wenn die Taste gedrückt wird Hier bist du.

button ist eine Liste, die ein Wörterbuch mit Layoutinformationen enthält ( button-Variablen unten).

python


"""
Ort der Schaltflächenerstellung
Schlüsselbeschreibung
active:Geben Sie die im Ausgangszustand gedrückte Taste an und geben Sie den Listenindex des Tastenwertes der Tasten ein
type:Dropdown oder Schaltfläche( "dropdown" | "buttons" ), default="dropdown"
buttons:Tasteneinstellungen
"""
buttons = []
for ii in range(len(data)):
    visible = [False] * len(data)  # len(data)=Weil 3, visible=[False, False, False]
    visible[ii] = True  #Setzen Sie nur den iith auf True, ex) [True, False, False]
    button = dict(label=data[ii].name,
                  method="update",  #So aktualisieren Sie das Layout"update"
                  args=[dict(visible=visible),  #Es ist nur die Spur des Teils zu sehen, der auf True gesetzt wurde
                        dict(title="button_plotly_{}".format(data[ii].name),  #Titelaktualisierung
                             yaxis=dict(title="yaxis_{}".format(data[ii].name), showspikes=True))])  #Aktualisierung der y-Achsenbeschriftung
    buttons.append(button)

updatemenus = [dict(active=0, type="buttons", buttons=buttons)]

Dieses Mal schrieb ich, um den Plot ein- / auszublenden und den Titel und die Beschriftung der y-Achse mit der Schaltfläche zu wechseln.

python


visible=[False] * len(data)
visble[ii] = True

Legt fest, welches Diagramm angezeigt werden soll.

Wenn beispielsweise "data = [trace1, trace2, trace3]" und "visible = [True, False, False]" angezeigt wird, wird nur trace1 angezeigt.

Schließlich können Sie mit "go.Layout (updatemenus = updatemenus)" eine Schaltfläche im Diagramm erstellen.

Einzelheiten Erstellen eines Diagramms mit Plotly Button-Qiita

Überprüfung des Schiebereglers

slider_plotly.gif

python


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,Beide cos sind standardmäßig indexiert=Zeige 10 Spuren
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,cos beide Index=Lassen Sie 2 Spuren anzeigen
"""
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(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")

Ich erstelle unten einen Schieberegler

python


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,cos beide Index=Lassen Sie 2 Spuren anzeigen
"""
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)]

Was Sie tun, unterscheidet sich nicht wesentlich von einer Schaltfläche. Schieberegler = [Diktat (aktiv = 10, aktueller Wert = Diktat (Präfix =" Frequenz: "), Pad = Diktat (t = 50), Schritte = Schritte)] Wenn Schritte = Schritte den Schieberegler bewegt Hier werden die Informationen (Ein- / Ausblenden usw.) erstellt.

"Schritte" ist eine Liste, die ein Wörterbuch mit Layoutinformationen enthält ("Schritt" -Variablen oben).

Schließlich erstellt "go.Layout (Schieberegler = Schieberegler)" einen Schieberegler im Diagramm.

Einzelheiten Anwendung des Diagramms mit dem Plotly-Schieberegler --Qiita

Beispieldiagramm

button_slider_plotly.gif

Mit 3 Tasten

Ändern Sie nach dem Umschalten der Anzeige die Frequenz mit dem Schieberegler für das sichtbare Diagramm.

Erstellen Sie drei Schieberegler, ALL, SIN und COS, und ersetzen Sie die Schieberegler, wenn Sie das Layout mit der Schaltfläche aktualisieren.

python


import copy
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 = {"ALL": [], "SIN": [], "COS": []}
"""
Es gibt insgesamt 4 sichtbare Informationslisten
sin_visible_false:Alle sichtbaren Sündenwellen sind falsch
cos_visible_false:Alle sichtbaren cos-Wellen sind falsch
sin_visible_true:Sinuswellenindex=sichtbar von s ist wahr
cos_visible_true:cos Wellenindex=sichtbar von s ist wahr

Wenn Sie es nicht anzeigen möchten, können Sie es auf False setzen.
sin,sichtbare Informationen bei der Anzeige beider cos: sin_visible_true + cos_visible_true
Sichtbare Informationen, wenn nur Sünde angezeigt wird: sin_visible_true + cos_visible_false
Sichtbare Informationen, wenn nur cos angezeigt wird: sin_visible_false + cos_visible_true
"""
for s in range(len(sin_data)):
    # sin_data, cos_Alle Daten einmal ausblenden
    sin_visible_false, cos_visible_false = [False] * len(sin_data), [False] * len(cos_data)
    # sin_visible_false, cos_visible_Falsche Kopiererstellung, Kopierindex=Richtig für s
    sin_visible_true, cos_visible_true = copy.copy(sin_visible_false), copy.copy(cos_visible_false)
    sin_visible_true[s], cos_visible_true[s] = True, True

    step_all = dict(method="update",
                    args=[{"visible": sin_visible_true + cos_visible_true},
                          {"title": "slider_button_ALL step: {}".format(s)}]
                    )
    step_sin = dict(method="update",
                    args=[{"visible": sin_visible_true + cos_visible_false},
                          {"title": "slider_button_SIN step: {}".format(s)}]
                    )
    
    step_cos = dict(method="update",
                    args=[{"visible": sin_visible_false + cos_visible_true},
                          {"title": "slider_button_COS step: {}".format(s)}]
                    )

    steps["ALL"].append(step_all)
    steps["SIN"].append(step_sin)
    steps["COS"].append(step_cos)

sliders = {}
for key, step in steps.items():
    slider = [dict(active=10, currentvalue=dict(prefix="Frequency: "), pad=dict(t=50), steps=step)]
    sliders[key] = slider

buttons = []
for key, slider in sliders.items():
    slider_active = slider[0]["active"]
    slider_visible = slider[0]["steps"][slider_active]["args"][0]["visible"]
    button = dict(label=key,
                  method="update",
                  args=[dict(visible=slider_visible),
                        dict(title="slider_button_{} step: {}".format(key, slider_active),
                             yaxis=dict(title="y {}".format(key)),
                             sliders=slider)])
    buttons.append(button)

updatemenus = [dict(active=0, type="buttons", buttons=buttons)]

layout = go.Layout(
    title="slider_button_ALL step: 10",
    xaxis=dict(title="x", domain=[0.05, 1]),
    yaxis=dict(title="y ALL"),
    font=dict(size=16),
    hovermode='x unified',
    hoverlabel=dict(font_size=16),
    sliders=sliders["ALL"],
    updatemenus=updatemenus,
    showlegend=True)

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

offline.plot(fig, auto_open=True, include_plotlyjs="cdn", filename=r"./slider_button_plotly.html",
             config={'modeBarButtonsToAdd': ['drawline', 'drawopenpath', 'drawclosedpath', 'drawcircle', 'drawrect',
                                             'eraseshape']})

Ich erstelle eine Plotanzeige, wenn der Schieberegler bewegt wird.

python


steps = {"ALL": [], "SIN": [], "COS": []}
"""
Es gibt insgesamt 4 sichtbare Informationslisten
sin_visible_false:Alle sichtbaren Sündenwellen sind falsch
cos_visible_false:Alle sichtbaren cos-Wellen sind falsch
sin_visible_true:Sinuswellenindex=sichtbar von s ist wahr
cos_visible_true:cos Wellenindex=sichtbar von s ist wahr

Wenn Sie es nicht anzeigen möchten, können Sie es auf False setzen.
sin,sichtbare Informationen bei der Anzeige beider cos: sin_visible_true + cos_visible_true
Sichtbare Informationen, wenn nur Sünde angezeigt wird: sin_visible_true + cos_visible_false
Sichtbare Informationen, wenn nur cos angezeigt wird: sin_visible_false + cos_visible_true
"""
for s in range(len(sin_data)):
    # sin_data, cos_Alle Daten einmal ausblenden
    sin_visible_false, cos_visible_false = [False] * len(sin_data), [False] * len(cos_data)
    # sin_visible_false, cos_visible_Falsche Kopiererstellung, Kopierindex=Richtig für s
    sin_visible_true, cos_visible_true = copy.copy(sin_visible_false), copy.copy(cos_visible_false)
    sin_visible_true[s], cos_visible_true[s] = True, True

    step_all = dict(method="update",
                    args=[{"visible": sin_visible_true + cos_visible_true},
                          {"title": "slider_button_ALL step: {}".format(s)}]
                    )
    step_sin = dict(method="update",
                    args=[{"visible": sin_visible_true + cos_visible_false},
                          {"title": "slider_button_SIN step: {}".format(s)}]
                    )

    step_cos = dict(method="update",
                    args=[{"visible": sin_visible_false + cos_visible_true},
                          {"title": "slider_button_COS step: {}".format(s)}]
                    )

    steps["ALL"].append(step_all)
    steps["SIN"].append(step_sin)
    steps["COS"].append(step_cos)

sliders = {}
for key, step in steps.items():
    slider = [dict(active=10, currentvalue=dict(prefix="Frequency: "), pad=dict(t=50), steps=step)]
    sliders[key] = slider

Der Inhalt der Schieberegler lautet "{" ALL ": Schieberegler bei ALL," SIN ": Schieberegler bei SIN, ...}"

python


buttons = []
for key, slider in sliders.items():
    slider_active = slider[0]["active"]
    slider_visible = slider[0]["steps"][slider_active]["args"][0]["visible"]
    button = dict(label=key,
                  method="update",
                  args=[dict(visible=slider_visible),
                        dict(title="slider_button_{} step: {}".format(key, slider_active),
                             yaxis=dict(title="y {}".format(key)),
                             sliders=slider)])
    buttons.append(button)

updatemenus = [dict(active=0, type="buttons", buttons=buttons)]

Ich erstelle einen Button. slider_visible = slider [0] [" Schritte "] [slider_active] [" Argumente "] [0] [" sichtbar "] erhält die sichtbaren Informationen über die Anfangsposition des Schiebereglers.

Im Fall des obigen Skripts wird die Anfangsposition des Schiebereglers auf 10 gesetzt, sodass die Position des Schiebereglers und der Anzeige nicht übereinstimmen, es sei denn, die Anzeige unmittelbar nach dem Umschalten der Schaltfläche stimmt ebenfalls mit dieser überein.

python


layout = go.Layout(
    title="slider_button_ALL step: 10",
    xaxis=dict(title="x", domain=[0.05, 1]),
    yaxis=dict(title="y ALL"),
    font=dict(size=16),
    hovermode='x unified',
    hoverlabel=dict(font_size=16),
    sliders=sliders["ALL"],
    updatemenus=updatemenus,
    showlegend=True)

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

offline.plot(fig, auto_open=True, include_plotlyjs="cdn", filename=r"./slider_button_plotly.html",
             config={'modeBarButtonsToAdd': ['drawline', 'drawopenpath', 'drawclosedpath', 'drawcircle', 'drawrect',
                                             'eraseshape']})

Das Layout wird festgelegt und ausgegeben. Standardmäßig wird ALL angezeigt.

config = {...} fügt oben rechts eine Zeichenschaltfläche hinzu.

Referenz

offiziell Custom Buttons | Python | Plotly layout.updatemenus | Python | Plotly Plotly Python Graphing Library | Python | Plotly

Recommended Posts

Erstellen Sie ein Diagramm mit der Plot-Schaltfläche und dem Schieberegler
Erstellen Sie mit dem Sympy-Modul ein Diagramm
Plotly Erstellen Sie ein Diagramm mit einer Schaltfläche
Ein Hinweis beim Erstellen eines gerichteten Diagramms mit Graphviz in Python
Die Geschichte des Erstellens einer Datenbank mithilfe der Google Analytics-API
Erstellen einer Webanwendung mit Flask ②
Erstellen einer einfachen Tabelle mit Stettytable
Erstellen einer Webanwendung mit Flask ①
Erstellen eines Lernmodells mit MNIST
Erstellen einer Webanwendung mit Flask ③
Machen Sie eine schöne Grafik mit Plotly
Erstellen einer Webanwendung mit Flask ④
Teilen und Verarbeiten eines Datenrahmens mithilfe der Groupby-Funktion
Berechnen Sie die kürzeste Route eines Diagramms mit der Dyxtra-Methode und Python
Erstellen eines Markierungsblatts mit Python OpenCV (Tipps zum guten Lesen)
So zeichnen Sie ein Diagramm mit Matplotlib
Hinter dem Graph Drawing Algorithmus und Networkx
Erstellen einer Datenanalyseanwendung mit Streamlit
Fügen Sie mithilfe des Keras-Backends eine Ebene hinzu
Ich bekam das Datum von Kagawas Pub-Reis und zeichnete eine Grafik
Erstellen Sie eine REST-API mit dem in Lobe und TensorFlow Serving erlernten Modell.
Verwenden Sie libsixel, um Sixel in Python auszugeben und das Matplotlib-Diagramm an das Terminal auszugeben.
[Python] Ein Programm, das die minimalen und maximalen Werte ohne Verwendung von Methoden findet
Erstellen eines Positionsschätzungsmodells für den Intelligenzwettbewerb menschlicher Wölfe mithilfe von maschinellem Lernen
Holen Sie sich mit Python den Aktienkurs eines japanischen Unternehmens und erstellen Sie eine Grafik
Lösen Sie Rucksackprobleme mit pyomo und glpk
Memo, mit dem ein Diagramm zum Plotten animiert wurde
ffmpeg-Erstellen Sie eine Python-Umgebung und teilen Sie das Video
Schreiben Sie einen TCP-Server mit dem SocketServer-Modul
Erstellen einer interaktiven Anwendung mithilfe eines Themenmodells
Erstellen Sie eine Webmap mit Python und GDAL
Überprüfen von Methoden und Variablen mithilfe der Bibliothek siehe
Beantworten Sie das verkleinerte Bild mit Flask und PILImage
Generieren Sie Hash-Werte mit der HMAC-Methode.
"Erstellen eines Aktienkursdatensatzes" und "Implementieren von AR (1)"
[Bash] Erstellen eines sicheren und vielseitigen temporären Verzeichnisses
Berücksichtigung der Stärken und Schwächen von Python
Erstellen Sie eine GUI auf dem Terminal mit Flüchen
Ich habe versucht, das Update von "Werde ein Romanautor" mit "IFTTT" und "Werde ein Romanautor API" zu benachrichtigen.