Fonctions de rappel Dash
Dash permet aux développeurs d'utiliser Python pour créer des interfaces utilisateur dynamiques et réactives.
L'une des fonctionnalités principales de Dash est la fonction de rappel, qui permet à l'interface utilisateur de se mettre à jour en temps réel en fonction des entrées ou des actions de l'utilisateur.
Les fonctions de rappel sont le mécanisme central de Dash pour gérer les interactions utilisateur. Elles vous permettent de mettre à jour dynamiquement la mise en page ou les données de l'application lorsque l'utilisateur interagit avec l'application. En termes simples, une fonction de rappel est une fonction Python qui est déclenchée lorsque des entrées spécifiques changent, et elle met à jour les sorties en fonction des changements de ces entrées.
Une fonction de rappel Dash typique se compose des parties suivantes :
- Entrée: Spécifie quels changements de propriété de composant déclencheront la fonction de rappel.
- Sortie: Spécifie quelles propriétés de composant seront mises à jour après l'exécution de la fonction de rappel.
- État: Paramètre facultatif, utilisé pour transmettre des données qui ne déclenchent pas le rappel mais qui doivent être utilisées dans le rappel.
- Corps de la fonction de rappel: Contient le code logique réel, utilisé pour traiter les entrées et générer les sorties.
Structure de base des fonctions de rappel
@app.callback(
Output(component_id='output-component', component_property='output-property'),
Input(component_id='input-component', component_property='input-property')
)
def update_output(input_value):
# 根据输入值计算输出值
return output_value
Output:Spécifie la cible de sortie de la fonction de rappel.
component_id: L'ID du composant cible.component_property: La propriété du composant cible (par ex.children、valueetc.).
Input:Spécifie la source d'entrée de la fonction de rappel.
component_id: L'ID du composant d'entrée.component_property: La propriété du composant d'entrée (par ex.value、n_clicksetc.).
fonction de rappel:
Reçoit des valeurs d'entrée, calcule et renvoie des valeurs de sortie.
Le nom de la fonction peut être personnalisé (par ex.
update_output)。
Exemple
L'exemple suivant montre comment mettre à jour dynamiquement le contenu textuel en fonction de la valeur d'une zone de saisie :
Exemple
# Créer l'application Dash
app = Dash(__name__)
# Définir la mise en page
app.layout = html.Div([
dcc.Input(id='input', type='text', placeholder='Veuillez saisir le contenu...'),
html.Div(id='output')
])
# Définir la fonction de rappel
@app.callback(
Output('output', 'children'),
Input('input', 'value')
)
def update_output(input_value):
return f'Vous avez saisi : {input_value}'
# Exécuter l'application
if __name__ == '__main__':
app.run_server(debug=True)
L'exemple suivant montre comment mettre à jour dynamiquement un graphique en fonction de la sélection dans un menu déroulant :
Exemple
import plotly.express as px
import pandas as pd
# Créer l'application Dash
app = Dash(__name__)
# Données d'exemple
df = pd.DataFrame({
'city': ['Beijing', 'Shanghai', 'Guangzhou', 'Shenzhen'],
'Population': [2171, 2424, 1490, 1303]
})
# Définir la mise en page
app.layout = html.Div([
dcc.Dropdown(
id='dropdown',
options=[{'label': city, 'value': city} for city in df['city']],
value='Beijing' # Valeur par défaut
),
dcc.Graph(id='graph')
])
# Définir la fonction de rappel
@app.callback(
Output('graph', 'figure'),
Input('dropdown', 'value')
)
def update_graph(selected_city):
filtered_df = df[df['city'] == selected_city]
fig = px.bar(filtered_df, x='city', y='Population', title=f'{selected_city} données de population')
return fig
# Exécuter l'application
if __name__ == '__main__':
app.run_server(debug=True)
Après l'exécution du code ci-dessus, lorsque vous sélectionnez une ville dans le menu déroulant, le graphique se met à jour dynamiquement pour afficher les données de population de cette ville.

Dans l'exemple suivant, après que l'utilisateur a saisi un nombre, le carré de ce nombre s'affiche :
Exemple
# Créer l'application Dash
app = Dash(__name__)
# Définir la mise en page
app.layout = html.Div([
html.H1("Calculer le carré"), # Titre
dcc.Input(
id='number-input', # ID de la zone de saisie
type='number', # Le type de saisie est un nombre
placeholder='Veuillez saisir un nombre...', # Texte indicatif du champ de saisie
value='' # La valeur initiale est vide
),
html.Div(id='output') # Div pour afficher les résultats
])
# Définir la fonction de rappel
@app.callback(
Output('output', 'children'), # Sortie vers la propriété children de la div avec l'id 'output'
Input('number-input', 'value') # l'entrée provient de l'attribut value de l'élément input avec l'id 'number-input'
)
def calculate_square(number):
if number is None or number == '': # Si l'entrée est vide
return 'Veuillez saisir un nombre.'
try:
number = float(number) # Convertir l'entrée en float
square = number ** 2 # Calculer le carré
return f'Le carré de {number} est : {square}' # Renvoyer le résultat
except ValueError: # Si l'entrée n'est pas un nombre
return 'Veuillez saisir un nombre valide.'
# Exécuter l'application
if __name__ == '__main__':
app.run_server(debug=True) # Démarrer l'application, debug=True active le mode débogage
Explication du code :
1. Section de mise en page:
-
Utilisation
html.H1Créez un titre "Calculer le carré". -
Utilisation
dcc.InputCréez une zone de saisie numérique,idestnumber-input, le type estnumber。 -
Utilisation
html.DivCréez une zone pour afficher les résultats,idestoutput。
2. Fonction de rappel:
-
Utilisation
@app.callbackLe décorateur définit la fonction de rappel. -
l'entrée est
number-inputdu champ de saisievaluePropriété. -
la sortie est
outputde la DivchildrenPropriété. -
Dans la fonction de rappel :
-
Vérifiez si l'entrée est vide.
-
Convertissez l'entrée en float et calculez le carré.
-
Retournez le résultat formaté.
-
3. Exécuter l'application: Utilisezapp.run_server(debug=True)Lancez l'application,debug=TrueIndique que le mode débogage est activé. Le résultat d'exécution s'affiche comme suit :

Comment fonctionnent les fonctions de rappel
1. Liaison des entrées et des sorties
Dans Dash, les entrées et les sorties d'une fonction de rappel sont spécifiées viaInputetOutputSpécifié par l'objet.InputL'objet spécifie quels changements de propriété de composant déclencheront la fonction de rappel, tandis queOutputL'objet spécifie quelles propriétés de quels composants seront mises à jour après l'exécution de la fonction de rappel.
2. Déclenchement des fonctions de rappel
Lorsque l'utilisateur effectue une action sur l'interface (par exemple, saisir du texte, cliquer sur un bouton, etc.), les propriétés des composants concernés changent. Dash détecte ces changements et appelle automatiquement la fonction de rappel qui leur est liée.
3. Exécution des fonctions de rappel
Lorsque la fonction de rappel s'exécute, Dash transmet les valeurs actuelles des propriétés d'entrée en tant que paramètres à la fonction de rappel. La fonction de rappel effectue des calculs ou un traitement en fonction de ces valeurs d'entrée et renvoie de nouvelles valeurs pour les propriétés de sortie. Dash met automatiquement à jour les valeurs renvoyées dans les propriétés du composant spécifié.
Utilisation avancée des fonctions de rappel
1. Entrées et sorties multiples
Une fonction de rappel peut avoir plusieurs entrées et sorties. Par exemple :
Exemple
[Output('output-div-1', 'children'),
Output('output-div-2', 'children')],
[Input('input-1', 'value'),
Input('input-2', 'value')]
)
def update_outputs(input1, input2):
return f'Input 1: {input1}', f'Input 2: {input2}'
Dans cet exemple, la fonction de rappelupdate_outputsa deux entrées et deux sorties. Lorsqueinput-1ouinput-2la valeur de ... change, la fonction de rappel est déclenchée, et elle met à jour les ... des deux composants de sortie.childrenPropriété.
2. Utilisation de State
Parfois, vous pouvez avoir besoin d'utiliser des données dans une fonction de rappel qui ne déclenche pas la fonction de rappel. Dans ce cas, vous pouvez utiliserStateObjet.Stateobjet etInputSemblable à l'objet, mais il ne déclenche pas la fonction de rappel.
Exemple
Output('output-div', 'children'),
[Input('submit-button', 'n_clicks')],
[State('input-text', 'value')]
)
def update_output(n_clicks, input_value):
if n_clicks is None:
return 'Pas encore de clics'
return f'Bouton cliqué {n_clicks} fois. Entrée : {input_value}'
Dans cet exemple,n_clicksest l'entrée qui déclenche le rappel, tandis queinput_valueC'est l'état utilisé dans la fonction de rappel. La fonction de rappel ne sera déclenchée que lorsque le bouton sera cliqué, mais la valeur actuelle du champ de saisie peut être utilisée dans la fonction de rappel.
3. Empêcher l'exécution en double des fonctions de rappel
Dans certains cas, les fonctions de rappel peuvent être déclenchées fréquemment, ce qui entraîne des problèmes de performance. Pour éviter cela, vous pouvez utiliserdash.no_updatepour éviter les mises à jour inutiles.
Exemple
Output('output-div', 'children'),
[Input('input-text', 'value')]
)
def update_output(input_value):
if not input_value:
return dash.no_update
return f'You have entered: {input_value}'
Dans cet exemple, si la valeur du champ de saisie est vide, la fonction de rappel ne mettra pas à jour le composant de sortie.
Problèmes courants et solutions
1. Fonction de rappel non déclenchée
Si la fonction de rappel ne se déclenche pas comme prévu, cela peut être dû à l'une des raisons suivantes :
- Incompatibilité d'ID d'entrée ou de sortie: assurez-vous
InputetOutputLes ID des composants dans ... correspondent aux ID dans le layout. - Erreur de nom d'attribut: assurez-vous
InputetOutputAssurez-vous que les noms de propriété dans ... sont corrects. - Fonction de rappel non enregistrée: Assurez-vous que la fonction de rappel est correctement enregistrée dans l'application.
2. Exécution lente de la fonction de rappel
Si la fonction de rappel s'exécute lentement, envisagez les méthodes d'optimisation suivantes :
- Réduisez la charge de calcul de la fonction de rappel: Essayez d'éviter d'effectuer des calculs complexes dans la fonction de rappel.
- Utilisez un cache: Pour des résultats de calcul répétés, la mise en cache peut être utilisée pour réduire le temps de calcul.
- Rappel asynchrone: Pour les tâches de longue durée, des rappels asynchrones peuvent être utilisés pour éviter de bloquer le thread principal.