Un ghid pentru paginarea în Django

Paginarea îmbunătățește experiența utilizatorului și performanța aplicației atunci când aveți de-a face cu seturi de date mari. Fără un sistem de paginare în vigoare, aplicația dvs. va experimenta întârzieri de cele mai multe ori. Cu Django, puteți profita de suportul încorporat pentru paginare pentru a vă pagina aplicația web.

Cum funcționează paginarea în Django

Implementarea paginarii în Django poate diferi în funcție de dacă lucrați cu vederi bazate pe clasă sau pe funcții. Indiferent de metoda preferată, principiile de bază rămân aceleași.

Django folosește o clasă numită Paginator pentru a implementa paginarea. The Paginator clasa oferă mai multe metode pe care le puteți folosi pentru a vă personaliza paginarea. La inițializarea Paginator clasa, este nevoie de doi parametri obligatorii; datele de paginat și numărul de articole de afișat pe pagină. The

Paginator acceptă un al treilea parametru opțional pentru orfani pentru a specifica numărul minim de articole care ar trebui să rămână pe ultima pagină. În mod implicit, valoarea orfanilor este 0, ceea ce înseamnă că toate paginile au același număr de articole.

Adresa URL pentru o pagină paginată Django este similară cu aceasta: https://example.com/products/?page=3. The pagină parametrul din URL îi spune lui Django ce pagină dorește să vadă utilizatorul. De asemenea, îl ajută pe Django să determine ce porțiune a datelor să fie afișată pentru pagina respectivă.

Codul folosit în acest proiect este disponibil în a Depozitul GitHub și este gratuit pentru utilizare sub licența MIT.

Configurați proiectul Django pentru paginare

Înainte de a pagina în Django, trebuie să aveți instalat Django și configurați-l pe computer. După configurarea Django pe computer, ar trebui să creați o aplicație și un model pentru datele dvs. Iată un model simplu pe care îl puteți copia:

din django.db import modele
clasăPost(modele. Model):
 titlu = modele. CharField (lungime_max =255)
 autor = modele. CharField (lungime_max =50)
 continut = modele. TextField(„Postează conținut”)
def__str__(de sine):
întoarcere auto.titlu

Modelul de mai sus este pentru o aplicație de blog. Acesta definește titlul, autorul și câmpurile de conținut pentru fiecare postare de blog. De asemenea, are o metodă care returnează titlul postării pentru o experiență mai bună a utilizatorului în panoul de administrare.

Migrați-vă modelul rulând această comandă:

python manage.py makemigrations && python manage.py migra

După migrarea modelului dvs., ar trebui să navigați la blog>admin.py să-l înregistreze. Următorul cod înregistrează cu succes un model numit Post.

din django.contrib import admin
din .modele import Post # înlocuiți „Post” cu numele modelului dvs
admin.site.register (Postare)

Apoi, creați un superutilizator și adăugați postări în panoul de administrare Django. Pentru a crea un superutilizator, utilizați această comandă:

python manage.py createsuperuser

Comanda de mai sus vă va ghida prin procesul ilustrat în imaginea de mai jos:

După ce ați creat un superutilizator, rulați serverul de dezvoltare și navigați la panoul de administrare.

python manage.py runserver

Odată ce serverul dvs. pornește, navigați la http://127.0.0.1:8000/admin, conectează-te și adaugă câteva postări.

Apoi, creați un șablon HTML pentru a vă reda postările în browser. Creați fișierul în următorul director: your_app/templates/your_app_name/index.html. Dacă nu înțelegeți cum să creați șabloane, citiți ghid introductiv pentru arhitectura MVT a lui Django.

Paginarea Django într-o vizualizare bazată pe funcții

Django vă permite să construiți aplicații fie cu vederi bazate pe clasă, fie cu vederi bazate pe funcții. Pentru a vă pagina aplicația folosind o vizualizare bazată pe funcții. Urmați acești pași:

• Deschide-ți vederi.py fișier și importați fișierul Paginator clasă.

din django.core.paginator import Paginator

• Creați o funcție de vizualizare pentru a reda postările în șablonul HTML.

din django.comenzi rapide import face
din .modele import Post
din django.core.paginator import Paginator
deflist_view(cerere):
 posts = Post.objects.all()
întoarcere randa (cerere, „blog/blog_list_view.html”, {„postări”:postări})

• Creați un model URL pentru a vă afișa postările în browser. Începeți prin a configura modelul URL în directorul proiectului. Deschide urls.py fișier la nivel de proiect și adăugați-l la urlpatterns:

din django.urls import include
urlpatterns = [
 ...,
 cale('', include(„blog.urls”)),
]

În fragmentul de cod de mai sus, înlocuiți blog cu numele aplicației dvs. Dacă nu puteți face diferența între un proiect și o aplicație, ar trebui să știți cum diferă un proiect de o aplicație în Django.

După ce ați făcut configurația de mai sus, creați un urls.py fișier în directorul aplicației dvs. (în acest caz, este blog folder) și adăugați acest fragment de cod:

din django.urls import cale
din .vizualizări import list_view
urlpatterns = [
 cale('', list_view, name=„vizualizare listă”),
]

Când rulați serverul și navigați la http://127.0.0.1:8000/, browserul vă va afișa postările în conformitate cu foaia de stil specificată.

• Modificați funcția de vizualizare pentru a adăuga logica de paginare. Iată un exemplu:

deflist_view(cerere):
 posts = Post.objects.all()
 paginated = Paginator (postări, 3)
 page_number = cerere. GET.get('pagină') #Obțineți numărul de pagină solicitat de la adresa URL

 pagina = paginated.get_page (număr_pagină)
întoarcere randa (cerere, „blog/blog_list_view.html”, {'pagină':pagină})

Fragmentul de cod de mai sus introduce trei variabile noi: paginat, numărul paginii, și pagină. Fiecare variabilă face următoarele:

1. The paginat variabila a initializat Paginator clasă. În acest scenariu, datele care trebuie paginate sunt setul de interogări, postări, si este nevoie 3 ca numărul de elemente de afișat pe pagină.
2. The numărul paginii variabila primește numărul paginii de la adresa URL. De exemplu, în http://127.0.0.1:8000/?page=2, numărul paginii este 2.
3. The pagină variabila preia pagina specifică pentru a reda din paginat variabil.

Până acum, Django trebuie să-ți fi paginat pagina. Puteți naviga la anumite pagini paginate folosind formatul URL afișat în această imagine:

• Modificați șablonul HTML pentru a afișa navigarea pentru paginile paginate. Folosind metodele disponibile în Paginator clasa vă permite să creați o navigare simplă pe pagina dvs. Iată un exemplu pe care îl puteți adăuga mai jos codul HTML inițial:

 {% if page.has_previous %}
<Ahref=„?page={{page.previous_page_number}}”
 class="btn btn-secondary mx-NN">AnteriorA>
 {% endif %}
<Ahref=„?page=1”clasă="btn btn-secundar">PrimulA>
 {% pentru num în page.paginator.page_range %}
 {% if num == page.number %}
<span>{{ num }}span>
 {% altfel %}
<Ahref=„?page={{num}}”clasă=„btn btn-secundar mx-2”>
 {{ num }}
A>
 {% endif %}
 {% endfor %}
<Ahref=„?page={{page.paginator.num_pages}}”clasă=„btn btn-secundar mx-2”>
 Ultimul
A>
 {% if page.has_next %}
<Ahref=„?page={{page.next_page_number}}”clasă=„btn btn-secundar mx-2”>
 Următorul
A>
 {% endif %}

În fragmentul de cod de mai sus, următoarele metode sunt utilizate împreună cu instrucțiunile condiționate pentru a determina cum va arăta navigarea prin paginare:

1. are_anterior: Această metodă revine Adevărat dacă există o pagină anterioară în datele paginate.
2. numărul_paginii_anterior: Această metodă returnează valoarea paginii anterioare.
3. interval de pagini: Această metodă vă permite să știți câte pagini aveți în datele dvs. paginate.
4. număr: Această metodă returnează valoarea paginii curente.
5. num_pages: Această metodă returnează numărul total de pagini.
6. are_next: Această funcție revine Adevărat dacă există o pagină următoare în datele paginate.
7. next_page_number: Această metodă returnează valoarea paginii următoare.

Paginare Django într-o vizualizare bazată pe clasă

Într-o vizualizare bazată pe clasă, nu trebuie să importați și să inițializați Paginator clasă. Pentru a implementa paginarea într-o vizualizare bazată pe clasă, ar trebui să specificați un atribut numit paginate_by. Urmați acești pași pentru a vă pagina aplicația cu o vizualizare bazată pe clasă:

• Scrieți o vizualizare bazată pe clasă și specificați paginate_by atribut. Iată un exemplu simplu:

din .modele import Post
din django.views.generic import ListView
clasăPostListView(Vizualizare listă):
 model = Post
 template_name = „blog/blog_list_view.html”
 nume_obiect_context = 'pagină'
 paginate_by = 2

Vederea de mai sus este versiunea bazată pe clasă a vederii bazate pe funcții scrisă mai devreme. Această viziune moștenește cea a lui Django ListView clasa, folosită pentru listarea articolelor. Își definește logica cu atribute precum model, Nume șablon, nume_obiect_context, și paginate_by. The paginate_by atributul determină câte postări trebuie afișate pe pagină; în acest caz, 2 postări.

• Odată ce ați creat vizualizarea, modificați urls.py fișier pentru a-l folosi. Iată un exemplu simplu:

din .vizualizări import PostListView
urlpatterns = [
 cale('', PostListView.as_view(), nume=„vizualizare listă”),
]

• Modificați șablonul HTML pentru a-l utiliza page_obj pentru paginare.

 {% if page_obj.has_previous %}
<Ahref=„?page={{page_obj.previous_page_number}}”
 class="btn btn-secondary mx-NN">AnteriorA>
 {% endif %}
<Ahref=„?page=1”clasă="btn btn-secundar">PrimulA>
 {% pentru num în page_obj.paginator.page_range %}
 {% if num == page_obj.number %}
<spanclasă="pagina curenta">{{ num }}span>
 {% altfel %}
<Ahref=„?page={{num}}”clasă=„btn btn-secundar mx-2”>
 {{ num }}
A>
 {% endif %}
 {% endfor %}
<Ahref=„?page={{page_obj.paginator.num_pages}}”
 class="btn btn-secondary mx-NN">
 Ultimul
A>
 {% if page.has_next %}
<Ahref=„?page={{page_obj.next_page_number}}”
 class="btn btn-secondary mx-NN">
 Următorul
A>
 {% endif %}

Spre deosebire de șablonul HTML pentru vizualizarea bazată pe funcții, acest șablon folosește page_obj în loc de pagină pentru a reprezenta obiectul pagină. Acesta este comportamentul implicit pentru paginarea bazată pe clasă în Django.

Utilizați paginarea pentru a face aplicația dvs. scalabilă

Paginarea reduce încărcarea serverului/bazei de date prin preluarea și afișarea simultană a unor subseturi mai mici de date. Odată cu paginarea, performanța site-urilor dvs. web va crește. Utilizatorii dvs. vor avea, de asemenea, o experiență bună atunci când vă folosesc aplicația.

Vizualizările bazate pe clasă economisesc mai mult timp și cod în comparație cu vizualizările bazate pe funcții, dar puteți utiliza oricare dintre ele în funcție de preferințele dvs. și de specificațiile proiectului.