Django incluye un marco de caché flexible que admite múltiples niveles de caché (páginas completas, resultados de vistas, fragmentos de plantilla o datos arbitrarios) y múltiples backends (en memoria, Redis, Memcached, base de datos). El caché evita repetir trabajo costoso — una de las optimizaciones de rendimiento de mayor impacto.
CACHES = {
: {
: ,
: ,
}
}
# 1. Per-view caching — cache an entire view's output
from django.views.decorators.cache import cache_page
@cache_page(60 * 15) # cache this view's response for 15 minutes
def article_list(request):
...
<!-- 2. Template fragment caching — cache part of a template -->
{% load cache %}
{% cache 500 sidebar %}
... expensive sidebar rendering ... <!-- cached for 500 seconds -->
{% endcache %}
# 3. Low-level cache API — cache ANY data, full control
from django.core.cache import cache
def get_stats():
stats = cache.get("dashboard_stats") # check cache first
if stats is None: # cache MISS
stats = compute_expensive_stats() # do the work
cache.set("dashboard_stats", stats, 3600) # store for 1 hour
return stats
Django permite cachear a múltiples granularidades: páginas completas (cache_page), fragmentos de plantilla ({% cache %}), y datos arbitrarios a través de la API de bajo nivel (cache.get/cache.set — el patrón flexible de obtener-o-calcular). También hay caché de sitio completo a través de middleware.
# when underlying data changes, the cache must be updated or cleared, or users see stale data
def update_article(article):
article.save()
cache.delete("article_list") # invalidate affected cache entries
# strategies: TTL (accept brief staleness), explicit deletion on writes, versioned keys,
# or signals to invalidate on model save/delete
Cache invalidation is the classic hard problem: when data changes, stale cached
values must be cleared/refreshed. Approaches: short TTLs (accept some staleness),
explicit cache.delete on writes, or cache versioning/key schemes.
✓ Expensive queries/computations, rendered pages/fragments that change infrequently
✓ Aggregations, external API responses, session data
✗ Highly personalized or rapidly-changing data (or use very short TTLs / vary per user)
✗ Don't cache sensitive data carelessly (consider who can read the cache)
El caché es una de las optimizaciones de rendimiento de mayor impacto para aplicaciones Django, y el sistema de caché integral y multinivel del framework lo hace accesible — comprenderlo es un conocimiento valioso de nivel senior para construir aplicaciones rápidas y escalables.
El valor fundamental es evitar trabajo costoso repetido: consultas a la base de datos, cálculos complejos, llamadas a API externas y renderizado de plantillas pueden cachearse para que las solicitudes posteriores se sirvan rápidamente, reduciendo dramáticamente la latencia y la carga de la base de datos/servidor.
La flexibilidad de Django en múltiples niveles de caché (páginas completas con cache_page, fragmentos de plantilla con {% cache %}, y datos arbitrarios a través del patrón obtener-o-calcular de la API de bajo nivel) permite cachear en exactamente la granularidad correcta para cada situación, y sus backends conectables (especialmente Redis para un caché compartido entre múltiples servidores — importante porque los cachés en memoria por proceso no se comparten al escalar horizontalmente) se adaptan a diferentes necesidades de despliegue.
Saber cómo configurar caché, elegir el nivel apropiado y seleccionar el backend correcto para el despliegue es un conocimiento práctico y frecuentemente necesario.
Igualmente importante es comprender la dificultad central del caché — invalidación (el problema famosamente difícil de limpiar o refrescar datos en caché cuando los datos subyacentes cambian, a través de TTLs, eliminación explícita en escrituras o versionado de claves, para evitar servir datos obsoletos) — ya que hacerlo incorrectamente es el fallo de caché clásico que muestra a los usuarios información desactualizada.
También saber qué cachear (datos costosos y que cambian infrecuentemente) versus qué no (datos altamente dinámicos o sensibles) es clave para usar caché efectivamente.
Porque el caché proporciona ganancias de rendimiento importantes pero requiere invalidación cuidadosa, dominar el marco de caché de Django — los niveles, backends, y especialmente las estrategias de invalidación — es un conocimiento importante para construir aplicaciones performantes y escalables y es un sello distintivo de desarrolladores que pueden hacer que las aplicaciones Django sean rápidas bajo carga real.