Ein Leitfaden zur Paginierung in Django

Die Paginierung verbessert das Benutzererlebnis und die Anwendungsleistung beim Umgang mit großen Datenmengen. Ohne ein vorhandenes Paginierungssystem kommt es in Ihrer Anwendung die meiste Zeit zu Verzögerungen. Mit Django können Sie die integrierte Unterstützung für Paginierung nutzen, um Ihre Webanwendung zu paginieren.

So funktioniert die Paginierung in Django

Die Implementierung der Paginierung in Django kann unterschiedlich sein, je nachdem, ob Sie mit klassenbasierten oder funktionsbasierten Ansichten arbeiten. Unabhängig von Ihrer bevorzugten Methode bleiben die zugrunde liegenden Prinzipien dieselben.

Django verwendet eine Klasse namens Paginator Paginierung implementieren. Der Paginator Die Klasse stellt mehrere Methoden bereit, mit denen Sie Ihre Paginierung anpassen können. Bei der Initialisierung des Paginator

Klasse benötigt es zwei obligatorische Parameter; die zu paginierenden Daten und die Anzahl der pro Seite anzuzeigenden Elemente. Der Paginator Nimmt einen dritten optionalen Parameter für Waisen auf, um die Mindestanzahl an Elementen anzugeben, die auf der letzten Seite verbleiben sollen. Standardmäßig ist der Wert für Waisen 0, was bedeutet, dass alle Seiten die gleiche Anzahl an Elementen haben.

Die URL für eine Django-Paginierungsseite sieht etwa so aus: https://example.com/products/?page=3. Der Buchseite Der Parameter in der URL teilt Django mit, welche Seite der Benutzer sehen möchte. Es hilft Django auch dabei, zu bestimmen, welcher Teil der Daten für diese Seite angezeigt werden soll.

Der in diesem Projekt verwendete Code ist in a verfügbar GitHub-Repository Die Nutzung steht Ihnen unter der MIT-Lizenz kostenlos zur Verfügung.

Richten Sie Ihr Django-Projekt für die Paginierung ein

Bevor Sie in Django paginieren, müssen Sie Folgendes tun Django installiert und auf Ihrem Computer eingerichtet. Nachdem Sie Django auf Ihrem Computer eingerichtet haben, sollten Sie eine App und ein Modell für Ihre Daten erstellen. Hier ist ein einfaches Modell, das Sie kopieren können:

aus django.db importieren Modelle
KlassePost(Modelle. Modell):
 Titel = Modelle. CharField (max_length=255)
 Autor = Modelle. CharField (max_length=50)
 Inhalt = Modelle. Textfeld(„Inhalt veröffentlichen“)
def__str__(selbst):
zurückkehren Selbsttitel

Das obige Modell ist für eine Blog-Anwendung. Es definiert die Titel-, Autor- und Inhaltsfelder für jeden Blog-Beitrag. Es verfügt außerdem über eine Methode, die den Beitragstitel zurückgibt, um die Benutzererfahrung im Admin-Bereich zu verbessern.

Migrieren Sie Ihr Modell, indem Sie diesen Befehl ausführen:

python manage.py makemigrations && python manage.py migrate

Nach der Migration Ihres Modells sollten Sie zu navigieren blog>admin.py um es zu registrieren. Der folgende Code registriert erfolgreich ein Modell namens Post.

aus django.contrib importieren Administrator
aus .Modelle importieren Post # Ersetzen Sie „Post“ durch Ihren Modellnamen
admin.site.register (Beitrag)

Erstellen Sie als Nächstes einen Superuser und fügen Sie Beiträge in Ihrem Django-Administrationsbereich hinzu. Um einen Superuser zu erstellen, verwenden Sie diesen Befehl:

python manage.py createsuperuser

Der obige Befehl führt Sie durch den im Bild unten dargestellten Prozess:

Nachdem Sie einen Superuser erstellt haben, führen Sie Ihren Entwicklungsserver aus und navigieren Sie zum Admin-Bereich.

python manage.py runserver

Navigieren Sie nach dem Start Ihres Servers zu http://127.0.0.1:8000/admin, melden Sie sich an und fügen Sie ein paar Beiträge hinzu.

Erstellen Sie als Nächstes eine HTML-Vorlage, um Ihre Beiträge im Browser darzustellen. Erstellen Sie Ihre Datei im folgenden Verzeichnis: your_app/templates/your_app_name/index.html. Wenn Sie nicht wissen, wie man Vorlagen erstellt, lesen Sie unsere Einführungsleitfaden zur MVT-Architektur von Django.

Django-Paginierung in einer funktionsbasierten Ansicht

Mit Django können Sie Anwendungen entweder mit klassenbasierten Ansichten oder mit funktionsbasierten Ansichten erstellen. Um Ihre Anwendung mithilfe einer funktionsbasierten Ansicht zu paginieren. Folge diesen Schritten:

• Öffne dein Ansichten.py Datei und importieren Sie die Paginator Klasse.

aus django.core.paginator importieren Paginator

• Erstellen Sie eine Ansichtsfunktion, um Beiträge in Ihrer HTML-Vorlage darzustellen.

aus django.shortcuts importieren machen
aus .Modelle importieren Post
aus django.core.paginator importieren Paginator
defListenansicht(Anfrage):
 Beiträge = Post.objects.all()
zurückkehren rendern (Anfrage, 'blog/blog_list_view.html', {'Beiträge':beiträge})

• Erstellen Sie ein URL-Muster, um Ihre Beiträge im Browser anzuzeigen. Beginnen Sie mit der Konfiguration des URL-Musters in Ihrem Projektverzeichnis. Öffne das urls.py Datei auf Projektebene und fügen Sie diese der hinzu URL-Muster:

aus django.urls importieren enthalten
URL-Muster = [
 ...,
 Weg('', enthalten('blog.urls')),
]

Ersetzen Sie im obigen Codeausschnitt Blog mit dem Namen Ihrer App. Wenn Sie nicht zwischen einem Projekt und einer App unterscheiden können, sollten Sie es wissen wie sich ein Projekt von einer App in Django unterscheidet.

Nachdem Sie die obige Konfiguration durchgeführt haben, erstellen Sie eine urls.py Datei in Ihrem App-Verzeichnis (in diesem Fall ist es die Blog Ordner) und fügen Sie diesen Codeausschnitt hinzu:

aus django.urls importieren Weg
aus .Ansichten importieren Listenansicht
URL-Muster = [
 Weg('', list_view, name='Listenansicht'),
]

Wenn Sie Ihren Server ausführen und zu navigieren http://127.0.0.1:8000/, zeigt der Browser Ihre Beiträge gemäß Ihrem angegebenen Stylesheet an.

• Ändern Sie Ihre Ansichtsfunktion, um Paginierungslogik hinzuzufügen. Hier ist ein Beispiel:

defListenansicht(Anfrage):
 Beiträge = Post.objects.all()
 paginated = Paginator (Beiträge, 3)
 Seitennummer = Anfrage. GET.get('Buchseite') #Erhalten Sie die angeforderte Seitenzahl von der URL

 page = paginated.get_page (page_number)
zurückkehren rendern (Anfrage, 'blog/blog_list_view.html', {'Buchseite':Buchseite})

Der obige Codeausschnitt führt drei neue Variablen ein: paginiert, Seitennummer, Und Buchseite. Jede Variable bewirkt Folgendes:

1. Der paginiert Variable initialisierte die Paginator Klasse. In diesem Szenario handelt es sich bei den zu paginierenden Daten um den Abfragesatz. Beiträge, und es dauert 3 als Anzahl der pro Seite anzuzeigenden Elemente.
2. Der Seitennummer Die Variable ruft die Seitenzahl aus der URL ab. Zum Beispiel in http://127.0.0.1:8000/?page=2, die Seitenzahl ist 2.
3. Der Buchseite Die Variable ruft die spezifische Seite ab, die gerendert werden soll paginiert Variable.

Inzwischen muss Django Ihre Seite paginiert haben. Sie können zu bestimmten paginierten Seiten navigieren, indem Sie das in diesem Bild gezeigte URL-Format verwenden:

• Ändern Sie Ihre HTML-Vorlage, um die Navigation für paginierte Seiten anzuzeigen. Mit den verfügbaren Methoden Paginator Mit der Klasse können Sie eine einfache Navigation auf Ihrer Seite erstellen. Hier ist ein Beispiel, das Sie unterhalb Ihres ursprünglichen HTML-Codes hinzufügen können:

 {% if page.has_ previous %}
<Ahref="?page={{page. previous_page_number}}"
 class="btn btn-secondary mx-NN">ZurückA>
 {% endif %}
<Ahref=„?page=1“Klasse=„btn btn-secondary“>ErsteA>
 {% für Anzahl in page.paginator.page_range %}
 {% if num == page.number %}
<Spanne>{{ num }}Spanne>
 {% anders %}
<Ahref=„?page={{num}}“Klasse=„btn btn-secondary mx-2“>
 {{ num }}
A>
 {% endif %}
 {% endfor %}
<Ahref=„?page={{page.paginator.num_pages}}“Klasse=„btn btn-secondary mx-2“>
 Zuletzt
A>
 {% if page.has_next %}
<Ahref="?page={{page.next_page_number}}"Klasse=„btn btn-secondary mx-2“>
 Nächste
A>
 {% endif %}

Im obigen Codeausschnitt werden die folgenden Methoden in Verbindung mit bedingten Anweisungen verwendet, um zu bestimmen, wie die Paginierungsnavigation aussehen wird:

1. has_ previous: Diese Methode gibt zurück WAHR wenn es in den paginierten Daten eine vorherige Seite gibt.
2. previous_page_number: Diese Methode gibt den Wert der vorherigen Seite zurück.
3. SeitenReichweite: Mit dieser Methode erfahren Sie, wie viele Seiten Ihre paginierten Daten enthalten.
4. Nummer: Diese Methode gibt den Wert der aktuellen Seite zurück.
5. Anzahl_Seiten: Diese Methode gibt die Gesamtzahl der Seiten zurück.
6. has_next: Diese Funktion gibt zurück WAHR wenn es in den paginierten Daten eine nächste Seite gibt.
7. next_page_number: Diese Methode gibt den Wert der nächsten Seite zurück.

Django-Paginierung in einer klassenbasierten Ansicht

In einer klassenbasierten Ansicht müssen Sie die nicht importieren und initialisieren Paginator Klasse. Um die Paginierung in einer klassenbasierten Ansicht zu implementieren, sollten Sie ein Attribut namens angeben paginate_by. Befolgen Sie diese Schritte, um Ihre App mit einer klassenbasierten Ansicht zu paginieren:

• Schreiben Sie eine klassenbasierte Ansicht und geben Sie die an paginate_by Attribut. Hier ist ein einfaches Beispiel:

aus .Modelle importieren Post
aus django.views.generic importieren Listenansicht
KlassePostListView(Listenansicht):
 Modell = Beitrag
 template_name = 'blog/blog_list_view.html'
 context_object_name = 'Buchseite'
 paginate_by = 2

Die obige Ansicht ist die klassenbasierte Version der zuvor geschriebenen funktionsbasierten Ansicht. Diese Ansicht erbt die von Django Listenansicht Klasse, die zum Auflisten von Elementen verwendet wird. Es definiert seine Logik mit Attributen wie Modell, Vorlagenname, context_object_name, Und paginate_by. Der paginate_by Das Attribut bestimmt, wie viele Beiträge pro Seite angezeigt werden sollen. in diesem Fall 2 Beiträge.

• Sobald Sie Ihre Ansicht erstellt haben, ändern Sie Ihre urls.py Datei, um sie zu verwenden. Hier ist ein einfaches Beispiel:

aus .Ansichten importieren PostListView
URL-Muster = [
 Weg('', PostListView.as_view(), name='Listenansicht'),
]

• Ändern Sie Ihre zu verwendende HTML-Vorlage page_obj für die Paginierung.

 {% if page_obj.has_ previous %}
<Ahref="?page={{page_obj. previous_page_number}}"
 class="btn btn-secondary mx-NN">ZurückA>
 {% endif %}
<Ahref=„?page=1“Klasse=„btn btn-secondary“>ErsteA>
 {% für num in page_obj.paginator.page_range %}
 {% if num == page_obj.number %}
<SpanneKlasse="aktuelle Seite">{{ num }}Spanne>
 {% anders %}
<Ahref=„?page={{num}}“Klasse=„btn btn-secondary mx-2“>
 {{ num }}
A>
 {% endif %}
 {% endfor %}
<Ahref="?page={{page_obj.paginator.num_pages}}"
 class="btn btn-secondary mx-NN">
 Zuletzt
A>
 {% if page.has_next %}
<Ahref=„?page={{page_obj.next_page_number}}“
 class="btn btn-secondary mx-NN">
 Nächste
A>
 {% endif %}

Im Gegensatz zur HTML-Vorlage für die funktionsbasierte Ansicht verwendet diese Vorlage page_obj anstatt Buchseite um das Seitenobjekt darzustellen. Dies ist das Standardverhalten für die klassenbasierte Paginierung in Django.

Verwenden Sie Paginierung, um Ihre Anwendung skalierbar zu machen

Durch die Paginierung wird die Belastung Ihres Servers bzw. Ihrer Datenbank verringert, indem jeweils kleinere Teilmengen von Daten abgerufen und angezeigt werden. Mit der Paginierung steigern Sie die Leistung Ihrer Websites. Auch Ihre Benutzer werden eine gute Erfahrung bei der Nutzung Ihrer Anwendung haben.

Klassenbasierte Ansichten sparen im Vergleich zu funktionsbasierten Ansichten mehr Zeit und Code, Sie können jedoch je nach Ihren Vorlieben und Projektspezifikationen eine der beiden verwenden.