Növelje Django alkalmazásának hatékonyságát és méretezhetőségét az oldalszámozás megvalósításával. Itt van minden, amit tudnod kell az induláshoz.

A lapozás javítja a felhasználói élményt és az alkalmazások teljesítményét nagy adatkészletek kezelésekor. Lapszámozási rendszer nélkül az alkalmazás az idő nagy részében lemarad. A Django segítségével a beépített oldalszámozási támogatást kihasználhatja webalkalmazása lapozására.

Hogyan működik a lapozás a Django-ban

A lapozás megvalósítása a Django programban eltérő lehet attól függően, hogy osztály- vagy függvényalapú nézetekkel dolgozik. A választott módszertől függetlenül az alapelvek ugyanazok maradnak.

A Django egy osztályt használ Lapozó oldalszámozás megvalósításához. A Lapozó osztály számos módszert kínál, amelyek segítségével személyre szabhatja a lapozást. Inicializáláskor a Lapozó osztályhoz két kötelező paraméter szükséges; az oldalszámozandó adatok és az oldalanként megjelenítendő elemek száma. A Lapozó bevesz egy harmadik opcionális paramétert az árvák számára, hogy meghatározza az utolsó oldalon maradó elemek minimális számát. Alapértelmezés szerint az árvák értéke 0, ami azt jelenti, hogy minden oldalon ugyanannyi elem van.

instagram viewer

A Django oldalszámmal ellátott oldal URL-je hasonló a következőhöz: https://example.com/products/?page=3. A oldalon Az URL-ben található paraméter közli a Django-val, hogy a felhasználó melyik oldalt szeretné látni. Segít a Django-nak abban is, hogy meghatározza az adatok melyik részét jelenítse meg az adott oldalon.

A projektben használt kód elérhető a GitHub adattár és az MIT licence alapján ingyenesen használható.

Állítsa be Django projektjét oldalszámozáshoz

Mielőtt lapozna a Django nyelven, meg kell tennie telepítette a Django-t, és állítsa be a számítógépén. Miután beállította a Django-t a számítógépén, hozzon létre egy alkalmazást és egy modellt az adatokhoz. Íme egy egyszerű modell, amelyet másolhat:

tól től django.db import modellek
osztályHozzászólás(modellek. Modell):


 cím = modellek. CharField (max_length=255)
 szerző = modellek. CharField (max_length=50)
 tartalom = modellek. TextField("Tartalom közzététele")
def__str__(maga):
Visszatérés önmaga.cím

A fenti modell blogalkalmazáshoz készült. Meghatározza az egyes blogbejegyzések címét, szerzőjét és tartalmi mezőit. Olyan módszerrel is rendelkezik, amely visszaadja a bejegyzés címét a jobb felhasználói élmény érdekében az adminisztrációs panelen.

Állítsa át a modellt a következő parancs futtatásával:

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

A modell áttelepítése után navigáljon ide blog>admin.py regisztrálni. A következő kód sikeresen regisztrálja az úgynevezett modellt Hozzászólás.

tól től django.contrib import admin
tól től .modellek import Hozzászólás # cserélje ki a „Post” kifejezést a modell nevére
admin.site.register (bejegyzés)

Ezután hozzon létre egy szuperfelhasználót, és adjon hozzá bejegyzéseket a Django adminisztrációs panelen. Superuser létrehozásához használja ezt a parancsot:

python manage.py createsuperuser

A fenti parancs végigvezeti az alábbi képen látható folyamaton:

A szuperfelhasználó létrehozása után futtassa a fejlesztőkiszolgálót, és lépjen az adminisztrációs panelre.

python manage.py runserver

Miután a szerver elindult, navigáljon ide http://127.0.0.1:8000/admin, jelentkezzen be, és adjon hozzá néhány bejegyzést.

Ezután hozzon létre egy HTML-sablont a bejegyzések megjelenítéséhez a böngészőben. Hozza létre a fájlt a következő könyvtárban: your_app/templates/your_app_name/index.html. Ha nem érted, hogyan kell sablonokat létrehozni, olvasd el a mi oldalunkat bevezető útmutató a Django MVT architektúrájához.

Django lapozás funkció alapú nézetben

A Django lehetővé teszi alkalmazások készítését akár osztály-, akár funkció-alapú nézetekkel. Az alkalmazás oldalszámozása függvényalapú nézet használatával. Kovesd ezeket a lepeseket:

  • Nyissa meg views.py fájlt, és importálja a Lapozó osztály. 
tól től django.core.paginator import Lapozó
  • Hozzon létre egy nézet funkciót a bejegyzések megjelenítéséhez a HTML-sablonban. 
tól től django.parancsikonok import Vakol
tól től .modellek import Hozzászólás
tól től django.core.paginator import Lapozó
deflista nézet(kérés):
 posts = Post.objects.all()
Visszatérés render (kérés, "blog/blog_list_view.html", {"bejegyzések":posts})
  • Hozzon létre egy URL-mintát, hogy megjelenítse bejegyzéseit a böngészőben. Kezdje az URL-minta konfigurálásával a projektkönyvtárban. Nyissa meg a urls.py fájlt a projekt szintjén, és adja hozzá ezt a URL-minták: 
tól től django.urls import tartalmazza
urlpatterns = [
 ...,
 pálya('', include("blog.urls")),
]

A fenti kódrészletben cserélje ki blog az alkalmazás nevével. Ha nem tud különbséget tenni egy projekt és egy alkalmazás között, tudnod kell miben különbözik egy projekt a Django alkalmazásától.

A fenti konfiguráció elvégzése után hozzon létre a urls.py fájlt az alkalmazáskönyvtárban (ebben az esetben ez a blog mappa), és adja hozzá ezt a kódrészletet:

tól től django.urls import pálya
tól től .nézetek import lista nézet
urlpatterns = [
 pálya('', lista_nézet, név='lista nézet'),
]

Amikor futtatja a szervert, és navigál a http://127.0.0.1:8000/, a böngésző az Ön által megadott stíluslapnak megfelelően jeleníti meg bejegyzéseit.

  • Módosítsa a nézet funkciót oldalszámozási logika hozzáadásához. Íme egy példa: 
deflista nézet(kérés):
 posts = Post.objects.all()
 oldalszámozott = Lapozó (bejegyzések, 3)
 oldal_szám = kérés. GET.get('oldal') #A kért oldalszám lekérése az URL-ből

 oldal = oldalszámozott.get_oldal (oldal_száma)
Visszatérés render (kérés, "blog/blog_list_view.html", {'oldal':page})

A fenti kódrészlet három új változót vezet be: oldalszámú, oldalszám, és oldalon. Mindegyik változó a következőket teszi:

  1. A oldalszámú változó inicializálva a Lapozó osztály. Ebben a forgatókönyvben a lapozandó adat a lekérdezéskészlet, hozzászólások, és tart 3 mint az oldalanként megjelenítendő elemek száma.
  2. A oldalszám változó az oldalszámot az URL-ből kapja. Például be http://127.0.0.1:8000/?page=2, az oldalszám 2.
  3. A oldalon változó lekéri a megjelenítendő oldalt a oldalszámú változó.

Mostanra a Django biztosan lapozgatta az oldaladat. Az ezen a képen látható URL-formátum használatával navigálhat adott oldalszámozott oldalakra:

  • Módosítsa a HTML-sablont, hogy megjelenítse a lapozott oldalak navigációját. A rendelkezésre álló módszerek segítségével Lapozó osztály segítségével egyszerű navigációt hozhat létre az oldalon. Íme egy példa, amelyet hozzáadhat a kezdeti HTML-kódhoz: 
 {% if page.has_previous %}
<ahref="?page={{page.previous_page_number}}"
 class="btn btn-secondary mx-NN">Előzőa>
 {% endif %}
<ahref="?page=1"osztály="btn btn-szekunder">Elsőa>


 {% for num in page.paginator.page_range %}
 {% if num == oldalszám %}
<span>{{ szám }}span>
 {% más %}
<ahref="?page={{num}}"osztály="btn btn-secondary mx-2">
 {{ szám }}
a>
 {% endif %}
 {% endfor %}


<ahref="?page={{page.paginator.num_pages}}"osztály="btn btn-secondary mx-2">
 Utolsó
a>
 {% if page.has_next %}
<ahref="?page={{page.next_page_number}}"osztály="btn btn-secondary mx-2">
 Következő
a>
 {% endif %}

A fenti kódrészletben a következő módszerek használatosak a feltételes utasításokkal együtt annak meghatározására, hogyan fog kinézni a lapozási navigáció:

  1. van_előző: Ez a metódus visszatér Igaz ha az oldalszámozott adatok között van előző oldal.
  2. előző_oldal_szám: Ez a metódus az előző oldal értékét adja vissza.
  3. oldal_tartomány: Ez a módszer lehetővé teszi, hogy megtudja, hány oldal van az oldalszámozott adatok között.
  4. szám: Ez a metódus az aktuális oldal értékét adja vissza.
  5. oldalak_száma: Ez a módszer az oldalak teljes számát adja vissza.
  6. van_következő: Ez a függvény visszatér Igaz ha van egy következő oldal az oldalszámozott adatok között.
  7. következő_oldal_száma: Ez a metódus a következő oldal értékét adja vissza.

Django lapozás osztályalapú nézetben

Osztályalapú nézetben nem kell importálnia és inicializálnia a Lapozó osztály. Az oldalszámozás osztályalapú nézetben való megvalósításához meg kell adnia az úgynevezett attribútumot oldalszámozása. Kövesse az alábbi lépéseket az alkalmazás oldalszámozásához osztályalapú nézetben:

  • Írjon egy osztály alapú nézetet, és adja meg a oldalszámozása tulajdonság. Íme egy egyszerű példa: 
tól től .modellek import Hozzászólás
tól től django.views.generic import Lista nézet
osztályPostListView(Lista nézet):
 modell = Posta
 sablon_neve = "blog/blog_list_view.html"
 kontextus_objektum_neve = 'oldal'
 lapozás_by = 2

A fenti nézet a korábban írt függvény alapú nézet osztály alapú változata. Ez a nézet Djangoét örökli Lista nézet osztály, az elemek felsorolására szolgál. Logikáját olyan attribútumokkal határozza meg, mint pl modell, Sablonnév, kontextus_objektum_neve, és oldalszámozása. A oldalszámozása attribútum határozza meg, hogy hány bejegyzés jelenjen meg egy oldalon; ebben az esetben 2 hozzászólás.

  • Miután létrehozta a nézetet, módosítsa azt urls.py fájlt a használatához. Íme egy egyszerű példa: 
tól től .nézetek import PostListView
urlpatterns = [
 pálya('', PostListView.as_view(), név='lista nézet'),
]
  • Módosítsa a használni kívánt HTML-sablont page_obj az oldalszámozáshoz. 
 {% if page_obj.has_previous %}
<ahref="?page={{page_obj.previous_page_number}}"
 class="btn btn-secondary mx-NN">Előzőa>
 {% endif %}
<ahref="?page=1"osztály="btn btn-szekunder">Elsőa>


 {% for num in page_obj.paginator.page_range %}
 {% if num == page_obj.number %}
<spanosztály="aktuális oldal">{{ szám }}span>
 {% más %}
<ahref="?page={{num}}"osztály="btn btn-secondary mx-2">
 {{ szám }}
a>
 {% endif %}
 {% endfor %}


<ahref="?page={{page_obj.paginator.num_pages}}"
 class="btn btn-secondary mx-NN">
 Utolsó
a>
 {% if page.has_next %}
<ahref="?page={{page_obj.next_page_number}}"
 class="btn btn-secondary mx-NN">
 Következő
a>
 {% endif %}

A függvényalapú nézet HTML-sablonjával ellentétben ez a sablon használja page_obj ahelyett oldalon az oldalobjektum ábrázolására. Ez az alapértelmezett viselkedés az osztályalapú lapozáshoz a Django-ban.

Használja az oldalszámozást az alkalmazás méretezhetővé tételéhez

Az oldalszámozás csökkenti a szerver/adatbázis terhelését azáltal, hogy egyszerre kisebb részhalmazokat kér le és jelenít meg. Az oldalszámozással nő a webhelyek teljesítménye. A felhasználóinak is jó élményben lesz részük az alkalmazás használata során.

Az osztályalapú nézetek több időt és kódot takarítanak meg a funkcióalapú nézetekhez képest, de bármelyiket használhatja preferenciáitól és projektspecifikációitól függően.