పేజినేషన పెద్ద సమితి ఫలితాలను వేర్వేరు పేజీలుగా విభజిస్తుంది, కాబట్టి మీరు వేలాది రికార్డ్లను ఒకేసారి లోడ్ చేయవలసి లేదు. ఇది పనితీరు మరియు ఉపయోగకారితకు అవసరం. Django పేరు చేసిన Paginator క్లాస్ను టెంప్లేట్ల/వ్యూల కోసం అందిస్తుంది, మరియు DRF API ల కోసం నిర్మిత-లో పేజినేషన్ అందిస్తుంది.
# ❌ 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() నావిగేషన్ సహాయకాలు (has_next, next_page_number, మొదలైనవి)తో పేజీ ఆబ్జెక్ట్ను అందిస్తుంది — ఇది LIMIT/OFFSETను ప్రశ్నకు జోడిస్తుంది, కాబట్టి డేటాబేస్ నుండి ఒక పేజీ మాత్రమే పొందబడుతుంది.
# 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 ఒకసారి కాన్ఫిగర్ చేయబడితే తాదాత్మ్య పేజీ ఎండ్పాయింట్లను ఆటోమేటిక్గా పేజిනేట్ చేస్తుంది, ఫలితాలు పక్కన పేజీ మెటాడేటా (గణన, తరువాత/మునుపటి లింకులు) తిరిగి ఇస్తుంది — క్లায়েంట్లు అందించిన URL ల ద్వారా నావిగేట్ చేస్తారు.
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.
పేజినేషన్ వాస్తవ డేటా వాల్యూమ్లను నిర్వహించే పనితీరు ఉన్న, ఉపయోగకారిత అనుకూల అనువర్తనాలను నిర్మించడానికి అవసరం — దీని లేకుండా, ఎండ్పాయింట్లను జాబితా చేయడం మరియు సమগ్ర పట్టికలను (సంభవ్యమైన వేలవేల లేదా లక్షల వరుసలు) లోడ్ చేసే పేజీలు నెమ్మదిగా, మెమరీ-ఇంటెన్సివ్ మరియు ఉపయోగించలేనివిగా మారుతాయి, డేటాబేస్కు సమ్మెళ్ళు ఇచ్చి వినియోగదారులు మరియు క్లায়েంట్లను ఆధిక్యంగా భరిస్తాయి.
పేజినేషన్ను అర్థం చేసుకోవడం రోజువారీ ఆచరణాత్మక జ్ఞానం: Django యొక్క Paginator సాంప్రదాయ వ్యూల/టెంప్లేట్లను నిర్వహిస్తుంది (querysets ని నావిగేషన్ సహాయకాలతో పేజీలుగా కత్తిరించి, LIMIT/OFFSET ద్వారా సమర్థవంతంగా ఒక పేజీ మాత్రమే పొందుతుంది), మరియు DRF యొక్క నిర్మిత-లో పేజినేషన్ API ల నిర్వహిస్తుంది (ఒకసారి కాన్ఫిగర్ చేయబడితే మెటాడేటా మరియు నావిగేషన్ లింకులతో తాదాత్మ్య ఎండ్పాయింట్లను ఆటోమేటిక్గా పేజినేట్ చేస్తుంది) — సర్వర్-రెండర్ చేసిన పేజీలు లేదా API ల నిర్మాణం చేస్తున్నారో లేనిపై ఆధారపడి రెండూ అవసరం.
రెండు సందర్భాలలో పేజినేషన్ నిర్వహణ ఎలా చేయాలో తెలుసుకోవడం దాదాపు ఏదైనా డేటా-జాబితా సమన్వయ కోసం అవసరం.
పనితీరు సూక్ష్మమైనది ప్రత్యేకంగా విలువైన సిన్యర్-స్థర జ్ఞానం: ప్రామాణిక OFFSET-ఆధారిత పేజినేషన్ చాలా పెద్ద పట్టికల యొక్క లోతైన పేజీలపై క్షీణిస్తుంది (డేటాబేస్ అన్ని ముందు సంభవించే వరుసలను దాటవేయాలి), కాబట్టి కర్సర్ (keyset) పేజినేషన్ హిందూ లేదా వేగంగా మారుతున్న డేటాసెట్ల కోసం సమర్థవంతమైన ఎంపిక, మరియు ఎల్లప్పుడు స్థిరమైన ఫీల్డ్ ద్వారా ఆర్డర్ చేయడం పేజీల్లో అసంగత లేదా నకిలీ ఫలితాలను నివారించడానికి అవసరం.
ప్రాథమిక మెకానిక్స్ (Paginator, DRF పేజినేషన్ క్లాసులు) మరియు ఈ పనితీరు పరిగణనలు (OFFSET vs కర్సర్ పేజినేషన్, సంగతమైన ఆర్డర్) రెండింటినీ అర్థం చేసుకోవడం డేటా విస్తరించినప్పుడు వేగంగా మరియు సరిగా ఉండే అనువర్తనాలను నిర్మించడానికి ముఖ్యమైనది — పేజినేషన్ సర్వసాధారణ అవసరం, మరియు దీన్ని సరిగా చేయడం, ప్రత్యేకించి స్కేల్పై, అనువర్తన పనితీరు మరియు వినియోగదారి అనుభవాన్ని నేరుగా ప్రభావితం చేసే ఆచరణాత్మక నైపుణ్యం.