En guide til paginering i Django

Paginering forbedrer brukeropplevelsen og applikasjonsytelsen når du arbeider med store datasett. Uten et pagineringssystem på plass vil applikasjonen din oppleve etterslep mesteparten av tiden. Med Django kan du utnytte den innebygde støtten for paginering for å paginere nettapplikasjonen din.

Hvordan paginering fungerer i Django

Implementering av paginering i Django kan variere avhengig av om du jobber med klassebaserte eller funksjonsbaserte visninger. Uansett hvilken metode du foretrekker, forblir de underliggende prinsippene de samme.

Django bruker en klasse som heter Paginering å implementere paginering. De Paginering klasse gir flere metoder som du kan bruke for å tilpasse pagineringen. Ved initialisering av Paginering klasse, det tar to obligatoriske parametere; dataene som skal pagineres, og antall elementer som skal vises per side. De

Paginering tar inn en tredje valgfri parameter for foreldreløse barn for å spesifisere minimum antall elementer som skal forbli på siste side. Som standard er verdien av foreldreløse barn 0, noe som betyr at alle sider har samme antall elementer.

URL-en til en Django-paginert side ligner på denne: https://example.com/products/?page=3. De side parameter i URL-en forteller Django hvilken side brukeren vil se. Det hjelper også Django med å bestemme hvilken del av dataene som skal vises for den siden.

Koden som brukes i dette prosjektet er tilgjengelig i en GitHub-depot og er gratis for deg å bruke under MIT-lisensen.

Sett opp Django-prosjektet ditt for paginering

Før du paginerer i Django, må du ha installerte Django og sett den opp på datamaskinen din. Etter å ha satt opp Django på datamaskinen din, bør du lage en app og en modell for dataene dine. Her er en enkel modell du kan kopiere:

fra django.db import modeller
klassePost(modeller. Modell):
 tittel = modeller. CharField (max_length=255)
 forfatter = modeller. CharField (max_length=50)
 innhold = modeller. Tekstfelt("Legg ut innhold")
def__str__(selv):
komme tilbake selvtittel

Modellen ovenfor er for en bloggapplikasjon. Den definerer tittel, forfatter og innholdsfelt for hvert blogginnlegg. Den har også en metode som returnerer posttittelen for en bedre brukeropplevelse i administrasjonspanelet.

Migrer modellen din ved å kjøre denne kommandoen:

python manage.py makemigrations && python manage.py migrere

Etter å ha migrert modellen din, bør du navigere til blog>admin.py å registrere den. Følgende kode registrerer vellykket en modell kalt Post.

fra django.contrib import admin
fra .modeller import Post # erstatt 'Innlegg' med modellnavnet ditt
admin.site.register (Innlegg)

Deretter oppretter du en superbruker og legger til innlegg i Django-adminpanelet ditt. For å opprette en superbruker, bruk denne kommandoen:

python manage.py createsuperuser

Kommandoen ovenfor tar deg gjennom prosessen illustrert i bildet nedenfor:

Etter å ha opprettet en superbruker, kjør utviklingsserveren og naviger til administrasjonspanelet.

python manage.py runserver

Når serveren din starter, naviger til http://127.0.0.1:8000/admin, logg inn og legg til noen få innlegg.

Deretter lager du en HTML-mal for å gjengi innleggene dine i nettleseren. Opprett filen din i følgende katalog: your_app/templates/your_app_name/index.html. Hvis du ikke forstår hvordan du lager maler, les vår introduksjonsguide til Djangos MVT-arkitektur.

Django-paginering i en funksjonsbasert visning

Django lar deg bygge applikasjoner med enten klassebaserte visninger eller funksjonsbaserte visninger. For å paginere applikasjonen din ved hjelp av en funksjonsbasert visning. Følg disse instruksjonene:

• Åpne din views.py fil og importer Paginering klasse.

fra django.core.paginator import Paginering

• Lag en visningsfunksjon for å gjengi innlegg i HTML-malen din.

fra django.snarveier import gjengi
fra .modeller import Post
fra django.core.paginator import Paginering
deflistevisning(be om):
 innlegg = Post.objects.all()
komme tilbake gjengi (forespørsel, 'blog/blog_list_view.html', {'innlegg':posts})

• Lag et URL-mønster for å vise innleggene dine i nettleseren. Start med å konfigurere URL-mønsteret i prosjektkatalogen din. Åpne urls.py fil på prosjektnivå og legg denne til urlpatterns:

fra django.urls import inkludere
urlpatterns = [
 ...,
 sti('', inkluderer ('blog.urls')),
]

Erstatt i kodebiten ovenfor blogg med navnet på appen din. Hvis du ikke kan skille mellom et prosjekt og en app, bør du vite det hvordan et prosjekt skiller seg fra en app i Django.

Etter å ha utført konfigurasjonen ovenfor, lag en urls.py filen i appkatalogen din (i dette tilfellet er det blogg mappe) og legg til denne kodebiten:

fra django.urls import sti
fra .visninger import listevisning
urlpatterns = [
 sti('', listevisning, navn='listevisning'),
]

Når du kjører serveren din og navigerer til http://127.0.0.1:8000/, vil nettleseren vise innleggene dine i henhold til det angitte stilarket.

• Endre visningsfunksjonen for å legge til pagineringslogikk. Her er et eksempel:

deflistevisning(be om):
 innlegg = Post.objects.all()
 paginert = Paginering (innlegg, 3)
 sidenummer = forespørsel. GET.get('side') #Få det forespurte sidenummeret fra URL-en

 side = paginert.get_side (sidenummer)
komme tilbake gjengi (forespørsel, 'blog/blog_list_view.html', {'side':side})

Kodebiten ovenfor introduserer tre nye variabler: paginert, side nummer, og side. Hver variabel gjør følgende:

1. De paginert variabel initialiserte Paginering klasse. I dette scenariet er dataene som skal pagineres spørringssettet, innlegg, og det tar 3 som antall elementer som skal vises per side.
2. De side nummer variabel henter sidetallet fra URL-en. For eksempel i http://127.0.0.1:8000/?page=2, sidetallet er 2.
3. De side variabel henter den spesifikke siden som skal gjengis fra paginert variabel.

Nå må Django ha paginert siden din. Du kan navigere til spesifikke paginerte sider ved å bruke URL-formatet vist i dette bildet:

• Endre HTML-malen for å vise navigasjon for paginerte sider. Ved å bruke metoder som er tilgjengelige i Paginering klasse lar deg lage enkel navigering på siden din. Her er et eksempel du kan legge til under den første HTML-koden din:

 {% if page.has_previous %}
<enhref="?page={{page.previous_page_number}}"
 class="btn btn-secondary mx-NN">Forrigeen>
 {% slutt om %}
<enhref="?page=1"klasse="btn btn-sekundær">Førsten>
 {% for num i page.paginator.page_range %}
 {% if num == side.nummer %}
<span>{{ num }}span>
 {% annet %}
<enhref="?page={{num}}"klasse="btn btn-sekundær mx-2">
 {{ num }}
en>
 {% slutt om %}
 {% endfor %}
<enhref="?page={{page.paginator.num_pages}}"klasse="btn btn-sekundær mx-2">
 Siste
en>
 {% if page.has_next %}
<enhref="?page={{page.next_page_number}}"klasse="btn btn-sekundær mx-2">
 Neste
en>
 {% slutt om %}

I kodebiten ovenfor brukes følgende metoder i forbindelse med betingede utsagn for å bestemme hvordan pagineringsnavigasjonen vil se ut:

1. has_previous: Denne metoden returnerer ekte hvis det er en tidligere side i de paginerte dataene.
2. forrige_sidenummer: Denne metoden returnerer verdien til forrige side.
3. sideområde: Denne metoden lar deg vite hvor mange sider du har i de paginerte dataene dine.
4. Antall: Denne metoden returnerer verdien til gjeldende side.
5. antall_sider: Denne metoden returnerer totalt antall sider.
6. har_neste: Denne funksjonen returnerer ekte hvis det er en neste side i de paginerte dataene.
7. neste_sidenummer: Denne metoden returnerer verdien til neste side.

Django-paginering i en klassebasert visning

I en klassebasert visning trenger du ikke å importere og initialisere Paginering klasse. For å implementere paginering i en klassebasert visning, bør du spesifisere et attributt kalt paginere_av. Følg disse trinnene for å paginere appen din med en klassebasert visning:

• Skriv en klassebasert visning og spesifiser paginere_av Egenskap. Her er et enkelt eksempel:

fra .modeller import Post
fra django.views.generic import Listevisning
klassePostListView(Listevisning):
 modell = Post
 malnavn = 'blog/blog_list_view.html'
 kontekstobjektnavn = 'side'
 pagine_by = 2

Visningen ovenfor er den klassebaserte versjonen av den funksjonsbaserte visningen skrevet tidligere. Dette synet arver Djangos Listevisning klasse, brukt til å liste elementer. Den definerer sin logikk med attributter som f.eks modell, mal_navn, kontekstobjekt_navn, og paginere_av. De paginere_av attributt bestemmer hvor mange innlegg som skal vises per side; i dette tilfellet 2 innlegg.

• Når du har opprettet visningen, endrer du urls.py fil for å bruke den. Her er et enkelt eksempel:

fra .visninger import PostListView
urlpatterns = [
 sti('', PostListView.as_view(), navn='listevisning'),
]

• Endre HTML-malen du vil bruke side_obj for paginering.

 {% if page_obj.has_previous %}
<enhref="?page={{page_obj.previous_page_number}}"
 class="btn btn-secondary mx-NN">Forrigeen>
 {% slutt om %}
<enhref="?page=1"klasse="btn btn-sekundær">Førsten>
 {% for num i page_obj.paginator.page_range %}
 {% if num == page_obj.number %}
<spanklasse="nåværende side">{{ num }}span>
 {% annet %}
<enhref="?page={{num}}"klasse="btn btn-sekundær mx-2">
 {{ num }}
en>
 {% slutt om %}
 {% endfor %}
<enhref="?page={{page_obj.paginator.num_pages}}"
 class="btn btn-sekundær mx-NN">
 Siste
en>
 {% if page.has_next %}
<enhref="?page={{page_obj.next_page_number}}"
 class="btn btn-sekundær mx-NN">
 Neste
en>
 {% slutt om %}

I motsetning til HTML-malen for den funksjonsbaserte visningen, bruker denne malen side_obj i stedet for side for å representere sideobjektet. Dette er standardoppførselen for klassebasert paginering i Django.

Bruk paginering for å gjøre applikasjonen din skalerbar

Paginering reduserer belastningen på serveren/databasen din ved å hente og vise mindre delsett av data om gangen. Med paginering vil ytelsen til nettsidene dine øke. Brukerne dine vil også ha en god opplevelse når de bruker applikasjonen din.

Klassebaserte visninger sparer mer tid og kode sammenlignet med funksjonsbaserte visninger, men du kan bruke begge avhengig av dine preferanser og prosjektspesifikasjoner.