Forbedre effektiviteten og skalerbarheden af ​​din Django-applikation ved at implementere paginering. Her er alt hvad du behøver at vide for at komme i gang.

Sideinddeling forbedrer brugeroplevelsen og applikationens ydeevne, når der er tale om store datasæt. Uden et pagineringssystem på plads vil din applikation opleve at halte det meste af tiden. Med Django kan du udnytte den indbyggede understøttelse af paginering til at paginere din webapplikation.

Sådan fungerer sideinddeling i Django

Implementering af paginering i Django kan variere afhængigt af, om du arbejder med klassebaserede eller funktionsbaserede visninger. Uanset din foretrukne metode, forbliver de underliggende principper de samme.

Django bruger en klasse kaldet Sidetor at implementere paginering. Det Sidetor klasse giver flere metoder, som du kan bruge til at tilpasse din paginering. Ved initialisering af Sidetor klasse, det kræver to obligatoriske parametre; de data, der skal pagineres, og antallet af elementer, der skal vises pr. side. Det

Sidetor tager en tredje valgfri parameter ind for forældreløse børn for at angive det mindste antal elementer, der skal forblive på den sidste side. Som standard er værdien af ​​forældreløse børn 0, hvilket betyder, at alle sider har det samme antal elementer.

URL'en for en Django-pagineret side ligner denne: https://example.com/products/?page=3. Det side parameter i URL'en fortæller Django, hvilken side brugeren ønsker at se. Det hjælper også Django med at bestemme, hvilken del af dataene der skal vises for den pågældende side.

Koden brugt i dette projekt er tilgængelig i en GitHub-depot og er gratis for dig at bruge under MIT-licensen.

Konfigurer dit Django-projekt til sideinddeling

Før du paginerer i Django, skal du have installeret Django og opsat det på din computer. Efter opsætning af Django på din computer, bør du oprette en app og en model for dine data. Her er en simpel model, du kan kopiere:

fra django.db importere modeller
klasseStolpe(modeller. Model):


 titel = modeller. CharField (max_length=255)
 forfatter = modeller. CharField (max_length=50)
 indhold = modeller. Tekstfelt('Send indhold')
def__str__(selv):
Vend tilbage selv.titel

Ovenstående model er til en blogapplikation. Den definerer titel, forfatter og indholdsfelter for hvert blogindlæg. Det har også en metode, der returnerer posttitlen for en bedre brugeroplevelse i adminpanelet.

Migrer din model ved at køre denne kommando:

python manage.py makemigrationer && python manage.py migrere

Når du har migreret din model, skal du navigere til blog>admin.py at registrere det. Følgende kode registrerer en model kaldet Stolpe.

fra django.contrib importere admin
fra .modeller importere Stolpe # erstat 'Post' med dit modelnavn
admin.site.register (indlæg)

Derefter skal du oprette en superbruger og tilføje indlæg i dit Django-adminpanel. For at oprette en superbruger, brug denne kommando:

python manage.py createsuperuser

Ovenstående kommando vil tage dig gennem processen illustreret på billedet nedenfor:

Når du har oprettet en superbruger, skal du køre din udviklingsserver og navigere til administrationspanelet.

python manage.py runserver

Når din server starter, skal du navigere til http://127.0.0.1:8000/admin, log ind og tilføj et par indlæg.

Opret derefter en HTML-skabelon til at gengive dine indlæg i browseren. Opret din fil i følgende mappe: din_app/skabeloner/navnet_din_app/index.html. Hvis du ikke forstår, hvordan du opretter skabeloner, så læs vores introduktionsvejledning til Djangos MVT-arkitektur.

Django-sideinddeling i en funktionsbaseret visning

Django giver dig mulighed for at bygge applikationer med enten klassebaserede visninger eller funktionsbaserede visninger. For at paginere din applikation ved hjælp af en funktionsbaseret visning. Følg disse trin:

  • Åben din views.py fil og importer Sidetor klasse. 
fra django.core.paginator importere Sidetor
  • Opret en visningsfunktion til at gengive indlæg i din HTML-skabelon. 
fra django.genveje importere gengive
fra .modeller importere Stolpe
fra django.core.paginator importere Sidetor
defliste_visning(anmodning):
 posts = Post.objects.all()
Vend tilbage gengive (anmodning, 'blog/blog_list_view.html', {'indlæg':indlæg})
  • Opret et URL-mønster for at vise dine indlæg i browseren. Start med at konfigurere URL-mønsteret i din projektmappe. Åbn urls.py fil på projektniveau og tilføj denne til urlmønstre: 
fra django.urls importere omfatte
urlpatterns = [
 ...,
 sti('', inkluderer ('blog.urls')),
]

I ovenstående kodestykke skal du erstatte blog med navnet på din app. Hvis du ikke kan skelne mellem et projekt og en app, bør du vide det hvordan et projekt adskiller sig fra en app i Django.

Efter at have udført ovenstående konfiguration, skal du oprette en urls.py fil i din app-mappe (i dette tilfælde er det blog mappe) og tilføj dette kodestykke:

fra django.urls importere sti
fra .visninger importere liste_visning
urlpatterns = [
 sti('', liste_visning, navn='liste-visning'),
]

Når du kører din server og navigerer til http://127.0.0.1:8000/, vil browseren vise dine indlæg i henhold til dit angivne typografiark.

  • Rediger din visningsfunktion for at tilføje pagineringslogik. Her er et eksempel: 
defliste_visning(anmodning):
 posts = Post.objects.all()
 pagineret = Paginering (indlæg, 3)
 sidenummer = anmodning. GET.get('side') #Få det anmodede sidenummer fra URL'en

 side = pagineret.get_side (sidenummer)
Vend tilbage gengive (anmodning, 'blog/blog_list_view.html', {'side':side})

Ovenstående kodestykke introducerer tre nye variabler: pagineret, sidenummer, og side. Hver variabel gør følgende:

  1. Det pagineret variabel initialiserede Sidetor klasse. I dette scenarie er de data, der skal pagineres, forespørgselssættet, indlæg, og det tager 3 som antallet af elementer, der skal vises pr. side.
  2. Det sidenummer variabel henter sidetallet fra URL'en. For eksempel i http://127.0.0.1:8000/?page=2, sidetallet er 2.
  3. Det side variabel henter den specifikke side, der skal gengives fra pagineret variabel.

Nu skal Django have pagineret din side. Du kan navigere til specifikke paginerede sider ved hjælp af URL-formatet vist på dette billede:

  • Rediger din HTML-skabelon for at vise navigation for paginerede sider. Ved hjælp af metoder, der er tilgængelige i Sidetor klasse giver dig mulighed for at skabe enkel navigation på din side. Her er et eksempel, du kan tilføje under din oprindelige HTML-kode: 
 {% if page.has_previous %}
<-enhref="?page={{page.previous_page_number}}"
 class="btn btn-secondary mx-NN">Forrige-en>
 {% Afslut Hvis %}
<-enhref="?page=1"klasse="btn btn-sekundær">Først-en>


 {% for num i page.paginator.page_range %}
 {% if num == side.nummer %}
<span>{{ antal }}span>
 {% andet %}
<-enhref="?page={{num}}"klasse="btn btn-sekundær mx-2">
 {{ antal }}
-en>
 {% Afslut Hvis %}
 {% endfor %}


<-enhref="?page={{page.paginator.num_pages}}"klasse="btn btn-sekundær mx-2">
 Sidst
-en>
 {% if page.has_next %}
<-enhref="?page={{page.next_page_number}}"klasse="btn btn-sekundær mx-2">
 Næste
-en>
 {% Afslut Hvis %}

I ovenstående kodestykke bruges følgende metoder sammen med betingede sætninger for at bestemme, hvordan pagineringsnavigationen vil se ud:

  1. har_forrige: Denne metode vender tilbage Rigtigt hvis der er en tidligere side i de paginerede data.
  2. forrige_sidenummer: Denne metode returnerer værdien af ​​den forrige side.
  3. sideområde: Denne metode lader dig vide, hvor mange sider du har i dine paginerede data.
  4. nummer: Denne metode returnerer værdien af ​​den aktuelle side.
  5. antal_sider: Denne metode returnerer det samlede antal sider.
  6. har_næste: Denne funktion returnerer Rigtigt hvis der er en næste side i de paginerede data.
  7. næste_sidenummer: Denne metode returnerer værdien af ​​den næste side.

Django-sideinddeling i en klassebaseret visning

I en klassebaseret visning behøver du ikke at importere og initialisere Sidetor klasse. For at implementere paginering i en klassebaseret visning skal du angive en attribut kaldet paginere_af. Følg disse trin for at sideinddele din app med en klassebaseret visning:

  • Skriv en klassebaseret visning og angiv paginere_af attribut. Her er et simpelt eksempel: 
fra .modeller importere Stolpe
fra django.views.generic importere Listevisning
klassePostListView(Listevisning):
 model = Post
 skabelon_navn = 'blog/blog_list_view.html'
 kontekst_objekt_navn = 'side'
 paginate_by = 2

Ovenstående visning er den klassebaserede version af den funktionsbaserede visning skrevet tidligere. Denne opfattelse arver Djangos Listevisning klasse, bruges til at liste varer. Den definerer sin logik med attributter som f.eks model, skabelon_navn, kontekstobjekt_navn, og paginere_af. Det paginere_af attribut bestemmer, hvor mange indlæg der skal vises pr. side; i dette tilfælde 2 indlæg.

  • Når du har oprettet din visning, skal du ændre din urls.py fil for at bruge den. Her er et simpelt eksempel: 
fra .visninger importere PostListView
urlpatterns = [
 sti('', PostListView.as_view(), navn='liste-visning'),
]
  • Rediger din HTML-skabelon til brug side_obj for pagineringen. 
 {% if page_obj.has_previous %}
<-enhref="?page={{page_obj.previous_page_number}}"
 class="btn btn-secondary mx-NN">Forrige-en>
 {% Afslut Hvis %}
<-enhref="?page=1"klasse="btn btn-sekundær">Først-en>


 {% for num i page_obj.paginator.page_range %}
 {% if num == page_obj.number %}
<spanklasse="nuværende side">{{ antal }}span>
 {% andet %}
<-enhref="?page={{num}}"klasse="btn btn-sekundær mx-2">
 {{ antal }}
-en>
 {% Afslut Hvis %}
 {% endfor %}


<-enhref="?page={{page_obj.paginator.num_pages}}"
 class="btn btn-sekundær mx-NN">
 Sidst
-en>
 {% if page.has_next %}
<-enhref="?page={{page_obj.next_page_number}}"
 class="btn btn-sekundær mx-NN">
 Næste
-en>
 {% Afslut Hvis %}

I modsætning til HTML-skabelonen til den funktionsbaserede visning, bruger denne skabelon side_obj i stedet for side at repræsentere sideobjektet. Dette er standardadfærden for klassebaseret paginering i Django.

Brug sideinddeling til at gøre din applikation skalerbar

Sideinddeling reducerer belastningen på din server/database ved at hente og vise mindre delmængder af data ad gangen. Med paginering vil ydeevnen på dine hjemmesider øges. Dine brugere vil også få en god oplevelse, når de bruger din applikation.

Klassebaserede visninger sparer mere tid og kode sammenlignet med funktionsbaserede visninger, men du kan bruge en af ​​dem afhængigt af dine præferencer og projektspecifikationer.