Chose que tu veux faire

--Créez un bouton dans le graphique et appuyez sur le bouton pour utiliser la mise en page comme afficher / masquer le tracé et le titre.

Rendre possible l'utilisation du tracé affiché avec un curseur

environnement

Mac OS
python 3.8.5
plotly 4.12.0

pip

`python`


pip install plotly
pip install numpy

Examen du bouton

`python`


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

#Obtenir la couleur de la ligne
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)
#Rendre le 0ème des données visible comme état initial
data[0].visible = True

"""
Emplacement de création du bouton
Description clé
active:Spécifiez le bouton enfoncé dans l'état initial, entrez l'index de la liste des boutons
type:Liste déroulante ou bouton( "dropdown" | "buttons" ), default="dropdown"
buttons:Paramètres des boutons
"""
buttons = []
for ii in range(len(data)):
    visible = [False] * len(data)  # len(data)=Parce que 3, visible=[False, False, False]
    visible[ii] = True  #Définir uniquement le iith sur True, ex) [True, False, False]
    button = dict(label=data[ii].name,
                  method="update",  #Pour mettre à jour la mise en page"update"
                  args=[dict(visible=visible),  #Seule la trace de la pièce définie sur True peut être vue
                        dict(title="button_plotly_{}".format(data[ii].name),  #mise à jour du titre
                             yaxis=dict(title="yaxis_{}".format(data[ii].name), showspikes=True))])  #mise à jour de l'étiquette de l'axe y
    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")

Vous trouverez ci-dessous l'emplacement de création du bouton. updatemenus = [dict (active = 0, type =" boutons "," boutons "= boutons)] "boutons" = boutons` crée des informations (afficher / masquer, etc.) lorsque le bouton est enfoncé C'est là que vous êtes.

boutons est une liste qui contient un dictionnaire d'informations de mise en page (variables bouton ci-dessous).

`python`


"""
Emplacement de création du bouton
Description clé
active:Spécifiez le bouton enfoncé dans l'état initial, entrez l'index de la liste des boutons
type:Liste déroulante ou bouton( "dropdown" | "buttons" ), default="dropdown"
buttons:Paramètres des boutons
"""
buttons = []
for ii in range(len(data)):
    visible = [False] * len(data)  # len(data)=Parce que 3, visible=[False, False, False]
    visible[ii] = True  #Définir uniquement le iith sur True, ex) [True, False, False]
    button = dict(label=data[ii].name,
                  method="update",  #Pour mettre à jour la mise en page"update"
                  args=[dict(visible=visible),  #Seule la trace de la pièce définie sur True peut être vue
                        dict(title="button_plotly_{}".format(data[ii].name),  #mise à jour du titre
                             yaxis=dict(title="yaxis_{}".format(data[ii].name), showspikes=True))])  #mise à jour de l'étiquette de l'axe y
    buttons.append(button)

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

Cette fois, j'ai écrit pour afficher / masquer le tracé et changer le titre et l'étiquette de l'axe y avec le bouton.

`python`


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

Définit le tracé à afficher.

Par exemple, lorsque data = [trace1, trace2, trace3] et visible = [True, False, False], seule trace1 est affichée.

Enfin, vous pouvez créer un bouton sur le graphique avec go.Layout (updatemenus = updatemenus).

Détails Création d'un graphique avec plotly button-Qiita

Revue du curseur

`python`


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

# sin,Enregistrer les traces d'onde cos séparément
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,Les deux cos sont indexés par défaut=Afficher 10 traces
sin_data[10].visible = True
cos_data[10].visible = True

data = sin_data + cos_data

steps = []
"""
sin_data, cos_Affichage des données/Définir caché séparément, puis combiner et ajouter à la clé visible
Par exemple, lorsque le curseur est 2,
sin_visible = [False, False, True, False,...]
cos_visible = [False, False, True, False,...]
En combinant les deux après,cos les deux index=Autoriser l'affichage de 2 traces
"""
for s in range(len(sin_data)):
    # sin_data, cos_Masquer toutes les données une fois
    sin_visible, cos_visible = [False] * len(sin_data), [False] * len(cos_data)
    #Rendre seulement le qc visible
    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")

Je crée un curseur ci-dessous

`python`


steps = []
"""
sin_data, cos_Affichage des données/Définir caché séparément, puis combiner et ajouter à la clé visible
Par exemple, lorsque le curseur est 2,
sin_visible = [False, False, True, False,...]
cos_visible = [False, False, True, False,...]
En combinant les deux après,cos les deux index=Autoriser l'affichage de 2 traces
"""
for s in range(len(sin_data)):
    # sin_data, cos_Masquer toutes les données une fois
    sin_visible, cos_visible = [False] * len(sin_data), [False] * len(cos_data)
    #Rendre seulement le qc visible
    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)]

Ce que vous faites n'est pas très différent d'un bouton. sliders = [dict (active = 10, currentvalue = dict (prefix =" Frequency: "), pad = dict (t = 50), steps = steps)] quand steps = steps déplace le curseur C'est là que les informations (afficher / masquer, etc.) sont créées.

steps est une liste, qui contient un dictionnaire d'informations de mise en page (variables step ci-dessus).

Enfin, go.Layout (sliders = sliders) crée un curseur sur le graphique.

Détails Application du graphique à l'aide du curseur de tracé --Qiita

Exemple de graphique

Avec 3 boutons

à la fois péché et cos (TOUS) --sin uniquement (SIN) --cos uniquement (COS)

Après avoir changé l'affichage de, modifiez la fréquence avec le curseur du tracé visible.

Créez trois curseurs, ALL, SIN et COS, et remplacez les curseurs lors de la mise à jour de la mise en page avec le bouton.

`python`


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

# sin,Enregistrer les traces d'onde cos séparément
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": []}
"""
Il y a un total de 4 listes d'informations visibles
sin_visible_false:Toutes les ondes de péché visibles sont fausses
cos_visible_false:Toutes les ondes cos visibles sont fausses
sin_visible_true:indice d'onde de péché=visible de s est vrai
cos_visible_true:indice d'onde cos=visible de s est vrai

Si vous ne souhaitez pas l'afficher, vous pouvez le définir sur False.
sin,informations visibles lors de l'affichage des deux cos: sin_visible_true + cos_visible_true
Informations visibles lors de l'affichage uniquement du péché: sin_visible_true + cos_visible_false
Informations visibles lors de l'affichage uniquement de cos: sin_visible_false + cos_visible_true
"""
for s in range(len(sin_data)):
    # sin_data, cos_Masquer toutes les données une fois
    sin_visible_false, cos_visible_false = [False] * len(sin_data), [False] * len(cos_data)
    # sin_visible_false, cos_visible_Création de fausses copies, copie d'index=Vrai pour 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']})

Je crée un affichage de tracé lorsque le curseur est déplacé.

`python`


steps = {"ALL": [], "SIN": [], "COS": []}
"""
Il y a un total de 4 listes d'informations visibles
sin_visible_false:Toutes les ondes de péché visibles sont fausses
cos_visible_false:Toutes les ondes cos visibles sont fausses
sin_visible_true:indice d'onde de péché=visible de s est vrai
cos_visible_true:indice d'onde cos=visible de s est vrai

Si vous ne souhaitez pas l'afficher, vous pouvez le définir sur False.
sin,informations visibles lors de l'affichage des deux cos: sin_visible_true + cos_visible_true
Informations visibles lors de l'affichage uniquement du péché: sin_visible_true + cos_visible_false
Informations visibles lors de l'affichage uniquement de cos: sin_visible_false + cos_visible_true
"""
for s in range(len(sin_data)):
    # sin_data, cos_Masquer toutes les données une fois
    sin_visible_false, cos_visible_false = [False] * len(sin_data), [False] * len(cos_data)
    # sin_visible_false, cos_visible_Création de fausses copies, copie d'index=Vrai pour 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

Le contenu des curseurs est {" ALL ": slider quand ALL," SIN ": slider quand 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)]

Je crée un bouton. slider_visible = slider [0] [" steps "] [slider_active] [" args "] [0] [" visible "] obtient les informations visibles de la position initiale du curseur.

Dans le cas du script ci-dessus, la position initiale du curseur est définie sur 10, de sorte que la position du curseur et l'affichage ne correspondent pas à moins que l'affichage immédiatement après la commutation du bouton ne corresponde également à celui-ci.

`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']})

La mise en page est décidée et sortie. La valeur par défaut est d'afficher TOUS.

config = {...} ajoute un bouton de dessin en haut à droite.

référence

Créez un graphique à l'aide du bouton et du curseur de l'intrigue

Chose que tu veux faire

environnement

python

Examen du bouton

python

python

python

Revue du curseur

python

python

Exemple de graphique

python

python

python

python

référence

`python`

`python`

`python`

`python`

`python`

`python`

`python`

`python`

`python`

`python`