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.

  • Nutzungdcc.Locationunddcc.LinkEin Multi-Page-Layout kann implementiert werden.

  • Durch Callback-Funktionen, basierend aufpathnameSeiteninhalte 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.

  • DurchpathnameDie Eigenschaft ermittelt den Pfad der aktuellen Seite.

Nutzungdcc.Link:

  • dcc.LinkDie Komponente wird verwendet, um Seitennavigationslinks zu erstellen.

  • DurchhrefDie Eigenschaft gibt den Pfad der Zielseite an.

Seiteninhalt dynamisch laden:

  • Verwenden Sie Callback-Funktionen, um das entsprechende Seitenlayout dynamisch zurückzugeben, basierend aufpathnamegibt dynamisch das entsprechende Seitenlayout zurück.

Beispiel

from dash import Dash, html, dcc, Eingabe, Ausgabe

# 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

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

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

from dash import Dash, html, dcc, Eingabe, Ausgabe

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

  • Entsprechendpathnamegibt 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ückgebennot_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

from dash import html, dcc

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

from dash import html, dcc

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

@app.callback(
    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
Weitere Erweiterungen