Pagination ਨਤੀਜਿਆਂ ਦੇ ਇੱਕ ਵੱਡੇ ਸੈੱਟ ਨੂੰ ਵੱਖ-ਵੱਖ ਪੰਨਿਆਂ ਵਿੱਚ ਵੰਡਦਾ ਹੈ, ਤਾਂ ਕਿ ਤੁਸੀਂ ਇੱਕ ਵਾਰ ਹਜ਼ਾਰ ਰਿਕਾਰਡ ਲੋਡ ਨਹੀਂ ਕਰਦੇ। ਇਹ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ ਉਪਯੋਗਿਤਾ ਲਈ ਜ਼ਰੂਰੀ ਹੈ। Django Paginator ਕਲਾਸ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ templates/views ਲਈ, ਅਤੇ DRF APIs ਲਈ built-in pagination ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।
# ❌ loading everything — slow, memory-heavy, bad UX with thousands of rows
articles = Article.objects.()
from django.core.paginator import Paginator
def article_list(request):
articles = Article.objects.all().order_by("-created_at") # ORDER matters for consistent pages
paginator = Paginator(articles, 20) # 20 items per page
page_number = request.GET.get("page") # ?page=2
page_obj = paginator.get_page(page_number) # the requested page
return render(request, "list.html", {"page_obj": page_obj})
<!-- in the template -->
{% for article in page_obj %}
<h2>{{ article.title }}</h2>
{% endfor %}
{% if page_obj.has_previous %}<a href="?page={{ page_obj.previous_page_number }}">Prev</a>{% endif %}
Page {{ page_obj.number }} of {{ page_obj.paginator.num_pages }}
{% if page_obj.has_next %}<a href="?page={{ page_obj.next_page_number }}">Next</a>{% endif %}
Paginator ਇੱਕ queryset ਨੂੰ ਪੰਨਿਆਂ ਵਿੱਚ ਸਲਾਈਸ ਕਰਦਾ ਹੈ ਅਤੇ get_page() navigation helpers (has_next, next_page_number, ਆਦਿ) ਦੇ ਨਾਲ ਇੱਕ page object ਵਾਪਸ ਕਰਦਾ ਹੈ — ਧਿਆਨ ਦਿਓ ਕਿ ਇਹ query ਵਿੱਚ LIMIT/OFFSET ਜੋੜਦਾ ਹੈ, ਇਸ ਲਈ database ਤੋਂ ਸਿਰਫ ਇੱਕ page ਲਿਆ ਜਾਂਦਾ ਹੈ।
# global default in settings.py
REST_FRAMEWORK = {
"DEFAULT_PAGINATION_CLASS": "rest_framework.pagination.PageNumberPagination",
"PAGE_SIZE": 20,
}
# now list endpoints are automatically paginated, returning:
# { "count": 1000, "next": "...?page=3", "previous": "...?page=1", "results": [...] }
DRF ਇੱਕ ਵਾਰ configure ਹੋਣ ਤੋਂ ਬਾਅਦ list endpoints ਨੂੰ ਆਪਣੇ ਆਪ ਪ੍ਰਭਾਵਿਤ ਕਰਦਾ ਹੈ, page metadata (count, next/previous links) ਦੇ ਨਾਲ ਨਤੀਜੇ ਵਾਪਸ ਕਰਦਾ ਹੈ — clients ਪ੍ਰਦਾਨ ਕੀਤੇ URLs ਦੇ ਰਾਹੀਂ navigate ਕਰਦੇ ਹਨ।
PageNumberPagination → ?page=2 (simple page numbers)
LimitOffsetPagination → ?limit=20&offset=40 (flexible offsets)
CursorPagination → opaque cursor; consistent & performant for large/changing data
(avoids OFFSET performance issues on huge datasets)
⚠️ OFFSET-based pagination (page/offset) gets SLOWER on deep pages of huge tables
(the DB must skip OFFSET rows). For very large datasets, CURSOR pagination
(keyset, using a WHERE on an indexed column) is far more efficient.
⚠️ Always ORDER BY a stable field, or pages can be inconsistent/repeat items.
Pagination ਉਨ੍ਹਾਂ ਪ੍ਰਦਰਸ਼ਨਸ਼ੀਲ, ਉਪਯੋਗੀ ਐਪਲੀਕੇਸਨਾਂ ਨੂੰ ਬਣਾਉਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ ਜੋ ਅਸਲ ਡੇਟਾ ਵਾਲੀਅਮ ਨੂੰ ਸੰਭਾਲਦੀ ਹਨ — ਇਸ ਦੇ ਬਿਨਾਂ, listing endpoints ਅਤੇ ਪੰਨੇ ਜੋ ਪੂਰੀ ਟੇਬਲਾਂ (ਸੰਭਵ ਤੌਰ ਤੇ ਹਜ਼ਾਰਾਂ ਜਾਂ ਲੱਖਾਂ ਤਾਲੀਮ) ਨੂੰ ਲੋਡ ਕਰਦੇ ਹਨ, ਹੌਲੀ ਬਣ ਜਾਂਦੇ ਹਨ, memory-intensive ਹੋ ਜਾਂਦੇ ਹਨ, ਅਤੇ ਅਯੋਗ ਹੋ ਜਾਂਦੇ ਹਨ, ਜੋ ਕਿ database ਨੂੰ ਤਨਾਅ ਦਿੰਦੇ ਹਨ ਅਤੇ ਉਪਯੋਗਕਰਤਾਵਾਂ ਅਤੇ clients ਨੂੰ ਭਾਰ ਸੰਭਾਲਦੇ ਹਨ।
Pagination ਨੂੰ ਸਮਝਣਾ ਰੋਜ਼ਾਨਾ ਮੁਹਾਰਤ ਹੈ: Django ਦਾ Paginator traditional views/templates ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ (querysets ਨੂੰ navigation helpers ਦੇ ਨਾਲ ਪੰਨਿਆਂ ਵਿੱਚ ਸਲਾਈਸ ਕਰਦਾ ਹੈ, LIMIT/OFFSET ਦੇ ਰਾਹੀਂ ਕੁਸ਼ਲਤਾ ਨਾਲ ਸਿਰਫ ਇੱਕ page ਲੇਂਦਾ ਹੈ), ਅਤੇ DRF ਦਾ built-in pagination APIs ਨਾਲ ਸੰਭਾਲਦਾ ਹੈ (ਇੱਕ ਵਾਰ configure ਹੋਣ ਤੋਂ ਬਾਅਦ metadata ਅਤੇ navigation links ਦੇ ਨਾਲ list endpoints ਨੂੰ ਆਪਣੇ ਆਪ paginate ਕਰਦਾ ਹੈ) — ਦੋਵੇਂ ਜ਼ਰੂਰੀ ਹਨ ਇਸ ਗੱਲ ਦੇ ਅਧਾਰ ਤੇ ਕਿ ਤੁਸੀਂ server-rendered ਪੰਨੇ ਜਾਂ APIs ਬਣਾ ਰਹੇ ਹੋ।
ਦੋਵੇਂ contexts ਵਿੱਚ pagination ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਜਾਣਨਾ ਲਗਭਗ ਕਿਸੇ ਵੀ data-listing feature ਲਈ ਜ਼ਰੂਰੀ ਹੈ।
Performance nuance ਖਾਸ ਤੌਰ 'ਤੇ ਕੀਮਤੀ senior-level ਗਿਆਨ ਹੈ: standard OFFSET-based pagination ਬਹੁਤ ਵੱਡੀ ਟੇਬਲਾਂ ਦੇ ਡੂੰਘੇ ਪੰਨਿਆਂ ਤੇ ਖਰਾਬ ਪ੍ਰਦਰਸ਼ਨ ਕਰਦਾ ਹੈ (database ਨੂੰ ਸਾਰੀਆਂ ਪੂਰਵ-ਵਰਤੀ ਤਾਲੀਮਾਂ ਨੂੰ skip ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ), ਇਸ ਲਈ cursor (keyset) pagination ਬਹੁਤ ਵੱਡੇ ਜਾਂ ਤੇਜ਼ੀ ਨਾਲ ਬਦਲਣ ਵਾਲੇ datasets ਲਈ ਕੁਸ਼ਲ ਚੋਣ ਹੈ, ਅਤੇ ਹਮੇਸ਼ਾ ਇੱਕ stable field ਦੁਆਰਾ ordering ਪੰਨਿਆਂ ਤੋਂ ਅਸੰਗਤ ਜਾਂ ਡੁਪਲੀਕੇਟ ਨਤੀਜੇ ਤੋਂ ਬਚਣ ਲਈ ਜ਼ਰੂਰੀ ਹੈ।
ਬੋਥ basic mechanics (Paginator, DRF pagination classes) ਅਤੇ ਇਹਨਾਂ performance considerations (OFFSET vs cursor pagination, consistent ordering) ਨੂੰ ਸਮਝਣਾ ਉਨ੍ਹਾਂ ਐਪਲੀਕੇਸਨਾਂ ਨੂੰ ਬਣਾਉਣ ਲਈ ਮਹੱਤਵਪੂਰਨ ਹੈ ਜੋ ਡੇਟਾ ਵਧਣ ਨਾਲ ਤੇਜ਼ ਅਤੇ ਸਹੀ ਰਹਿੰਦੀਆਂ ਹਨ — pagination ਇੱਕ ਸਰਵ-ਵਿਆਪਕ ਜ਼ਰੂਰਤ ਹੈ, ਅਤੇ ਇਸ ਨੂੰ ਚੰਗੀ ਤਰ੍ਹਾਂ ਕਰਨਾ, ਖਾਸ ਤੌਰ 'ਤੇ scale ਤੇ, ਇੱਕ ਮੁਹਾਰਤ ਹੈ ਜੋ ਸਿੱਧੇ ਐਪਲੀਕੇਸ਼ਨ ਪ੍ਰਦਰਸ਼ਨ ਅਤੇ user experience ਨੂੰ ਪ੍ਰਭਾਵਿਤ ਕਰਦੀ ਹੈ।