Pagination results के एक बड़े set को अलग pages में विभाजित करता है, ताकि आप एक साथ हजारों records load न करें। यह performance और usability के लिए आवश्यक है। Django templates/views के लिए एक Paginator class प्रदान करता है, और 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 को pages में slice करता है और get_page() navigation helpers (has_next, next_page_number, आदि) के साथ एक page object लौटाता है — ध्यान दें कि यह query में LIMIT/OFFSET जोड़ता है, इसलिए database से केवल एक page fetch होता है।
# 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 को स्वचालित रूप से paginate करता है, results के साथ 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 वास्तविक data volumes को handle करने वाली performant, usable applications बनाने के लिए आवश्यक है — इसके बिना, listing endpoints और pages जो पूरी tables (संभावित रूप से हजारों या लाखों rows) load करते हैं slow, memory-intensive, और अनुपयोगी हो जाते हैं, database को तनाव में डालते हुए और users और clients दोनों को overwhelm करते हुए।
Pagination को समझना रोजमर्रा का व्यावहारिक ज्ञान है: Django का Paginator traditional views/templates को handle करता है (querysets को navigation helpers के साथ pages में slice करते हुए, LIMIT/OFFSET के माध्यम से केवल एक page कुशलता से fetch करते हुए), और DRF की built-in pagination APIs को handle करती है (configure होने के बाद metadata और navigation links के साथ list endpoints को स्वचालित रूप से paginate करते हुए) — दोनों की आवश्यकता होती है इस पर निर्भर करते हुए कि आप server-rendered pages बना रहे हैं या APIs।
दोनों contexts में pagination को कैसे implement करें यह जानना लगभग किसी भी data-listing feature के लिए आवश्यक है।
performance की बारीकी विशेष रूप से मूल्यवान senior-level ज्ञान है: standard OFFSET-based pagination बहुत बड़ी tables के deep pages पर degrade होती है (database को सभी पूर्ववर्ती rows को skip करना होता है), इसलिए cursor (keyset) pagination बड़े या तेजी से बदलते datasets के लिए कुशल विकल्प है, और pages में inconsistent या duplicated results से बचने के लिए हमेशा एक stable field द्वारा ordering आवश्यक है।
दोनों basic mechanics (Paginator, DRF pagination classes) और इन performance विचारों (OFFSET बनाम cursor pagination, consistent ordering) को समझना उन applications को बनाने के लिए महत्वपूर्ण है जो data बढ़ने पर fast और correct रहती हैं — pagination एक सर्वव्यापी आवश्यकता है, और इसे अच्छी तरह करना, विशेष रूप से scale पर, एक व्यावहारिक skill है जो सीधे application performance और user experience को प्रभावित करती है।