¿Cómo se pagina en Django y DRF?

Question

Accepted Answer

**Paginación** divide un conjunto grande de resultados en páginas discretas, para que no cargues miles de registros de una vez. Es esencial para el rendimiento y la usabilidad. Django proporciona una clase `Paginator` para vistas/plantillas, y DRF ofrece paginación integrada para APIs. ## El problema que resuelve la paginación ```python # ❌ loading everything — slow, memory-heavy, bad UX with thousands of rows articles = Article.objects.all() # could be 100,000 records ``` ## Paginator de Django (para vistas/plantillas tradicionales) ```python 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}) ``` ```html {% for article in page_obj %}

{% endfor %} {% if page_obj.has_previous %}Prev{% endif %} Page {{ page_obj.number }} of {{ page_obj.paginator.num_pages }} {% if page_obj.has_next %}Next{% endif %} ``` El `Paginator` divide un queryset en páginas y `get_page()` devuelve un objeto de página con asistentes de navegación (`has_next`, `next_page_number`, etc.) — nota que añade `LIMIT`/`OFFSET` a la consulta, por lo que solo se obtiene una página de la base de datos. ## Paginación de DRF (para APIs) ```python # 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 pagina automáticamente los endpoints de lista una vez configurado, devolviendo metadatos de página (count, enlaces next/previous) junto con los resultados — los clientes navegan mediante las URLs proporcionadas. ## Estilos de paginación en DRF ```text 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) ``` ## El matiz de rendimiento ```text ⚠️ 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. ``` ## Por qué es importante La paginación es esencial para construir aplicaciones eficientes y usables que manejen volúmenes reales de datos — sin ella, los endpoints de listado y las páginas que cargan tablas completas (potencialmente miles o millones de filas) se vuelven lentos, intensivos en memoria e inutilizables, tanto al sobrecargar la base de datos como al abrumar a usuarios y clientes. Comprender la paginación es conocimiento práctico cotidiano: el **Paginator** de Django maneja vistas/plantillas tradicionales (dividiendo querysets en páginas con asistentes de navegación, obteniendo eficientemente solo una página mediante LIMIT/OFFSET), y la **paginación integrada de DRF** maneja APIs (paginando automáticamente endpoints de lista con metadatos y enlaces de navegación una vez configurado) — ambos son necesarios dependiendo de si estás construyendo páginas renderizadas en el servidor o APIs. Saber cómo implementar paginación en ambos contextos es necesario para casi cualquier característica de listado de datos. El **matiz de rendimiento** es conocimiento particularmente valioso a nivel senior: la paginación basada en OFFSET estándar se degrada en páginas profundas de tablas muy grandes (la base de datos debe omitir todas las filas anteriores), por lo que la **paginación por cursor (keyset)** es la opción eficiente para conjuntos de datos enormes o que cambian rápidamente, y siempre **ordenar por un campo estable** es necesario para evitar resultados inconsistentes o duplicados en las páginas. Comprender tanto la mecánica básica (Paginator, clases de paginación de DRF) como estas consideraciones de rendimiento (paginación OFFSET vs cursor, ordenamiento consistente) es importante para construir aplicaciones que se mantengan rápidas y correctas a medida que los datos crecen — la paginación es un requisito ubicuo, y hacerlo bien, especialmente a escala, es una habilidad práctica que afecta directamente el rendimiento de la aplicación y la experiencia del usuario.