En guide till paginering i Django

Paginering förbättrar användarupplevelsen och applikationsprestanda när man hanterar stora datamängder. Utan ett pagineringssystem på plats kommer din applikation att uppleva eftersläpning för det mesta. Med Django kan du utnyttja det inbyggda stödet för paginering för att paginera din webbapplikation.

Hur paginering fungerar i Django

Att implementera paginering i Django kan skilja sig åt beroende på om du arbetar med klassbaserade eller funktionsbaserade vyer. Oavsett vilken metod du föredrar, förblir de underliggande principerna desamma.

Django använder en klass som heter Paginator att implementera paginering. De Paginator class tillhandahåller flera metoder som du kan använda för att anpassa din sidnumrering. När du initierar Paginator klass, det tar två obligatoriska parametrar; data som ska sidnumreras och antalet objekt som ska visas per sida. De

Paginator tar in en tredje valfri parameter för föräldralösa barn för att ange det minsta antal objekt som ska finnas kvar på sista sidan. Som standard är värdet för föräldralösa barn 0 vilket betyder att alla sidor har samma antal objekt.

URL: en för en Django sidnumrerad sida liknar denna: https://example.com/products/?page=3. De sida parametern i URL: en talar om för Django vilken sida användaren vill se. Det hjälper också Django att avgöra vilken del av data som ska visas för den sidan.

Koden som används i detta projekt är tillgänglig i en GitHub-förråd och är gratis för dig att använda under MIT-licensen.

Ställ in ditt Django-projekt för paginering

Innan du paginerar i Django måste du ha installerat Django och installerat det på din dator. Efter att ha ställt in Django på din dator bör du skapa en app och en modell för dina data. Här är en enkel modell som du kan kopiera:

från django.db importera modeller
klassPosta(modeller. Modell):
 titel = modeller. CharField (max_length=255)
 författare = modeller. CharField (max_length=50)
 innehåll = modeller. Textfält("Inlägg innehåll")
def__str__(själv):
lämna tillbaka själv.titel

Modellen ovan är för en bloggapplikation. Den definierar titel, författare och innehållsfält för varje blogginlägg. Den har också en metod som returnerar inläggets titel för en bättre användarupplevelse i adminpanelen.

Migrera din modell genom att köra det här kommandot:

python manage.py makemigrations && python manage.py migrera

När du har migrerat din modell bör du navigera till blog>admin.py att registrera den. Följande kod registrerar framgångsrikt en modell som kallas Posta.

från django.contrib importera administration
från .modeller importera Posta # ersätt 'Post' med ditt modellnamn
admin.site.register (Inlägg)

Skapa sedan en superanvändare och lägg till inlägg i din Django-adminpanel. För att skapa en superanvändare, använd detta kommando:

python manage.py createsuperuser

Ovanstående kommando tar dig genom processen som illustreras i bilden nedan:

När du har skapat en superanvändare kör du din utvecklingsserver och navigerar till adminpanelen.

python manage.py runserver

När din server startar, navigera till http://127.0.0.1:8000/admin, logga in och lägg till några inlägg.

Skapa sedan en HTML-mall för att återge dina inlägg i webbläsaren. Skapa din fil i följande katalog: din_app/templates/ditt_app_namn/index.html. Om du inte förstår hur man skapar mallar, läs vår introduktionsguide till Djangos MVT-arkitektur.

Django-paginering i en funktionsbaserad vy

Django låter dig bygga applikationer med antingen klassbaserade vyer eller funktionsbaserade vyer. För att paginera din applikation med hjälp av en funktionsbaserad vy. Följ dessa steg:

• Öppna din views.py fil och importera Paginator klass.

från django.core.paginator importera Paginator

• Skapa en visningsfunktion för att rendera inlägg i din HTML-mall.

från django.shortcuts importera framställa
från .modeller importera Posta
från django.core.paginator importera Paginator
defListvy(begäran):
 inlägg = Post.objects.all()
lämna tillbaka rendera (begäran, 'blog/blog_list_view.html', {"inlägg":posts})

• Skapa ett URL-mönster för att visa dina inlägg i webbläsaren. Börja med att konfigurera URL-mönstret i din projektkatalog. Öppna urls.py fil på projektnivå och lägg till denna i urlmönster:

från django.urls importera omfatta
urlpatterns = [
 ...,
 väg('', inkludera('blog.urls')),
]

I kodavsnittet ovan, ersätt blogg med namnet på din app. Om du inte kan skilja mellan ett projekt och en app bör du veta det hur ett projekt skiljer sig från en app i Django.

Efter att ha gjort ovanstående konfiguration, skapa en urls.py filen i din appkatalog (i det här fallet är det blogg mapp) och lägg till detta kodavsnitt:

från django.urls importera väg
från .visningar importera Listvy
urlpatterns = [
 väg('', list_view, name='Listvy'),
]

När du kör din server och navigerar till http://127.0.0.1:8000/, kommer webbläsaren att visa dina inlägg enligt din angivna stilmall.

• Ändra din visningsfunktion för att lägga till pagineringslogik. Här är ett exempel:

defListvy(begäran):
 inlägg = Post.objects.all()
 paginerad = Paginering (inlägg, 3)
 page_number = begäran. GET.get('sida') #Hämta det begärda sidnumret från URL: en

 page = paginerad.get_page (page_number)
lämna tillbaka rendera (begäran, 'blog/blog_list_view.html', {'sida':sida})

Ovanstående kodavsnitt introducerar tre nya variabler: paginerade, Sidonummer, och sida. Varje variabel gör följande:

1. De paginerade variabel initierade Paginator klass. I det här scenariot är data som ska sidnumreras frågeuppsättningen, inlägg, och det tar 3 som antalet objekt som ska visas per sida.
2. De Sidonummer variabeln får sidnumret från URL: en. Till exempel i http://127.0.0.1:8000/?page=2, sidnumret är 2.
3. De sida variabeln hämtar den specifika sidan som ska renderas från paginerade variabel.

Vid det här laget måste Django ha paginerat din sida. Du kan navigera till specifika sidnumrerade sidor med URL-formatet som visas i den här bilden:

• Ändra din HTML-mall för att visa navigering för sidnumrerade sidor. Med hjälp av metoder som finns tillgängliga i Paginator klass gör det möjligt för dig att skapa enkel navigering på din sida. Här är ett exempel som du kan lägga till under din ursprungliga HTML-kod:

 {% if page.has_previous %}
<ahref="?page={{page.previous_page_number}}"
 class="btn btn-secondary mx-NN">Föregåendea>
 {% endif %}
<ahref="?page=1"klass="btn btn-sekundär">Första>
 {% för num i page.paginator.page_range %}
 {% om num == sida.nummer %}
<spänna>{{ num }}spänna>
 {% annat %}
<ahref="?page={{num}}"klass="btn btn-sekundär mx-2">
 {{ num }}
a>
 {% endif %}
 {% slutför %}
<ahref="?page={{page.paginator.num_pages}}"klass="btn btn-sekundär mx-2">
 Sista
a>
 {% if page.has_next %}
<ahref="?page={{page.next_page_number}}"klass="btn btn-sekundär mx-2">
 Nästa
a>
 {% endif %}

I ovanstående kodavsnitt används följande metoder tillsammans med villkorliga uttalanden för att avgöra hur sidnumreringsnavigeringen kommer att se ut:

1. has_previous: Denna metod returnerar Sann om det finns en föregående sida i sidnumrerade data.
2. föregående_sida_nummer: Den här metoden returnerar värdet på föregående sida.
3. sidintervall: Den här metoden låter dig veta hur många sidor du har i din paginerade data.
4. siffra: Den här metoden returnerar värdet på den aktuella sidan.
5. antal_sidor: Denna metod returnerar det totala antalet sidor.
6. has_next: Denna funktion returnerar Sann om det finns en nästa sida i sidnumrerade data.
7. nästa_sida_nummer: Denna metod returnerar värdet på nästa sida.

Django-paginering i en klassbaserad vy

I en klassbaserad vy behöver du inte importera och initiera Paginator klass. För att implementera paginering i en klassbaserad vy bör du ange ett attribut som kallas paginera_av. Följ dessa steg för att paginera din app med en klassbaserad vy:

• Skriv en klassbaserad vy och ange paginera_av attribut. Här är ett enkelt exempel:

från .modeller importera Posta
från django.views.generic importera Listvy
klassPostListView(Listvy):
 modell = Post
 mallnamn = 'blog/blog_list_view.html'
 context_object_name = 'sida'
 paginera_by = 2

Ovanstående vy är den klassbaserade versionen av den funktionsbaserade vyn som skrevs tidigare. Denna syn ärver Djangos Listvy klass, används för att lista artiklar. Den definierar sin logik med attribut som t.ex modell, mallnamn, context_object_name, och paginera_av. De paginera_av attribut bestämmer hur många inlägg som ska visas per sida; i detta fall 2 inlägg.

• När du har skapat din vy, ändra din urls.py fil för att använda den. Här är ett enkelt exempel:

från .visningar importera PostListView
urlpatterns = [
 väg('', PostListView.as_view(), name='Listvy'),
]

• Ändra din HTML-mall att använda page_obj för pagineringen.

 {% if page_obj.has_previous %}
<ahref="?page={{page_obj.previous_page_number}}"
 class="btn btn-secondary mx-NN">Föregåendea>
 {% endif %}
<ahref="?page=1"klass="btn btn-sekundär">Första>
 {% för num i page_obj.paginator.page_range %}
 {% if num == page_obj.number %}
<spännaklass="nuvarande sida">{{ num }}spänna>
 {% annat %}
<ahref="?page={{num}}"klass="btn btn-sekundär mx-2">
 {{ num }}
a>
 {% endif %}
 {% slutför %}
<ahref="?page={{page_obj.paginator.num_pages}}"
 class="btn btn-sekundär mx-NN">
 Sista
a>
 {% if page.has_next %}
<ahref="?page={{page_obj.next_page_number}}"
 class="btn btn-sekundär mx-NN">
 Nästa
a>
 {% endif %}

Till skillnad från HTML-mallen för den funktionsbaserade vyn, använder denna mall page_obj istället för sida för att representera sidobjektet. Detta är standardbeteendet för klassbaserad paginering i Django.

Använd paginering för att göra din applikation skalbar

Paginering minskar belastningen på din server/databas genom att hämta och visa mindre delmängder av data åt gången. Med paginering kommer prestandan på dina webbplatser att öka. Dina användare kommer också att ha en bra upplevelse när de använder din applikation.

Klassbaserade vyer sparar mer tid och kod jämfört med funktionsbaserade vyer, men du kan använda båda beroende på dina önskemål och projektspecifikationer.