Mise en page multipage Dash
Dans le développement moderne d'applications web, les applications monopages (SPA) et les applications multipages (MPA) sont deux modèles architecturaux courants.
Les applications monopages offrent généralement une expérience utilisateur fluide en chargeant dynamiquement le contenu, tandis que les applications multipages organisent le contenu à travers plusieurs pages indépendantes.
Application monopage vs application multipage
Dans les applications monopages, tout le contenu est chargé et mis à jour dynamiquement sur une seule page, et les utilisateurs passent d'une vue à l'autre en cliquant sur des liens ou des boutons. L'avantage de cette architecture est une expérience utilisateur fluide et un chargement rapide des pages, mais l'inconvénient est que, à mesure que l'échelle de l'application augmente, la structure du code peut devenir complexe.
Les applications multipages organisent le contenu à travers plusieurs pages indépendantes, chacune ayant sa propre URL et sa propre mise en page. L'avantage de cette architecture est une structure de code claire et une maintenance facile, mais l'inconvénient est qu'il y a un certain délai de chargement lors du changement de page.
Implémentation d'une mise en page multipage Dash
L'implémentation d'une mise en page multipage dans Dash peut être réalisée à l'aide des composants dcc.Location et dcc.Link.
dcc.Location sert à suivre l'URL de la page actuelle, tandis que dcc.Link sert à la navigation entre les pages. En combinant des fonctions de rappel, différents contenus de page peuvent être chargés dynamiquement en fonction de l'URL.
Utilisation
dcc.Locationetdcc.LinkUne mise en page multipage peut être implémentée.Grâce aux fonctions de rappel, en fonction de
pathnamecharger dynamiquement le contenu de la page.En combinant des mises en page modulaires et des paramètres d'URL, des applications multipages plus complexes peuvent être construites.
Structure de base d'une mise en page multipage
L'idée centrale d'une mise en page multipage est de charger dynamiquement différents contenus de page en fonction du chemin d'URL.
Voici les étapes de base pour implémenter une mise en page multipage :
Définir la mise en page:
-
La mise en page de chaque page peut être définie comme une fonction ou une variable.
-
Par exemple,
home_layoutReprésente la page d'accueil,about_layoutReprésente la page À propos.
Utilisationdcc.Location:
-
dcc.LocationLe composant est utilisé pour suivre l'URL de la page actuelle. -
Via
pathnameLa propriété récupère le chemin de la page actuelle.
Utilisationdcc.Link:
-
dcc.LinkLe composant est utilisé pour créer des liens de navigation entre les pages. -
Via
hrefLa propriété spécifie le chemin de la page cible.
Charger dynamiquement le contenu de la page:
-
Utiliser des fonctions de rappel pour renvoyer dynamiquement la mise en page correspondante en fonction de
pathnamerenvoie dynamiquement la mise en page correspondante.
Exemple
# Créer l'application Dash
app = Dash(__name__)
app.layout = html.Div([
dcc.Location(id='url', refresh=False),
html.Div(id='page-content')
])
Dans le code ci-dessus,dcc.Locationdu composantidDéfini àurl,refreshParamètre défini surFalseIndiquant que la page ne s'actualise pas lorsque l'URL change.html.Div(id='page-content')Il s'agit d'un espace réservé utilisé pour afficher le contenu des différentes pages.
Définir la mise en page
Ensuite, nous devons définir les mises en page des différentes pages. Chaque mise en page peut être une fonction ou une variable indépendante. Par exemple, nous pouvons définir deux mises en page :index_pageetpage1。
Exemple
html.H1("Accueil"),
dcc.Link('Aller à la page 1', href='/page1')
])
page1 = html.Div([
html.H1("Page 1"),
dcc.Link('Retour à l’accueil', href='/')
])
Dans le code ci-dessus,index_pageest la mise en page de la page d’accueil, contenant un titre et un lien ; cliquer sur le lien permet de naviguer verspage1。page1est la mise en page de la page 1, contenant également un titre et un lien de retour vers la page d’accueil.
Chargement dynamique de la mise en page
Enfin, nous devons utiliser une fonction de rappel pour charger dynamiquement différentes mises en page en fonction des changements d’URL. La fonction de rappel détermine en fonction de l’dcc.Locationdu composantpathnameattribut quelle mise en page afficher.
Exemple
[Input('url', 'pathname')])
def display_page(pathname):
if pathname == '/page1':
return page1
else:
return index_page
Dans le code ci-dessus,display_pageLa fonction reçoitpathnameen entrée, et en fonction depathnamerenvoie la mise en page correspondante. SipathnameOui/page1, alors renvoiepage1mise en page ; sinon, renvoieindex_pagela mise en page.
Exemple complet
Voici un exemple complet de mise en page multi-pages Dash, comprenant une page d'accueil, une page à propos et une page 404.
Exemple
# Créer l'application Dash
app = Dash(__name__)
# Définir la mise en page de la page d'accueil
home_layout = html.Div([
html.H1("Accueil"),
html.P("Bienvenue sur la page d'accueil !"),
dcc.Link(Aller à la page À propos, href='/about')
])
# Définir la mise en page de la page À propos
about_layout = html.Div([
html.H1("Page À propos"),
html.P(Ceci est le contenu de la page À propos.),
dcc.Link('Retour à la page d'accueil', href='/')
])
# Définir la mise en page 404
not_found_layout = html.Div([
html.H1("404 - Page introuvable"),
html.P(La page que vous avez visitée n'existe pas.),
dcc.Link('Retour à la page d'accueil', href='/')
])
# Définir la mise en page de l'application
app.layout = html.Div([
dcc.Location(id='url', refresh=False), # Utilisé pour suivre l'URL
html.Div(id='page-content') # Utilisé pour charger dynamiquement le contenu de la page
])
# Définir la fonction de rappel
@app.callback(
Output('page-content', 'children'), # Sortie vers la propriété children du Div avec l'id 'page-content'
Input('url', 'pathname') # Entrée provenant de la propriété pathname du composant Location avec l'id 'url'
)
def display_page(pathname):
if pathname == '/':
return home_layout # Afficher la page d'accueil
elif pathname == '/about':
return about_layout # Afficher la page À propos
else:
return not_found_layout # Afficher la page 404
# Exécuter l'application
if __name__ == '__main__':
app.run_server(debug=True)
Après avoir exécuté l'application, visitezhttp://127.0.0.1:8050/Vous pouvez voir le contenu de la page d'accueil, cliquez sur"Aller à la page À propos"Le lien peut naviguer vers la page À propos ; cliquez sur"Retour à l'accueil"Le lien peut revenir à la page d'accueil.

Explication du code
Mise en page:
-
home_layout: Disposition de la page d'accueil, contenant un titre, une description et un lien vers la page À propos. -
about_layout: Mise en page de la page about, contenant un titre, une description et un lien vers la page d'accueil. -
not_found_layout: Mise en page de la page 404, utilisée pour gérer les chemins inexistants.
dcc.Location:
-
id='url': Utilisé pour suivre l'URL de la page actuelle. -
refresh=False: Désactive l'actualisation de la page pour obtenir l'effet d'application monopage (SPA).
dcc.Link:
-
est utilisé pour créer des liens de navigation entre les pages,
hrefLa propriété spécifie le chemin de la page cible.
fonction de rappel:
-
Selon
pathnamerenvoie dynamiquement la mise en page correspondante en fonction de la valeur. -
Si le chemin est
/, retournehome_layout。 -
Si le chemin est
/about, retourneabout_layout。 -
Si le chemin ne correspond pas, renvoyer
not_found_layout。
Extensions
Pour les applications multipages plus complexes, les méthodes suivantes peuvent être combinées pour optimiser la structure du code :
1. Utiliser une mise en page modulaire
Définir la mise en page de chaque page dans un module séparé pour faciliter la maintenance et l'extension.
Créer pages/home.py:
Exemple
layout = html.Div([
html.H1("Accueil"),
html.P("Bienvenue sur la page d'accueil !"),
dcc.Link(Aller à la page À propos, href='/about')
])
Créer pages/about.py:
Exemple
layout = html.Div([
html.H1("Page À propos"),
html.P(Ceci est le contenu de la page À propos.),
dcc.Link('Retour à la page d'accueil', href='/')
])
Importer la mise en page dans l'application principale :
from pages.home import layout as home_layout from pages.about import layout as about_layout
2. Utiliser les paramètres d'URL
Transmettez les paramètres d'URL via la propriété `search` ou `pathname` de `dcc.Location` pour implémenter une logique de page plus flexible.
Exemple
Output('page-content', 'children'),
Input('url', 'pathname')
)
def display_page(pathname):
if pathname == '/':
return home_layout
elif pathname.startswith('/about'):
# Analyser les paramètres d'URL
return about_layout
else:
return not_found_layout