Dash-Layout für mehrere Seiten
In der modernen Webanwendungsentwicklung sind Single-Page-Anwendungen (SPA) und Multi-Page-Anwendungen (MPA) zwei gängige Architekturmuster.
Single-Page-Anwendungen bieten in der Regel eine reibungslose Benutzererfahrung durch dynamisches Laden von Inhalten, während Multi-Page-Anwendungen Inhalte über mehrere unabhängige Seiten organisieren.
Single-Page-Anwendung vs. Multi-Page-Anwendung
In Single-Page-Anwendungen werden alle Inhalte dynamisch auf einer einzigen Seite geladen und aktualisiert, und Benutzer wechseln zwischen verschiedenen Ansichten, indem sie auf Links oder Schaltflächen klicken. Der Vorteil dieser Architektur ist eine reibungslose Benutzererfahrung und schnelles Laden der Seiten, aber der Nachteil ist, dass die Codestruktur mit wachsendem Umfang der Anwendung komplex werden kann.
Multi-Page-Anwendungen organisieren Inhalte über mehrere unabhängige Seiten, jede mit eigener URL und eigenem Layout. Der Vorteil dieser Architektur ist eine klare Codestruktur und einfache Wartung, aber der Nachteil ist, dass es beim Wechseln zwischen Seiten eine gewisse Ladeverzögerung gibt.
Implementierung des Dash-Multi-Page-Layouts
Ein mehrseitiges Layout in Dash kann mit den Komponenten dcc.Location und dcc.Link implementiert werden.
dcc.Location wird verwendet, um die aktuelle Seiten-URL zu verfolgen, während dcc.Link für die Navigation zwischen Seiten verwendet wird. Durch die Kombination von Callback-Funktionen können abhängig von der URL unterschiedliche Seiteninhalte dynamisch geladen werden.
Nutzung
dcc.Locationunddcc.LinkEin Multi-Page-Layout kann implementiert werden.Durch Callback-Funktionen, basierend auf
pathnameSeiteninhalte dynamisch laden.Durch die Kombination modularer Layouts und URL-Parameter können komplexere Multi-Page-Anwendungen erstellt werden.
Grundstruktur eines Multi-Page-Layouts
Die Kernidee eines Multi-Page-Layouts besteht darin, abhängig vom URL-Pfadnamen dynamisch unterschiedliche Seiteninhalte zu laden.
Im Folgenden sind die grundlegenden Schritte zur Implementierung eines Multi-Page-Layouts aufgeführt:
Seitenlayout definieren:
-
Das Layout jeder Seite kann als Funktion oder Variable definiert werden.
-
Zum Beispiel,
home_layoutStellt die Startseite dar,about_layoutStellt die About-Seite dar.
Nutzungdcc.Location:
-
dcc.LocationDie Komponente wird verwendet, um die URL der aktuellen Seite zu verfolgen. -
Durch
pathnameDie Eigenschaft ermittelt den Pfad der aktuellen Seite.
Nutzungdcc.Link:
-
dcc.LinkDie Komponente wird verwendet, um Seitennavigationslinks zu erstellen. -
Durch
hrefDie Eigenschaft gibt den Pfad der Zielseite an.
Seiteninhalt dynamisch laden:
-
Verwenden Sie Callback-Funktionen, um das entsprechende Seitenlayout dynamisch zurückzugeben, basierend auf
pathnamegibt dynamisch das entsprechende Seitenlayout zurück.
Beispiel
# Dash-App erstellen
app = Dash(__name__)
app.layout = html.Div([
dcc.Location(id='url', refresh=False),
html.Div(id='page-content')
])
Im obigen Code,dcc.Locationder KomponenteidSetzen aufurl,refreshParameter gesetzt aufFalseDies zeigt an, dass die Seite nicht neu geladen wird, wenn sich die URL ändert.html.Div(id='page-content')Es ist ein Platzhalter, der verwendet wird, um den Inhalt verschiedener Seiten anzuzeigen.
Seitenlayout definieren
Als Nächstes müssen wir die Layouts der verschiedenen Seiten definieren. Jedes Seitenlayout kann eine unabhängige Funktion oder Variable sein. Zum Beispiel können wir zwei Seitenlayouts definieren:index_pageundpage1。
Beispiel
html.H1("Startseite"),
dcc.Link('Zu Seite 1', href='/page1')
])
page1 = html.Div([
html.H1("Seite 1"),
dcc.Link('Zurück zur Startseite', href='/')
])
Im obigen Code,index_pageist das Layout der Startseite und enthält einen Titel und einen Link; durch Klicken auf den Link navigiert man zupage1。page1ist das Layout von Seite 1 und enthält ebenfalls einen Titel und einen Link zurück zur Startseite.
Seitenlayout dynamisch laden
Schließlich müssen wir eine Callback-Funktion verwenden, um verschiedene Seitenlayouts basierend auf URL-Änderungen dynamisch zu laden. Die Callback-Funktion bestimmt anhand desdcc.Locationder KomponentepathnameAttributs, welches Seitenlayout angezeigt werden soll.
Beispiel
[Input('url', 'pathname')])
def display_page(pathname):
if pathname == '/page1':
return page1
else:
return index_page
Im obigen Code,display_pageDie Funktion empfängtpathnameals Eingabe und basierend aufpathnamegibt das entsprechende Seitenlayout zurück. WennpathnameJa/page1, dann wird zurückgegebenpage1Layout; andernfalls returnindex_pagedas Layout.
Vollständiges Beispiel
Das Folgende ist ein vollständiges Dash-Beispiel für ein mehrseitiges Layout, einschließlich einer Startseite, einer About-Seite und einer 404-Seite.
Beispiel
# Dash-App erstellen
app = Dash(__name__)
# Layout der Startseite definieren
home_layout = html.Div([
html.H1("Startseite"),
html.P("Willkommen auf der Startseite!"),
dcc.Link(Zur Über-Seite gehen, href='/about')
])
# Layout der Über-Seite definieren
about_layout = html.Div([
html.H1("Über-Seite"),
html.P(Dies ist der Inhalt der Über-Seite.),
dcc.Link(Zurück zur Startseite, href='/')
])
# 404-Seiten-Layout definieren
not_found_layout = html.Div([
html.H1("Seite nicht gefunden"),
html.P(Die Seite, die Sie angefordert haben, existiert nicht.),
dcc.Link(Zurück zur Startseite, href='/')
])
# Anwendungslayout definieren
app.layout = html.Div([
dcc.Location(id='url', refresh=False), # Wird für die Seite verwendet
html.Div(id='page-content') # Wird verwendet, um den Seiteninhalt dynamisch zu laden
])
# Die Callback-Funktion definieren
@app.callback(
Output('page-content', 'children'), # Ausgabe an die children-Eigenschaft des Div mit der id 'page-content'
Input('url', 'pathname') # Eingabe kommt von id 'url' der pathname-Eigenschaft der Location-Komponente
)
def display_page(pathname):
if pathname == '/':
return home_layout # Startseite anzeigen
elif pathname == '/about':
return about_layout # About-Seite anzeigen
else:
return not_found_layout # 404-Seite anzeigen
# Die App ausführen
if __name__ == '__main__':
app.run_server(debug=True)
Nach dem Ausführen der Anwendung besuchen Siehttp://127.0.0.1:8050/Sie können den Inhalt der Startseite sehen, klicken Sie auf"Zur About-Seite"Der Link kann zur About-Seite navigieren; durch Klicken auf"Zurück zur Startseite"kann der Link zur Startseite zurückkehren.

Code-Erklärung
Seitenlayout:
-
home_layout: Layout der Startseite mit einem Titel, einer Beschreibung und einem Link zur About-Seite. -
about_layout: Layout der Über-uns-Seite mit einem Titel, einer Beschreibung und einem Link zur Startseite. -
not_found_layout: Layout der 404-Seite, das verwendet wird, um nicht vorhandene Pfade zu behandeln.
dcc.Location:
-
id='url': Wird verwendet, um die URL der aktuellen Seite zu verfolgen. -
refresh=False: Deaktiviert das Neuladen der Seite, um den Effekt einer Single-Page-Anwendung (SPA) zu erzielen.
dcc.Link:
-
wird verwendet, um Links für die Seitennavigation zu erstellen,
hrefDie Eigenschaft gibt den Pfad der Zielseite an.
Callback-Funktion:
-
Entsprechend
pathnamegibt abhängig vom Wert dynamisch das entsprechende Seitenlayout zurück. -
Wenn der Pfad
/, zurückgebenhome_layout。 -
Wenn der Pfad
/about, zurückgebenabout_layout。 -
Wenn der Pfad nicht übereinstimmt, zurückgeben
not_found_layout。
Erweiterungen
Bei komplexeren Multi-Page-Anwendungen können die folgenden Methoden kombiniert werden, um die Codestruktur zu optimieren:
1. Modulares Layout verwenden
Definiere das Layout jeder Seite in einem separaten Modul, um Wartung und Erweiterung zu erleichtern.
Erstellen Sie pages/home.py:
Beispiel
layout = html.Div([
html.H1("Startseite"),
html.P("Willkommen auf der Startseite!"),
dcc.Link(Zur Über-Seite gehen, href='/about')
])
Erstellen Sie pages/about.py:
Beispiel
layout = html.Div([
html.H1("Über-Seite"),
html.P(Dies ist der Inhalt der Über-Seite.),
dcc.Link(Zurück zur Startseite, href='/')
])
Importieren Sie das Layout in der Hauptanwendung:
from pages.home import layout as home_layout from pages.about import layout as about_layout
2. URL-Parameter verwenden
Übergeben Sie URL-Parameter über die Eigenschaft `search` oder `pathname` von `dcc.Location`, um eine flexiblere Seitenlogik zu implementieren.
Beispiel
Output('page-content', 'children'),
Input('url', 'pathname')
)
def display_page(pathname):
if pathname == '/':
return home_layout
elif pathname.startswith('/about'):
# URL-Parameter parsen
return about_layout
else:
return not_found_layout