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.

  • Utilisationdcc.Locationetdcc.LinkUne mise en page multipage peut être implémentée.

  • Grâce aux fonctions de rappel, en fonction depathnamecharger 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.

  • ViapathnameLa 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.

  • ViahrefLa 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 depathnamerenvoie dynamiquement la mise en page correspondante.

Exemple

from dash import Dash, html, dcc, Input, Output

# 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

index_page = html.Div([
    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

@app.callback(Output('page-content', 'children'),
              [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

from dash import Dash, html, dcc, Input, Output

# 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:

  • Selonpathnamerenvoie 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, renvoyernot_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

from dash import html, dcc

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

from dash import html, dcc

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

@app.callback(
    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
autres extensions