Skip to content

2. Vistas, enrutamiento, respuestas

Este capítulo examina el camino que sigue una solicitud, desde el navegador hasta la vista que la procesa, y la respuesta que esa vista devuelve. Las plantillas no se introducirán hasta el capítulo 3: aquí, las vistas devuelven texto o JSON directamente.

2.1. Ejemplo 01: la estructura de una aplicación Django

El primer ejemplo es la aplicación [Django] más pequeña posible. Un proyecto creado con [django-admin startproject] contiene seis archivos, y una aplicación creada con [python manage.py startapp] contiene siete más (véase la introducción); aquí conservamos solo aquellos sin los cuales la aplicación no puede funcionar:

1
2
3
4
5
6
7
01-structure/
├── config/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py
  • [manage.py]: la herramienta de línea de comandos del proyecto. Sirve para iniciar el servidor de desarrollo y ejecutar muchos otros comandos;
  • [config]: un paquete [Python], es decir, una carpeta que contiene módulos [Python] (archivos [.py]) y un archivo [__init__.py]. Para importar un módulo de un paquete, se escribe [config.settings] (el archivo [config/settings.py]);
  • [config/settings.py]: la configuración de la aplicación;
  • [config/urls.py]: las rutas de la aplicación y, en este primer ejemplo, su única vista;
  • [config/wsgi.py]: el punto de entrada de la aplicación para un servidor web;
  • [config/__init__.py]: el archivo que convierte la carpeta [config] en un paquete. A menudo está vacío; el nuestro contiene solo un comentario.

2.1.1. El punto de entrada: config/wsgi.py

[Python] tiene un estándar para las aplicaciones web: WSGI (Web Server Gateway Interface, que se pronuncia “whiskey”). Define cómo un servidor web transmite una solicitud a una aplicación [Python] y cómo recibe la respuesta. Todos los servidores web [Python] ([gunicorn], [waitress], [uWSGI], el servidor de desarrollo de [Django]...) saben llamar a una aplicación WSGI, y todos los frameworks web de [Python] ([Django], [Flask]...) generan una. El archivo [config/wsgi.py] genera la de nuestro proyecto:

# config/wsgi.py: el punto de entrada de la aplicación para un servidor web (estándar WSGI)

import os

from django.core.wsgi import get_wsgi_application

# el módulo de configuración, como en manage.py
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")

# la APLICACIÓN: el objeto que el servidor llama por cada solicitud recibida
application = get_wsgi_application()
  • Línea 1: un comentario, desde [#] hasta el final de la línea. Todos los archivos de los ejemplos comienzan con un comentario que indica su nombre y su propósito;
  • línea 3: la instrucción [import] importa un módulo: en este caso, [os], un módulo de la biblioteca estándar de [Python], que da acceso al sistema operativo y, en particular, a las variables de entorno del proceso ([os.environ]);
  • línea 5: [from ... import ...] importa un nombre de un módulo: la función [get_wsgi_application] del módulo [django.core.wsgi]. El nombre completo de un módulo indica su ubicación: [django.core.wsgi] es el archivo [wsgi.py] de la carpeta [core] del paquete [django], instalado en el entorno virtual (véase la introducción). Después de esta importación, se puede nombrar simplemente [get_wsgi_application];
  • línea 8: [Django] obtiene su configuración mediante la variable de entorno [DJANGO_SETTINGS_MODULE], que contiene el nombre del módulo de configuración: [config.settings]. [os.environ] se comporta como un diccionario; su método [setdefault] le asigna un valor, salvo que ya tenga uno: una variable de entorno real, definida antes de iniciar el servidor, tiene prioridad;
  • línea 11: [get_wsgi_application()] prepara [Django]: lee la configuración, configura el registro de eventos, carga las aplicaciones del proyecto (ejemplo 02) y luego devuelve la aplicación WSGI, almacenada en la variable [application]. Es esta variable la que el servidor web busca en el archivo. En [Python], una variable no se declara: se crea en su primera asignación y puede contener valores de cualquier tipo.

La aplicación WSGI es un objeto que el servidor llama, por cada solicitud que recibe, con los detalles de la solicitud; el objeto devuelve la respuesta. Toda la aplicación es, por lo tanto, una función que transforma una solicitud en una respuesta. En el medio, [Django] crea un objeto de solicitud ([HttpRequest]), encuentra la vista encargada de procesarla (enrutamiento), la llama y recupera el objeto de respuesta ([HttpResponse]) que esta produce, el cual transmite luego al servidor.

Este archivo se ejecuta una sola vez, cuando se inicia el servidor. Es la diferencia clave con [PHP], que los lectores del curso de [Symfony] han visto en acción: en [PHP], la aplicación se reconstruye en cada solicitud y luego se descarta; en [Python], se construye una sola vez, al iniciar, y luego permanece en memoria para procesar todas las solicitudes posteriores. La configuración, la tabla de enrutamiento, los módulos importados y los objetos almacenados en variables de módulo, todo esto se construye una vez y es compartido por todas las solicitudes. Esto es rápido, pero exige cautela: los datos modificados por una solicitud son visibles para las solicitudes siguientes y, si el servidor procesa varias solicitudes a la vez (el servidor de desarrollo lo hace, con un hilo por solicitud), dos solicitudes pueden modificar los mismos datos simultáneamente. Volveremos sobre esto en el ejemplo 06 y, sobre todo, en el capítulo sobre los ámbitos de datos.

[Python] tiene un segundo estándar, más reciente: ASGI (Asynchronous Server Gateway Interface), para aplicaciones asíncronas (como WebSockets, por ejemplo). [Django] puede generar ambas; el archivo [asgi.py] creado por [django-admin startproject] genera la aplicación ASGI. Nos quedaremos con WSGI.

2.1.2. La configuración: config/settings.py

# config/settings.py: la CONFIGURACIÓN de la aplicación, reducida a lo esencial

from pathlib import Path

# la carpeta del proyecto: la que contiene manage.py
BASE_DIR = Path(__file__).resolve().parent.parent

# modo de depuración: un error muestra una página detallada, el servidor de desarrollo
# sirve los archivos estáticos... ¡Nunca en producción!
DEBUG = True

# la clave secreta de la aplicación (firmas, tokens anti-CSRF...), propia de cada proyecto
SECRET_KEY = "django-insecure-o%dj0-lrbi!9py48(5i0j0v8bpz%3@n6c!1daacp&r0tk+u16&"

# los nombres de host que la aplicación acepta atender; en modo de depuración, una lista vacía
# equivale a ["localhost", "127.0.0.1", "[::1]"]
ALLOWED_HOSTS = []

# el idioma y la zona horaria de la aplicación
LANGUAGE_CODE = "en"
TIME_ZONE = "Europe/Paris"

# el módulo que contiene las RUTAS de la aplicación: el archivo config/urls.py
ROOT_URLCONF = "config.urls"

# la aplicación WSGI, que el servidor llama por cada solicitud (config/wsgi.py)
WSGI_APPLICATION = "config.wsgi.application"

Los parámetros de configuración de [Django] son variables del módulo [config.settings], escritas en mayúsculas. Es un archivo [Python] estándar: en él se pueden calcular valores, leer variables de entorno e importar otros módulos. [Django] solo exige unos pocos parámetros; todos los demás tienen un valor predeterminado, definido en el módulo [django.conf.global_settings] de [Django] (más de 150 parámetros). El comando [python manage.py diffsettings] muestra los parámetros que difieren de sus valores predeterminados:

  • línea 3: [pathlib] es el módulo de la biblioteca estándar que maneja las rutas de archivos. Un objeto [Path] representa una ruta; se escribe igual en [Windows] y en los demás sistemas;
  • línea 6: la carpeta del proyecto. [__file__] es la ruta del archivo actual ([config/settings.py]); [resolve()] la convierte en absoluta; [.parent] designa la carpeta que lo contiene ([config]), y [.parent.parent] designa la carpeta superior: la carpeta [01-structure]. Este parámetro, [BASE_DIR], no es un parámetro de [Django]: es una comodidad que otros parámetros utilizarán para referirse a las carpetas del proyecto ([BASE_DIR / "templates"], ejemplo 13: el operador [/] combina dos segmentos de ruta);
  • línea 10: modo de depuración. Si se establece en [True], una excepción no controlada muestra una página de error detallada (ejemplo 03), y el servidor de desarrollo sirve él mismo los archivos estáticos (ejemplo 15). Este modo está pensado para el desarrollo, y solo para el desarrollo: la página de error revela el código fuente y la configuración de la aplicación;
  • línea 13: la clave secreta de la aplicación: una cadena aleatoria que [Django] usa para firmar ciertos datos (cookies firmadas, tokens anti-CSRF, enlaces de restablecimiento de contraseña, etc.). Este parámetro es obligatorio: sin él, [Django] se negará a iniciar. Cada ejemplo tiene la suya. El prefijo [django-insecure-] es el que utiliza [django-admin startproject]: sirve como recordatorio de que esta clave, escrita directamente en el código fuente, no debe usarse en producción, donde la clave se suministra mediante una variable de entorno (caso de estudio);
  • línea 17: los nombres de host que la aplicación está configurada para atender (el encabezado [Host] de la solicitud). Es una salvaguarda contra solicitudes que identifican falsamente el sitio de destino. En modo de depuración, una lista vacía equivale a [localhost], [127.0.0.1] y [::1]; fuera del modo de depuración, debe completarse; de lo contrario, [python manage.py runserver] se negará a iniciar. En [Python], [[a, b]] es una lista;
  • líneas 20–21: el idioma de la aplicación ([en]: las fechas, los números y los mensajes de [Django] están en inglés; véase el ejemplo 06) y su zona horaria. Las cadenas pueden delimitarse con comillas dobles o simples; los ejemplos usan comillas dobles;
  • línea 24: el módulo que contiene las rutas de la aplicación: [config.urls], es decir, el archivo [config/urls.py];
  • línea 27: la aplicación WSGI, indicada por su ruta completa: la variable [application] del módulo [config.wsgi]. Es la que inicia el servidor de desarrollo.

2.1.3. Rutas y vista: config/urls.py

# config/urls.py: las RUTAS de la aplicación y, para este primer ejemplo, su única vista

from django.http import HttpResponse
from django.urls import path


# una VISTA: la función que Django llama para la solicitud GET /. Recibe la
# solicitud y devuelve la respuesta
def home(request):
    # la respuesta enviada al navegador
    return HttpResponse("Hello from Django!")


# la tabla de enrutamiento: la ruta "" (la raíz del sitio) se asocia con la vista home
urlpatterns = [
    path("", home),
]
  • líneas 3–4: importación de la clase [HttpResponse], la respuesta HTTP, y de la función [path], que declara una ruta;
  • líneas 9–11: una vista, es decir, una función que recibe la solicitud y devuelve la respuesta. [def] define una función; su cuerpo es el bloque con sangría que sigue a los dos puntos. En [Python], la sangría no es solo una cuestión de formato: es lo que delimita los bloques (mientras que [PHP] y [Java] usan llaves). El parámetro [request] recibe la solicitud, un objeto [HttpRequest] que [Django] siempre pasa en primer lugar a una vista (ejemplo 05); es una convención de [Django] llamarlo [request];
  • línea 11: la vista devuelve un objeto [HttpResponse], cuyo primer parámetro es el cuerpo de la respuesta. En [Python], un objeto se crea llamando a su clase como una función, sin la palabra clave [new]. Esta es la regla de [Django]: una vista siempre devuelve un objeto [HttpResponse] (ejemplo 03);
  • líneas 15–17: la tabla de enrutamiento. [Django] busca en el módulo [ROOT_URLCONF] una variable llamada [urlpatterns]: una lista de rutas. La ruta [path("", home)] asocia la ruta vacía (la raíz del sitio, [/]) con la vista [home]. Observe que la ruta de una ruta se escribe sin la barra inicial: [Django] la elimina de la ruta solicitada antes de compararla con las rutas. Observe también que se pasa a la función misma ([home], sin paréntesis) [path], y no su resultado: en [Python], una función es un objeto como cualquier otro, que se puede almacenar en una variable o pasar a otra función. [Django] la llamará más tarde, en cada solicitud a [/]. Se permite una coma después del último elemento de la lista, y es una práctica habitual cuando los elementos se escriben uno por línea.

En un proyecto real, las vistas nunca se escriben en el archivo de rutas: van en los archivos [views.py] de la aplicación (ejemplo 02). Aquí lo hicimos así para mantener el ejemplo sencillo.

2.1.4. La herramienta manage.py

El archivo [manage.py] es un script [Python] que prepara [Django], igual que [config/wsgi.py], pero para ejecutar un comando en lugar de procesar solicitudes:

#!/usr/bin/env python
# manage.py: la herramienta de línea de comandos de Django (python manage.py runserver...)

import os
import sys


def main():
    # el módulo que contiene la configuración de la aplicación: config/settings.py
    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "config.settings")
    # Django ejecuta el comando solicitado en la línea de comandos (runserver, check...)
    from django.core.management import execute_from_command_line
    execute_from_command_line(sys.argv)


if __name__ == "__main__":
    main()
  • línea 1: en [Linux] y [macOS], esta línea permite ejecutar el archivo directamente ([./manage.py]); en [Windows], siempre se escribe [python manage.py];
  • línea 10: el módulo de configuración, como en [config/wsgi.py];
  • líneas 12–13: una importación también puede realizarse dentro de una función. [execute_from_command_line] ejecuta el comando solicitado: [sys.argv] es la lista de parámetros de la línea de comandos ([["manage.py", "runserver"]]);
  • líneas 16–17: [__name__] es igual a ["__main__"] cuando el archivo se ejecuta directamente ([python manage.py]), y al nombre del módulo cuando se importa. Esta condición, presente en muchos scripts de [Python], llama a la función [main] solo en el primer caso.

[python manage.py help] muestra la lista de comandos disponibles: veinticinco en este ejemplo, y más cuando se agregan funcionalidades de [Django] (archivos estáticos, sesiones, autenticación, etc.). Usaremos varios de ellos: [runserver], [check] (verificación del proyecto), [shell] (una consola de [Python] en la que [Django] está listo para usarse), [makemessages] y [compilemessages] (traducciones, ejemplo 22), [collectstatic] (archivos estáticos, caso de estudio; la aplicación [django.contrib.staticfiles] lo agrega). [django-admin] (véanse los apéndices) es la misma herramienta, pero no sabe dónde se encuentra la configuración del proyecto.

2.1.5. Ejecución

En una ventana de terminal abierta en la carpeta [01-structure], donde se ha activado el entorno virtual de los ejemplos (véase la introducción), escriba [python manage.py runserver]. [Django] muestra:

Watching for file changes with StatReloader
Performing system checks...

System check identified no issues (0 silenced).
September 27, 2026 - 19:14:50
Django version 6.1.1, using settings 'config.settings'
Starting WSGI development server at http://127.0.0.1:8000/
Quit the server with CONTROL-C.

WARNING: This is a development server. Do not use it in a production setting. Use a production WSGI or ASGI server instead.
For more information on production servers see: https://docs.djangoproject.com/en/6.1/howto/deployment/

El comando [runserver] inicia el servidor de desarrollo integrado en [Django]. Primero realiza verificaciones del sistema en el proyecto: los parámetros ausentes o incoherentes, o las rutas mal escritas, producirán aquí errores o advertencias, antes de que se haga cualquier solicitud. Luego escucha en el puerto 8000 de la propia máquina ([127.0.0.1], [localhost]): solo acepta solicitudes de esta máquina, lo cual es adecuado para el desarrollo ([python manage.py runserver 0.0.0.0:8000] lo abriría a otras máquinas de la red). Se detiene con [Ctrl-C]. Este servidor está pensado para el desarrollo, como indica su advertencia: en producción será un servidor WSGI, como [gunicorn] o [waitress] (véase el caso de estudio).

La primera línea indica que el servidor supervisa los archivos del proyecto ([StatReloader]: compara periódicamente sus fechas de modificación). Como la aplicación permanece en memoria, un cambio en un archivo [Python] no sería detectado por la aplicación en ejecución; por eso, el servidor de desarrollo se reinicia automáticamente en cuanto un archivo cambia. No es necesario reiniciarlo manualmente, salvo después de agregar un archivo nuevo que nadie ha importado todavía.

Accedamos a la URL [http://localhost:8000/] con un navegador:

Image

y luego con [curl]. La opción [-i] también muestra los encabezados HTTP de la respuesta:

curl -i http://localhost:8000/
1
2
3
4
5
6
7
HTTP/1.1 200 OK
Date: Sun, 27 Sep 2026 17:14:50 GMT
Server: WSGIServer/0.2 CPython/3.13.13
Content-Type: text/html; charset=utf-8
Connection: close

Hello from Django!

La primera línea de la respuesta contiene la versión del protocolo, el código de estado (200) y su etiqueta ([OK]). Luego vienen los encabezados: la fecha, el servidor (el servidor WSGI de la biblioteca estándar de [Python], sobre el que se construye el servidor de desarrollo), el tipo de contenido y [Connection: close] (el servidor de desarrollo cierra la conexión después de cada respuesta). Una línea en blanco separa los encabezados del cuerpo de la respuesta. En el resto de este documento ya no incluiremos los encabezados [Date], [Server] y [Connection], pues no varían.

El encabezado [Content-Type: text/html; charset=utf-8] indica que la respuesta es HTML, con los caracteres codificados en UTF-8. Es la elección de [Django] para una respuesta cuya vista no especificó el tipo: el navegador interpreta entonces la cadena como HTML (aquí, al no haber etiquetas, se muestra tal cual). El ejemplo 03 mostrará cómo especificar un tipo distinto. La respuesta es mínima: no hay encabezado [Content-Length], ni cookies, ni encabezados de seguridad. Estos los agrega el middleware de [Django] (ejemplo 03), y nuestra aplicación no tiene ninguno.

Por cada solicitud, la consola del servidor muestra una entrada de registro: la fecha, los detalles de la solicitud (método, ruta, protocolo), el código de respuesta y el tamaño del cuerpo de la respuesta en bytes:

[27/Sep/2026 19:14:50] "GET / HTTP/1.1" 200 18

Modifiquemos el texto de la línea 11 de [config/urls.py] y guardemos el archivo: la consola muestra [.../01-structure/config/urls.py changed, reloading.], seguido de las líneas de inicio. La siguiente solicitud recibe el nuevo texto.

2.2. Ejemplo 02: enrutamiento

El enrutamiento asocia una URL con una vista. Escribir todas las vistas directamente en el archivo de enrutamiento pronto sería ilegible; en cambio, se organizan en aplicaciones. Una aplicación [Django] es un paquete [Python] que agrupa todo lo relacionado con un único dominio: sus vistas, sus rutas y, más adelante, sus plantillas, formularios y modelos. Un proyecto es un conjunto de aplicaciones. El ejemplo 02 tiene dos:

02-routing/
├── config/
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── first/
│   ├── __init__.py
│   ├── urls.py
│   └── views.py
├── home/
│   ├── __init__.py
│   └── views.py
└── manage.py

Los archivos [manage.py], [config/__init__.py], y [config/wsgi.py] son los del ejemplo 01: no volveremos a mencionarlos. El archivo [config/settings.py] siempre comienza con los mismos parámetros (solo cambian el nombre del ejemplo y la clave secreta); comentaremos únicamente los parámetros que agrega cada ejemplo. Esta es la lista de aplicaciones:

# config/settings.py: la configuración del ejemplo 02

from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent
DEBUG = True
SECRET_KEY = "django-insecure-tux4f(1*-79v%n@x(-h*y81q+iwyjg@yo0%ksc_ow1vjpf(0va"
ALLOWED_HOSTS = []
LANGUAGE_CODE = "en"
TIME_ZONE = "Europe/Paris"
ROOT_URLCONF = "config.urls"
WSGI_APPLICATION = "config.wsgi.application"

# las APLICACIONES del proyecto: cada una es un paquete de Python (una carpeta) que
# agrupa las vistas, las rutas y, más adelante, los modelos y las plantillas de un mismo
# dominio
INSTALLED_APPS = [
    "home",
    "first",
]
  • líneas 17–20: el parámetro [INSTALLED_APPS] enumera las aplicaciones del proyecto, identificadas por los nombres de sus paquetes. [Django] las carga al iniciar, en este orden. Para nuestro ejemplo, la declaración no es esencial: las vistas de [home] y [first] se encuentran mediante importaciones desde los archivos de rutas. Se volverá esencial en cuanto las aplicaciones incluyan plantillas (ejemplo 13), etiquetas de plantilla (ejemplo 16), traducciones (ejemplo 22) o modelos del ORM (ejemplo 28), que [Django] busca únicamente en las aplicaciones declaradas. [Django] mismo proporciona varias aplicaciones ([django.contrib.sessions], [django.contrib.messages], [django.contrib.staticfiles], [django.contrib.admin]...), que se declaran de la misma manera.

2.2.1. La vista de la aplicación home

# home/views.py: la página de inicio

from django.http import HttpResponse
from django.views.decorators.http import require_GET


# GET /: una página HTML que contiene enlaces a las vistas de la primera aplicación.
# El decorador @require_GET rechaza cualquier método HTTP distinto de GET (incluso HEAD)
@require_GET
def index(request):
    return HttpResponse("""
<h2>Example 02 - routing</h2>
<ul>
  <li><a href="/first/">/first/</a></li>
  <li><a href="/first/action01">/first/action01</a></li>
  <li><a href="/first/products/17">/first/products/17</a></li>
  <li><a href="/first/products/17/reviews/3">/first/products/17/reviews/3</a></li>
  <li><a href="/first/files/images/logo.png">/first/files/images/logo.png</a></li>
  <li><a href="/first/products/abc">/first/products/abc</a></li>
  <li><a href="/unknown">/unknown</a></li>
</ul>
""")
  • línea 4: importación de un decorador de [Django];
  • líneas 9–10: un decorador es una función que envuelve a otra función para modificar su comportamiento. Se escribe como [@name] encima de la definición de la función: [@require_GET] encima de [def index] equivale a escribir [index = require_GET(index)] después de la definición. La función [index] se reemplaza por una función que primero verifica el método HTTP de la solicitud: si no es GET, responde ella misma con un error 405, sin llamar a [index]. Sin decorador, una vista acepta todos los métodos. El módulo [django.views.decorators.http] también contiene [require_POST], [require_safe] (GET y HEAD) y [require_http_methods(["GET", "POST"])]. Observe que [require_GET] rechaza incluso las solicitudes con el método HEAD (la misma solicitud que GET, sin el cuerpo de la respuesta): [require_safe] es necesario para aceptarlas. Por convención, el nombre de una función o variable en [Python] se escribe en minúsculas, con las palabras separadas por guiones bajos ([require_GET] es una excepción), mientras que el nombre de una clase lleva una letra mayúscula al comienzo de cada palabra ([HttpResponse]);
  • líneas 11–22: una cadena de varias líneas, delimitada por tres comillas (["""]). La vista devuelve HTML, enviado con el tipo [text/html] (véase el ejemplo 01).

La vista [index] devuelve así una página HTML que contiene enlaces a vistas de la otra aplicación:

Image

2.2.2. Las vistas de la aplicación first

# first/views.py: las vistas de las URL /first...

from django.http import HttpResponse
from django.views import View
from django.views.decorators.http import require_GET


# GET /first/
@require_GET
def index(request):
    return HttpResponse("View [index] of the [first] application")


# GET y POST /first/action01: la misma URL, dos métodos HTTP, dos métodos de
# la clase. Un método HTTP que la clase no maneja (PUT...) es rechazado
class Action01(View):
    def get(self, request):
        return HttpResponse("View [Action01], method [get]: GET request")

    def post(self, request):
        return HttpResponse("View [Action01], method [post]: POST request")


# GET /first/products/17: el parámetro de ruta id se pasa al parámetro id de la
# vista, ya convertido a entero
@require_GET
def product(request, id):
    return HttpResponse(f"Product no. {id}")


# GET /first/products/17/reviews/3: los parámetros de ruta se pasan por su NOMBRE
@require_GET
def review(request, number, id):
    return HttpResponse(f"Review no. {number} of product no. {id}")


# GET /first/files/images/logo.png
@require_GET
def file(request, path):
    return HttpResponse(f"Requested file: {path}")
  • líneas 9–11: una vista como función, igual que en el ejemplo 01;
  • líneas 16–21: una vista también puede ser una clase que hereda de la clase [View] de [Django]. En [Python], la herencia se escribe colocando la clase padre entre paréntesis después del nombre de la clase. La clase tiene un método por cada método HTTP que implementa, con el nombre del método HTTP en minúsculas: [get] para GET, [post] para POST. [Django] llama al método que corresponde a la solicitud; un método HTTP que no es manejado por ningún método de la clase produce un error 405. Un método de [Python] siempre recibe, como primer parámetro, el objeto sobre el que se lo llama (llamado convencionalmente [self]), seguido de la solicitud. Es la forma más clara de manejar varios métodos HTTP en la misma URL (una función tendría que evaluar [request.method] por sí misma; véase el ejemplo 11). [Django] también ofrece vistas genéricas, clases listas para usar para necesidades comunes ([TemplateView], [ListView], [FormView]...), que este documento no utiliza: ocultan justamente lo que queremos mostrar;
  • líneas 26–28: una vista que recibe un parámetro de ruta, [id], después de la solicitud. El valor ya está convertido en entero (véase más adelante). La cadena [f"Product no. {id}"] es una f-string: las expresiones escritas entre llaves se reemplazan por sus valores;
  • líneas 32–34: dos parámetros de ruta. [Django] los pasa a la vista por nombre (parámetros con nombre): el orden de los parámetros de la vista no importa. Aquí, [number] se escribe antes que [id];
  • líneas 38–40: un parámetro de ruta que contiene barras.

2.2.3. Las rutas: config/urls.py y first/urls.py

Falta todavía asociar las URL con las vistas. La tabla de enrutamiento principal, para el parámetro [ROOT_URLCONF]:

# config/urls.py: la tabla de enrutamiento PRINCIPAL del proyecto

from django.urls import include, path

from home import views as home_views

urlpatterns = [
    # GET /: la vista index de la aplicación home; name: el NOMBRE de la ruta
    path("", home_views.index, name="home"),
    # todas las URL que empiezan con first/ se delegan a la tabla de enrutamiento
    # de la aplicación first (archivo first/urls.py), sin este prefijo
    path("first/", include("first.urls")),
]
  • línea 5: importa el módulo [views] de la aplicación [home] con otro nombre: [as home_views]. Dos aplicaciones pueden tener cada una un módulo llamado [views]; cambiarle el nombre evita confusiones;
  • línea 9: la ruta de la raíz del sitio. El tercer parámetro, [name], da un nombre a la ruta: este nombre se usará para generar su URL (ejemplo 04) sin escribirla directamente en el código. [Python] acepta parámetros por posición o por nombre ([name="home"]): los parámetros con nombre hacen la llamada más legible;
  • línea 12: [include] delega una parte de las URL a otra tabla de enrutamiento: todas las URL que comienzan con [first/] se asignan a las rutas del módulo [first.urls], al que [Django] solo le pasa el final de la ruta. Cada aplicación conserva así sus rutas en su propio archivo [urls.py], y el proyecto solo decide bajo qué prefijo se montan. El prefijo termina con una barra diagonal: es la convención que usa [Django], donde las rutas de las aplicaciones nunca comienzan con una barra diagonal.
# first/urls.py: las rutas de la aplicación first. Las rutas se escriben
# SIN el prefijo first/, que añade el include de config/urls.py

from django.urls import path

from . import views

# el ESPACIO DE NOMBRES de las rutas de este archivo: la ruta "product" se llama, en el
# resto del proyecto, "first:product"
app_name = "first"

urlpatterns = [
    # GET /first/: la ruta "" designa el propio prefijo
    path("", views.index, name="index"),
    # GET y POST /first/action01: una vista escrita como una CLASE, cada
    # método de la cual maneja un método HTTP
    path("action01", views.Action01.as_view(), name="action01"),
    # GET /first/products/17: <int:id> es un parámetro de ruta; el conversor
    # int acepta solo dígitos y pasa un entero a la vista
    path("products/<int:id>", views.product, name="product"),
    # GET /first/products/17/reviews/3: dos parámetros de ruta
    path("products/<int:id>/reviews/<int:number>", views.review, name="review"),
    # GET /first/files/images/logo.png: el conversor path acepta cualquier
    # final de ruta, incluidas las barras diagonales
    path("files/<path:path>", views.file, name="file"),
]
  • línea 10: [app_name] proporciona un espacio de nombres para las rutas del archivo: para el resto del proyecto, la ruta llamada [product] se denomina [first:product]. Así, dos aplicaciones pueden tener cada una una ruta llamada [index] sin conflicto;
  • línea 14: la ruta [""] designa el propio prefijo: la URL [/first/];
  • línea 17: la vista escrita como clase. [as_view()] es un método de la clase [View] que crea la función que [Django] llamará en cada solicitud: esta función crea un objeto [Action01] y luego llama a su método [get] o [post] , según el método HTTP de la solicitud. Se crea un objeto nuevo en cada solicitud;
  • línea 20: [<int:id>] es un parámetro de ruta: este segmento de la URL puede tomar varios valores. [id] es el nombre del parámetro, que se pasará a la vista; [int] es un convertidor que solo acepta dígitos y pasa un entero a la vista: para la URL [/first/products/17], el parámetro [id] de la vista es el entero 17. Si el segmento no está formado por dígitos, la ruta no coincide. Esto es el enlace de datos (data binding), que el siguiente capítulo examinará en detalle;
  • línea 22: dos parámetros de ruta;
  • línea 25: el convertidor [path] acepta cualquier final de ruta, incluidas las barras. [Django] tiene cinco convertidores: [str] (el convertidor predeterminado: [<name>] equivale a [<str:name>]; cualquier texto no vacío sin barra), [int] (números), [slug] (letras, números, guiones y guiones bajos, como en [my-article-01]), [uuid] (un identificador UUID) y [path]. El ejemplo 12 mostrará cómo escribir un convertidor “personalizado”, y el ejemplo 22 mostrará la función [re_path], que describe una ruta mediante una expresión regular.

Para cada solicitud, [Django] recorre las rutas en orden y se detiene en la primera que coincide con la ruta solicitada: el orden de las rutas importa cuando dos rutas pueden coincidir con la misma ruta solicitada.

2.2.4. Ejecución

Estas son las respuestas a algunas solicitudes:

curl -i http://localhost:8000/first/
1
2
3
4
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8

View [index] of the [first] application
curl -i http://localhost:8000/first/products/17/reviews/3
1
2
3
4
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8

Review no. 3 of product no. 17
curl -i http://localhost:8000/first/files/images/logo.png
1
2
3
4
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8

Requested file: images/logo.png

Para enviar una solicitud POST, use la opción [-X POST] de [curl]:

curl -i -X POST http://localhost:8000/first/action01
1
2
3
4
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8

View [Action01], method [post]: POST request

La solicitud POST se acepta tal cual. Esto dejará de ser así cuando la aplicación tenga el middleware de protección anti-CSRF de [Django] (ejemplo 18), que rechaza cualquier solicitud POST que no demuestre provenir de un formulario de la aplicación. Un método HTTP que la vista no maneja produce un error 405 ([Method Not Allowed]). El encabezado [Allow] especifica los métodos aceptados:

curl -i -X PUT http://localhost:8000/first/action01
1
2
3
HTTP/1.1 405 Method Not Allowed
Content-Type: text/html; charset=utf-8
Allow: GET, POST, HEAD, OPTIONS

La respuesta no tiene cuerpo. La clase [View] acepta, además de los métodos de la clase, el método HEAD (manejado por el método [get]) y el método OPTIONS (que devuelve la lista de métodos aceptados). La consola del servidor informa del rechazo:

Method Not Allowed (PUT): /first/action01
[27/Sep/2026 19:17:38] "PUT /first/action01 HTTP/1.1" 405 0

El decorador [@require_GET] produce el mismo error:

curl -i -X POST http://localhost:8000/first/products/17
1
2
3
HTTP/1.1 405 Method Not Allowed
Content-Type: text/html; charset=utf-8
Allow: GET

Una URL que ninguna ruta maneja produce un error 404. Lo mismo ocurre con un identificador que no es un número: el convertidor [int] impide que la ruta coincida con [/first/products/abc].

curl -i http://localhost:8000/first/products/abc
1
2
3
4
5
6
7
8
9
HTTP/1.1 404 Not Found
Content-Type: text/html; charset=utf-8

<!DOCTYPE html>
<html lang="en">
<head>
  <meta http-equiv="content-type" content="text/html; charset=utf-8">
  <title>Page not found at /first/products/abc</title>
...

En un navegador, en modo de depuración:

Image

La página de error de [Django] explica que ninguna ruta coincide con la ruta solicitada y enumera, en orden, todas las rutas de la aplicación junto con sus nombres: es una buena manera de comprobar las rutas ([Django] no tiene un comando que las enumere). Observe que las rutas de la aplicación [first] han sido efectivamente prefijadas con [first/], y que la ruta se comparó sin su barra inicial. El capítulo 6 mostrará cómo reemplazar esta página por una página personalizada para la aplicación. Observe también que [Django] distingue entre [/first/] y [/first]: la segunda, URL, no tiene ruta y devuelve un error 404. Un componente de middleware de [Django], [CommonMiddleware] (caso de estudio), resuelve este problema: cuando una ruta sin barra final no tiene ruta asociada, pero la misma ruta con barra final sí la tiene, redirige el navegador (ejemplo 04) a esa segunda ruta (esta es la configuración [APPEND_SLASH], habilitada de forma predeterminada).

curl -i http://localhost:8000/first
1
2
3
HTTP/1.1 404 Not Found
Content-Type: text/html; charset=utf-8
...

2.3. Ejemplo 03: respuestas de una vista

Lo que devuelve una vista determina la respuesta HTTP. El ejemplo 03 revisa los casos principales:

03-responses/
├── config/
│   ├── middleware.py
│   ├── settings.py
│   ├── urls.py
│   └── ...
├── responses/
│   ├── __init__.py
│   ├── urls.py
│   ├── viewmodels.py
│   └── views.py
└── manage.py

La aplicación enruta [responses], montada bajo el prefijo [responses/] mediante el archivo [config/urls.py], asocia cada URL [/responses/xxx] con una vista:

# responses/urls.py: una ruta por cada tipo de respuesta

from django.urls import path

from . import views

app_name = "responses"

urlpatterns = [
    path("text", views.text, name="text"),
    path("html", views.html, name="html"),
    path("json", views.as_json, name="json"),
    path("dictionary", views.dictionary, name="dictionary"),
    path("list", views.as_list, name="list"),
    path("calc", views.calc, name="calc"),
    path("created", views.created, name="created"),
    path("empty", views.empty, name="empty"),
    path("not-found", views.not_found, name="not_found"),
    path("abort", views.abort, name="abort"),
    path("error", views.error, name="error"),
    path("forgotten", views.forgotten, name="forgotten"),
]
# responses/views.py: las distintas respuestas de una vista

from dataclasses import asdict

from django.http import Http404, HttpResponse, JsonResponse
from django.views.decorators.http import require_GET

from .viewmodels import Person


# una cadena, anunciada como texto plano: el navegador la muestra tal cual
@require_GET
def text(request):
    return HttpResponse("<h1>View [text]</h1>", content_type="text/plain; charset=utf-8")


# sin tipo anunciado, Django envía la respuesta con el tipo text/html
@require_GET
def html(request):
    return HttpResponse("<h1>View [html]</h1>")


# un objeto: JsonResponse solo puede serializar los tipos básicos de Python
# (diccionarios, listas, cadenas, números...); asdict convierte el objeto en un
# diccionario. La vista no se llama json, para no ocultar el módulo json
@require_GET
def as_json(request):
    return JsonResponse(asdict(Person("Martin", "Jean", 42)))


# un diccionario: se convierte en un objeto JSON
@require_GET
def dictionary(request):
    return JsonResponse({"last_name": "Martin", "first_name": "Jean", "age": 42})


# una lista: se convierte en un arreglo JSON. safe=False: JsonResponse acepta algo
# distinto de un diccionario
@require_GET
def as_list(request):
    return JsonResponse(["Mme", "Melle", "Mr"], safe=False)


# una lista calculada: ordenada y luego transformada elemento por elemento
@require_GET
def calc(request):
    numbers = [3, 1, 2]
    numbers.sort()
    return JsonResponse([n * 10 for n in numbers], safe=False)


# el código 201 (Created) en lugar de 200 (OK)
@require_GET
def created(request):
    return JsonResponse({"message": "resource created"}, status=201)


# sin respuesta: el código 204 (No Content) significa "nada que mostrar"
@require_GET
def empty(request):
    return HttpResponse(status=204)


# un error "esperado": una respuesta JSON con el código 404
@require_GET
def not_found(request):
    return JsonResponse({"message": "This resource does not exist"}, status=404)


# lo mismo, mediante una excepción, que Django convierte en una respuesta 404
@require_GET
def abort(request):
    raise Http404("This resource does not exist either")


# un error "inesperado": una excepción no controlada produce una respuesta 500
@require_GET
def error(request):
    raise RuntimeError("An unexpected error")


# el olvido: una vista DEBE devolver un objeto HttpResponse. Esta sí construye la
# respuesta, pero olvida devolverla: sin return, una función de Python devuelve None
@require_GET
def forgotten(request):
    HttpResponse("A lost response")

Comentemos este código:

  • línea 5: las clases de respuesta y de excepción del módulo [django.http];
  • línea 8: importación de una clase desde un módulo de la misma aplicación. El punto en [.viewmodels] se refiere al paquete del archivo actual ([responses]): es una importación relativa;
  • líneas 12–14: [HttpResponse] acepta parámetros con nombre: [content_type] especifica aquí texto plano ([text/plain]); el navegador no interpretará las etiquetas. [status] (el código de estado, 200 de forma predeterminada) y [headers] (un diccionario de encabezados) son los demás;
  • líneas 18–20: la misma cadena, sin un tipo declarado: [Django] la envía con el tipo [text/html], y el navegador la interpreta;
  • líneas 26–28: [JsonResponse] es una clase hija de [HttpResponse]: convierte su primer parámetro a JSON y declara el tipo [application/json]. La conversión la realiza el módulo [json] de la biblioteca estándar, que reconoce solo los tipos básicos de [Python]: diccionarios, listas, cadenas, números, booleanos y [None]. Por lo tanto, un objeto debe convertirse primero en un diccionario: esto es lo que hace la función [asdict] (línea 3) con una clase de datos, como [Person], que se muestra más abajo. La vista se llama [as_json]: si se llamara [json], ocultaría el módulo [json] en este archivo si este se importara;
  • líneas 32–34: un diccionario llamado [Python], encerrado entre llaves, se convierte en un objeto llamado JSON;
  • líneas 39–41: una lista se convierte en un arreglo JSON. De forma predeterminada, [JsonResponse] acepta solo un diccionario: es una antigua medida de protección contra una vulnerabilidad de navegadores antiguos que permitía a un sitio de terceros leer un arreglo JSON. El parámetro [safe=False] elimina esta restricción;
  • líneas 45–49: una lista calculada. El método [sort] ordena la lista (modifica la propia lista). [[n * 10 for n in numbers]] es una comprensión de listas: la lista de valores [n * 10], para cada elemento [n] de la lista [numbers];
  • líneas 53–55: el parámetro [status]: 201 ([Created]) reemplaza a 200;
  • líneas 59–61: el código 204 ([No Content]) significa “nada que mostrar”: la respuesta no tiene cuerpo;
  • líneas 65–67: un error “esperado”: una respuesta 404 ([Not Found]), con un cuerpo (JSON) elegido por la vista;
  • líneas 71–73: el mismo error, causado por una excepción. [Http404] es una excepción de [Django]; la instrucción [raise] la lanza, lo que termina la vista. [Django] la convierte en una respuesta de error 404. Esta es la forma más común de terminar una vista por un error, incluso en lo profundo de una función llamada por la vista. El módulo [django.shortcuts] ofrece dos atajos que la lanzan: [get_object_or_404] y [get_list_or_404] (para los modelos del ORM, capítulo 7). [django.core.exceptions] define las excepciones que generan los demás códigos de error: [PermissionDenied] (403), [BadRequest] (400), [SuspiciousOperation] (400);
  • líneas 77–79: un error “inesperado” (una excepción que nadie maneja) produce una respuesta 500 ([Internal Server Error]). [RuntimeError] es una clase de excepción de la biblioteca estándar de [Python], disponible sin necesidad de importarla;
  • líneas 84–86: el error que se debe evitar. Una vista de [Django] debe devolver un objeto [HttpResponse]; esta vista genera la respuesta correctamente, pero no la devuelve. Una función de [Python] sin [return] devuelve el valor [None], que [Django] rechaza (veremos la respuesta más adelante). Esto difiere de otros frameworks, como [Flask], que convierten por sí mismos un diccionario o una cadena en una respuesta: [Django] exige que la vista especifique explícitamente qué respuesta devuelve.

La clase [Person]:

# responses/viewmodels.py: una persona

from dataclasses import dataclass


# @dataclass escribe por sí mismo el constructor de la clase (__init__), a partir de sus
# atributos tipados; frozen=True: los atributos ya no pueden cambiar después de
# la construcción
@dataclass(frozen=True)
class Person:
    last_name: str
    first_name: str
    age: int
  • línea 3: el módulo [dataclasses] de la biblioteca estándar;
  • líneas 9–13: una clase de datos. Las líneas [last_name: str] declaran atributos, junto con sus tipos (anotaciones de tipo, que [Python] no impone en tiempo de ejecución, pero que el editor de código verifica). El decorador [@dataclass] usa estos atributos para generar el constructor de la clase (el método [__init__], llamado por [Person("Martin", "Jean", 42)]), su método de comparación ([==]) y su representación de texto ([Person(last_name='Martin', first_name='Jean', age=42)]). Con [frozen=True], los atributos ya no se pueden modificar después de la construcción: un objeto [Person] es inmutable. No es obligatorio colocar esta clase en un módulo [viewmodels.py]: es una decisión tomada en este documento, que reserva el nombre [models.py] para los modelos del ORM de [Django] (capítulo 7).

Queda el archivo [config/middleware.py]:

# config/middleware.py: un JSON legible por un humano

import json

from django.http import JsonResponse


# un MIDDLEWARE: una clase de la que Django crea UN objeto al iniciar la aplicación,
# pasándole get_response, el resto del procesamiento (los demás middlewares y luego
# la vista). Luego el objeto se llama por cada solicitud
class ReadableJson:
    def __init__(self, get_response):
        self.get_response = get_response

    def __call__(self, request):
        # antes de la vista: nada que hacer aquí. La vista produce la respuesta...
        response = self.get_response(request)
        # ... que el middleware puede modificar antes de enviarla
        if isinstance(response, JsonResponse):
            # "é" en lugar de "é", y una presentación con sangría,
            # en varias líneas
            data = json.loads(response.content)
            response.content = json.dumps(data, ensure_ascii=False, indent=4)
        return response

De forma predeterminada, una respuesta [JsonResponse] contiene un JSON compacto de una sola línea, en el que los caracteres que no son ASCII se escriben como secuencias de escape: [é] se convierte en [\u00e9], lo cual es JSON válido, pero poco legible. Para los ejemplos de este curso, queremos un JSON legible. En lugar de solicitarlo en cada vista (el parámetro [json_dumps_params] de [JsonResponse] lo permitiría), modificamos todas las respuestas JSON de la aplicación mediante un mecanismo central de [Django]: el middleware.

Un middleware es un eslabón de la cadena que lleva de la solicitud a la vista, y luego de la vista a la respuesta. [Django] encadena los componentes de middleware de la configuración [MIDDLEWARE] como muñecas rusas: el primero recibe la solicitud y se la pasa al siguiente, que se la pasa al siguiente, y así hasta llegar a la vista; la respuesta de la vista recorre entonces la cadena en sentido inverso. Cada componente de middleware puede examinar o modificar la solicitud a la entrada y la respuesta a la salida, e incluso puede responder por sí mismo sin llamar al siguiente componente. Así está construido [Django] mismo: la sesión, la protección anti-CSRF, los mensajes y el idioma son todos componentes de middleware.

  • líneas 11–13: un middleware es una clase. [Django] crea una única instancia de ella al iniciarse la aplicación, pasando la función [get_response] (el resto de la cadena: los componentes de middleware siguientes, seguidos de la vista) a su constructor ([__init__]). El constructor la almacena en un atributo del objeto, [self.get_response];
  • líneas 15–24: el método [__call__] hace que el objeto sea invocable como una función: [Django] lo llama en cada solicitud, junto con la solicitud. El código que precede a la llamada a [self.get_response(request)] se ejecuta antes de la vista; el código que la sigue se ejecuta después de la vista: aquí, el middleware no hace nada antes de la vista;
  • líneas 19–23: si la respuesta es una respuesta JSON (la función [isinstance] verifica la clase de un objeto), el middleware vuelve a leer su cuerpo ([response.content], bytes), lo decodifica ([json.loads]) y luego lo codifica de nuevo ([json.dumps]) con dos opciones: [ensure_ascii=False] (los caracteres que no son ASCII se escriben tal cual) e [indent=4] (un formato con sangría, en varias líneas). La asignación a [response.content] reemplaza el cuerpo de la respuesta;
  • línea 24: el middleware devuelve la respuesta, que continúa su propagación ascendente.

Todavía falta declarar el middleware en el archivo [config/settings.py]:

# config/settings.py: la configuración del ejemplo 03

from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent
DEBUG = True
SECRET_KEY = "django-insecure-l^yufd#xgw7y7_t=t@o2)h96m-c!z*#%rzk_l7&p09nu!fmwdc"
ALLOWED_HOSTS = []
LANGUAGE_CODE = "en"
TIME_ZONE = "Europe/Paris"
ROOT_URLCONF = "config.urls"
WSGI_APPLICATION = "config.wsgi.application"

INSTALLED_APPS = [
    "responses",
]

# los MIDDLEWARES: funciones que Django llama por cada solicitud, antes de la vista,
# y por cada respuesta, después de ella. Este hace que las respuestas JSON sean legibles
MIDDLEWARE = [
    "config.middleware.ReadableJson",
]
  • líneas 20–22: la configuración [MIDDLEWARE] enumera los componentes de middleware de la aplicación en el orden en que la solicitud pasa por ellos, indicados mediante la ruta completa de su clase. Veremos cómo se va completando a medida que avancemos por los ejemplos. Los ejemplos 05 a 12 reutilizan este middleware.

En un navegador, la diferencia entre [text/plain] y [text/html] es visible:

Image

Image

Estas son las respuestas de las demás vistas:

curl -i http://localhost:8000/responses/json
1
2
3
4
5
6
7
8
HTTP/1.1 200 OK
Content-Type: application/json

{
    "last_name": "Martin",
    "first_name": "Jean",
    "age": 42
}

El objeto se convirtió en un objeto JSON, con un campo por atributo. La vista [/responses/dictionary] produce exactamente la misma respuesta.

curl -i http://localhost:8000/responses/list
curl -i http://localhost:8000/responses/calc
HTTP/1.1 200 OK
Content-Type: application/json

[
    "Mme",
    "Melle",
    "Mr"
]
HTTP/1.1 200 OK
Content-Type: application/json

[
    10,
    20,
    30
]
curl -i http://localhost:8000/responses/created
1
2
3
4
5
6
HTTP/1.1 201 Created
Content-Type: application/json

{
    "message": "resource created"
}
curl -i http://localhost:8000/responses/empty
HTTP/1.1 204 No Content
Content-Type: text/html; charset=utf-8
curl -i http://localhost:8000/responses/not-found
1
2
3
4
5
6
HTTP/1.1 404 Not Found
Content-Type: application/json

{
    "message": "This resource does not exist"
}
curl -i http://localhost:8000/responses/abort
1
2
3
4
5
6
7
8
9
HTTP/1.1 404 Not Found
Content-Type: text/html; charset=utf-8

<!DOCTYPE html>
<html lang="en">
<head>
  <meta http-equiv="content-type" content="text/html; charset=utf-8">
  <title>Page not found at /responses/abort</title>
...

La respuesta de la excepción es la página de error de [Django], la del ejemplo 02, con nuestro mensaje en lugar de la lista de rutas. Incluso cuando el cliente solicita una respuesta JSON mediante el encabezado [Accept: application/json] (opción [-H] de [curl]: [curl -i -H "Accept: application/json" http://localhost:8000/responses/abort]), la respuesta sigue siendo la página HTML: [Django] no adapta sus respuestas de error al tipo solicitado. Una aplicación que quiera errores en formato JSON los genera por sí misma mediante un middleware (ejemplo 08). La consola informa del error:

Not Found: /responses/abort
[27/Sep/2026 19:18:08] "GET /responses/abort HTTP/1.1" 404 4928

Queda la excepción no manejada. En modo de depuración, el navegador muestra la página de error de [Django]: el tipo y el mensaje de la excepción, la vista actual, el archivo y la línea donde se lanzó, seguidos de la pila de llamadas (traceback) y la lista de funciones que se estaban ejecutando en el momento del error, de la más antigua a la más reciente:

Image

Más abajo en la página, la última función de la pila es nuestra vista, [error], en la línea 79 del archivo [responses/views.py]; por encima están las funciones de [Django] que la llamaron. Para cada función, el enlace “Local vars” muestra los valores de sus variables locales; el resto de la página muestra la solicitud (sus parámetros, cookies y encabezados) y todos los ajustes de la aplicación (aquellos cuyos nombres sugieren información sensible, como [SECRET_KEY], se enmascaran con asteriscos). Por todas estas razones, el modo de depuración nunca debe habilitarse en un servidor accesible para otras personas. El error también se escribe en el registro de la aplicación (en este caso, la consola del servidor), junto con la pila de llamadas:

1
2
3
4
5
6
7
Internal Server Error: /responses/error
Traceback (most recent call last):
  ...
  File "/home/claude/django-sept-2026/examples/03-responses/responses/views.py", line 79, in error
    raise RuntimeError("An unexpected error")
RuntimeError: An unexpected error
[27/Sep/2026 19:18:59] "GET /responses/error HTTP/1.1" 500 106342

Sin el modo de depuración ([DEBUG = False] en el archivo [config/settings.py], junto con [ALLOWED_HOSTS = ["localhost"]], ya que la lista ya no puede estar vacía), la misma solicitud produce una página de error breve que no revela nada sobre el código:

HTTP/1.1 500 Internal Server Error
Content-Type: text/html; charset=utf-8


<!doctype html>
<html lang="en">
<head>
  <title>Server Error (500)</title>
</head>
<body>
  <h1>Server Error (500)</h1><p></p>
</body>
</html>

y el error 404 para [/responses/abort] también se convierte en una página corta ([Not Found]: “The requested resource was not found on this server.”), sin nuestro mensaje. Fuera del modo de depuración, [Django] tampoco escribe ya la pila de llamadas en la consola: la envía por correo electrónico a los administradores del sitio, si se han especificado (configuración [ADMINS]). El caso de estudio mostrará cómo configurar el registro. El capítulo 6 mostrará cómo mostrar una página de error específica de la aplicación.

Por último, la vista que olvida devolver su respuesta:

curl -i http://localhost:8000/responses/forgotten
1
2
3
4
5
6
7
8
9
HTTP/1.1 500 Internal Server Error
Content-Type: text/html

<!DOCTYPE html>
<html lang="en">
<head>
...
  <title>ValueError
          at /responses/forgotten</title>

La consola muestra el mensaje de la excepción:

ValueError: The view responses.views.forgotten didn't return an HttpResponse object. It returned None instead.

El mensaje es claro: “The view did not return an object HttpResponse; it returned None.” Es un error común entre los principiantes: en una vista con varias ramas ([if] / [else]), en una de ellas se olvida el [return].

2.4. Ejemplo 04: redirecciones

Una redirección es una respuesta que indica al navegador que obtenga otra URL: un código 3xx, junto con el encabezado [Location], que contiene la nueva dirección. El navegador envía de inmediato una segunda solicitud a esa dirección. Las rutas del ejemplo:

1
2
3
4
5
6
7
8
# config/urls.py: la tabla de enrutamiento principal

from django.urls import include, path

urlpatterns = [
    # un include sin prefijo: las rutas de la aplicación quedan en la raíz del sitio
    path("", include("redirects.urls")),
]
# redirects/urls.py: las rutas del ejemplo 04

from django.urls import path

from . import views

urlpatterns = [
    path("old", views.old, name="old"),
    path("new", views.new, name="new"),
    path("go/<str:destination>", views.go, name="go"),
    path("to-route/<str:destination>", views.to_route, name="to_route"),
    # name: el NOMBRE de la ruta, que permite construir su URL
    path("page/<str:name>", views.page, name="page"),
    path("documentation", views.documentation, name="documentation"),
]

El archivo [config/urls.py] monta las rutas de la aplicación [redirects] en la raíz del sitio (prefijo vacío). El archivo [redirects/urls.py] no contiene una línea para [app_name]: sus rutas no tienen espacio de nombres y se llaman simplemente [page], [new]... Las vistas:

# redirects/views.py: las redirecciones

from django.http import HttpResponse
from django.shortcuts import redirect
from django.views.decorators.http import require_GET


# redirección permanente (301): la página cambió de dirección de forma permanente
@require_GET
def old(request):
    return redirect("/new", permanent=True)


@require_GET
def new(request):
    return HttpResponse("You are on the [new] page")


# redirección temporal (302, el código predeterminado), a una dirección calculada
# pegando trozos de texto
@require_GET
def go(request, destination):
    return redirect("/page/" + destination)


# redirect recibe aquí el NOMBRE de una ruta y sus parámetros: construye la
# dirección por sí mismo, mediante la función reverse, que codifica correctamente el parámetro name
@require_GET
def to_route(request, destination):
    return redirect("page", name=destination)


@require_GET
def page(request, name):
    return HttpResponse(f"You are on the [{name}] page")


# redirección a otro sitio
@require_GET
def documentation(request):
    return redirect("https://docs.djangoproject.com/en/6.1/")
  • Línea 4: el módulo [django.shortcuts] contiene atajos y funciones que condensan en una sola línea las operaciones más comunes: [redirect], [render] (el capítulo sobre las plantillas), [get_object_or_404]...;
  • Líneas 9–11: [redirect] genera una respuesta de redirección (un objeto [HttpResponsePermanentRedirect] o [HttpResponseRedirect] , dos subclases de [HttpResponse]) hacia la dirección especificada. Con [permanent=True], el código es 301 ([Moved Permanently]): la página cambió su dirección de forma permanente, y el navegador (y los motores de búsqueda) pueden recordar la nueva;
  • Líneas 21–23: sin [permanent=True], [redirect] produce una redirección temporal con el código de estado 302 ([Found]). La dirección se calcula concatenando fragmentos de texto (el operador [+] concatena dos cadenas), lo que plantea un problema, como veremos;
  • líneas 28–30: [redirect] también acepta el nombre de una ruta (['page']), seguido de sus parámetros ([name=destination]): entonces genera la dirección por sí mismo mediante la función [reverse] de [Django], que realiza el proceso de enrutamiento inverso (de un nombre de ruta y sus parámetros a una URL) y codifica correctamente los parámetros para una URL. Si alguna vez se cambia la ruta de la ruta [page], las redirecciones hacia ella se actualizarán automáticamente. Para una ruta de una aplicación que tiene un espacio de nombres, el nombre se escribe como [first:product] (ejemplo 02);
  • líneas 40–41: una redirección a otro sitio: la dirección se toma tal cual. [redirect] primero verifica si la cadena es el nombre de una ruta; si no se encuentra ninguna, una cadena que contenga una barra o un punto se trata como una dirección (de lo contrario, es un error).

Las respuestas, usando [curl] (que, sin opciones, no sigue las redirecciones):

curl -i http://localhost:8000/old
1
2
3
HTTP/1.1 301 Moved Permanently
Content-Type: text/html; charset=utf-8
Location: /new

El encabezado [Location] contiene la dirección tal como la proporcionó la vista, relativa al sitio: el navegador la completa con el protocolo, el host y el puerto de la página actual. La respuesta no tiene cuerpo. La opción [-L] de [curl] sigue la redirección, tal como lo haría un navegador:

curl -L http://localhost:8000/old
You are on the [new] page

Ahora comparemos las dos redirecciones calculadas, con un destino que contiene un signo de interrogación, codificado como [%3F] en la URL (un [?] sin codificar iniciaría los parámetros de la URL):

curl -i http://localhost:8000/go/a%3Fb
curl -i http://localhost:8000/to-route/a%3Fb
1
2
3
4
5
6
7
HTTP/1.1 302 Found
Content-Type: text/html; charset=utf-8
Location: /page/a?b

HTTP/1.1 302 Found
Content-Type: text/html; charset=utf-8
Location: /page/a%3Fb

[Django] decodificó el parámetro de la ruta antes de pasarlo a la vista: [destination] es igual a [a?b]. La primera vista lo inserta de nuevo en la URL tal cual: [/page/a?b], que el navegador interpreta como la ruta [/page/a] seguida del parámetro [b]. La segunda sigue la ruta con nombre, cuyo parámetro se vuelve a codificar así: [/page/a%3Fb]. Al seguir las redirecciones:

curl -L http://localhost:8000/go/a%3Fb
curl -L http://localhost:8000/to-route/a%3Fb
You are on the [a] page
You are on the [a?b] page

Solo la segunda lleva a la página correcta. De ahí la regla: una dirección que contiene un valor variable se construye a partir del nombre de su ruta ([redirect("page", name=...)], [reverse("page", kwargs={"name": ...})] y, en las plantillas, la etiqueta [{% url %}]), nunca concatenando cadenas. En el navegador, solo se ve la página final; la barra de direcciones muestra la nueva URL:

Image

Existen otros dos códigos de redirección: 303 ([See Other]) y 307 ([Temporary Redirect]), que se obtienen generando la respuesta uno mismo: [HttpResponseRedirect(url, status=303)]. Después de una solicitud POST, los códigos 302 y 303 hacen que el navegador envíe una solicitud GET a la nueva dirección, mientras que 307 (y 308, la versión permanente) hacen que repita la solicitud POST. El ejemplo 20 usará una redirección después de un POST.

2.5. Ejemplo 05: los objetos de solicitud y de respuesta

Hasta ahora, las vistas solo han usado parámetros de ruta y han devuelto una respuesta de una línea. Una vista también puede acceder a la solicitud actual y construir su respuesta pieza por pieza. La aplicación se llama [http_app] (y no [http], como en el curso de [Symfony]: [http] ya es el nombre de un paquete de la biblioteca estándar de [Python], que la nuestra sobrescribiría); sus rutas se montan bajo el prefijo [http/]:

# http_app/views.py: los objetos de solicitud y de respuesta

import time

from django.http import HttpResponse, JsonResponse, StreamingHttpResponse
from django.views.decorators.http import require_GET


# la solicitud: método, ruta, parámetros, encabezados... Django SIEMPRE pasa a la vista,
# como primer parámetro, el objeto HttpRequest de la solicitud actual
@require_GET
def request_info(request):
    return JsonResponse({
        "method": request.method,
        "path": request.path,
        "url": request.build_absolute_uri(),
        "parameters": request.META["QUERY_STRING"],
        "browser": request.headers.get("User-Agent"),
        "ip": request.META["REMOTE_ADDR"],
    })


# la respuesta: le añadimos un encabezado
@require_GET
def header(request):
    response = HttpResponse("Response with an added header")
    response["X-Example"] = "05-request-response"
    return response


# la respuesta construida de una sola vez: cuerpo, código, encabezados
@require_GET
def response(request):
    return HttpResponse("Response built by [HttpResponse(...)]", status=200,
                        headers={"Content-Type": "text/plain; charset=utf-8"})


# una respuesta enviada POR FRAGMENTOS: el código y los encabezados salen con el primer
# fragmento y ya no pueden cambiar después
@require_GET
def stream(request):
    # una función GENERADORA: cada yield produce un fragmento de la respuesta
    def chunks():
        yield "Start of the response... "
        time.sleep(1)
        # demasiado tarde para anunciar un error: el código 200 ya salió
        raise RuntimeError("error in the middle of the response")

    return StreamingHttpResponse(chunks(), content_type="text/plain; charset=utf-8")
  • líneas 11–20: el parámetro [request] de la vista, que aún no habíamos usado, es el objeto [HttpRequest] de la solicitud actual. Sus atributos y métodos proporcionan toda la información que contiene: su método HTTP ([method]), su ruta ([path]), su URL completa ([build_absolute_uri()], que agrega el protocolo, la máquina y el puerto) y sus encabezados ([headers], un diccionario cuyas claves no distinguen entre mayúsculas y minúsculas: [headers.get("user-agent")] produciría el mismo resultado). El atributo [META] es un diccionario que contiene todas las variables que transmitió el servidor WSGI: los encabezados (bajo nombres como [HTTP_USER_AGENT]), los parámetros sin procesar (la parte de la URL que sigue a [?], [QUERY_STRING]), la dirección IP del cliente ([REMOTE_ADDR])... El método [get] de un diccionario devuelve el valor de una clave, o [None] si la clave no existe, mientras que [d["key"]] lanzaría una excepción [KeyError]. Los parámetros, uno por uno, se tratarán en el próximo capítulo;
  • líneas 24–28: la respuesta se crea primero y luego se rellena: un objeto [HttpResponse] se maneja como un diccionario de encabezados. [response["X-Example"] = ...] agrega el encabezado [X-Example] (por convención, los encabezados específicos de una aplicación suelen comenzar con [X-]); [response.headers] también da acceso a estos encabezados;
  • líneas 32–35: la respuesta construida de una sola vez: el cuerpo, el código de estado y los encabezados. Una llamada a una función puede abarcar varias líneas; dentro de paréntesis, [Python] ignora los saltos de línea;
  • líneas 40–49: una respuesta enviada por fragmentos (streaming). Un objeto [StreamingHttpResponse] recibe, en lugar de una cadena, un iterador: un objeto que produce fragmentos, uno tras otro. Aquí, es el resultado de una función generadora: una función que contiene la instrucción [yield]. Llamar a [chunks()] no ejecuta la función: devuelve un generador, que ejecutará la función paso a paso, de un [yield] al siguiente, cada vez que se solicite un fragmento. La función está definida dentro de la vista: esto está permitido en [Python]. El servidor envía el código y los encabezados, y luego cada segmento tan pronto como se genera. La longitud de la respuesta no se conoce de antemano. Esto es útil para una respuesta muy larga generada poco a poco (por ejemplo, un archivo CSV grande). Pero una vez enviado el primer fragmento, el código de estado ya no puede cambiar: aquí, la función lanza una excepción después del primer fragmento. Este es el error que se debe evitar: una respuesta que ya comenzó no puede convertirse en una respuesta de error.

El middleware [ReadableJson] es el del ejemplo 03. Las respuestas:

curl -i "http://localhost:8000/http/request?name=martin&age=42"
HTTP/1.1 200 OK
Content-Type: application/json

{
    "method": "GET",
    "path": "/http/request",
    "url": "http://localhost:8000/http/request?name=martin&age=42",
    "parameters": "name=martin&age=42",
    "browser": "curl/8.5.0",
    "ip": "127.0.0.1"
}

Las comillas alrededor de la URL evitan que el terminal interprete el carácter [&]. En un navegador, el encabezado [User-Agent] es el del navegador.

curl -i http://localhost:8000/http/header
1
2
3
4
5
HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8
X-Example: 05-request-response

Response with an added header
curl -i http://localhost:8000/http/response
1
2
3
4
HTTP/1.1 200 OK
Content-Type: text/plain; charset=utf-8

Response built by [HttpResponse(...)]
curl -i http://localhost:8000/http/stream
1
2
3
4
HTTP/1.1 200 OK
Content-Type: text/plain; charset=utf-8

Start of the response...

Después de un segundo, [curl] se detiene: el servidor cerró la conexión. El cliente recibió un código de estado 200 y un cuerpo simplemente truncado, sin ninguna forma de saber que ocurrió un error. [Django] no pudo hacer nada: cuando se lanza la excepción, su vista ya terminó hace mucho su trabajo (devolvió la respuesta y su generador), y es el servidor, al solicitar el siguiente fragmento, quien recibe la excepción. Solo la consola del servidor lo indica, con una pila de llamadas que parte del servidor WSGI de [Python], y no de [Django]:

1
2
3
4
5
6
7
Traceback (most recent call last):
  File "/usr/lib/python3.13/wsgiref/handlers.py", line 138, in run
    self.finish_response()
  ...
  File "/home/claude/django-sept-2026/examples/05-request-response/http_app/views.py", line 47, in chunks
    raise RuntimeError("error in the middle of the response")
RuntimeError: error in the middle of the response

2.6. Ejemplo 06: servicios compartidos

Una vista no debe contener por sí misma la lógica de la aplicación; delega esta lógica en servicios: objetos que realizan tareas específicas (como leer los datos de un producto o calcular el total de un carrito de compras). Varias vistas suelen usar el mismo servicio. [Symfony], como [Spring] o [ASP.NET Core], tiene para ello un contenedor de servicios, que crea los servicios y los proporciona automáticamente a quienes los necesitan: esto es la inyección de dependencias. [Django] no tiene nada parecido. En [Python], un módulo se ejecuta una sola vez, en su primera importación, y todos los que lo importan después reciben el mismo módulo: por lo tanto, un objeto almacenado en una variable de módulo ya está compartido en toda la aplicación. Los módulos actúan como contenedores. El siguiente paso es organizar las cosas para que las vistas dependan de un contrato, no de una implementación. El ejemplo 06 organiza su código por dominio (productos, clientes), es decir, en [Django], por aplicación:

06-services/
├── clients/
│   ├── __init__.py
│   ├── urls.py
│   └── views.py
├── config/
│   └── ...
├── products/
│   ├── __init__.py
│   ├── provider.py
│   ├── services.py
│   ├── urls.py
│   ├── viewmodels.py
│   └── views.py
└── manage.py

2.6.1. El producto: products/viewmodels.py

# products/viewmodels.py: un producto

from dataclasses import dataclass


# frozen=True: el objeto es inmutable (sus atributos los fija el constructor)
@dataclass(frozen=True)
class Product:
    id: int
    name: str
    # el precio en CENTAVOS: un entero, para cálculos exactos
    price_cents: int
  • Línea 7: una clase de datos inmutable (véase el ejemplo 03). Un objeto inmutable se puede compartir de forma segura entre varias partes del código y entre varias solicitudes;
  • Líneas 9–12: los atributos, junto con sus tipos. El precio es un entero: el precio en centavos (150 para 1,50 €). Un número de punto flotante, de tipo [float], se representa en binario y no puede representar exactamente 0.1 ni 3.2 (en binario, estos números tienen una cantidad infinita de dígitos): una suma de precios en [float] puede dar 5.500000000000001. En cambio, una suma de enteros siempre es exacta. [Python] también ofrece el tipo [Decimal] (módulo [decimal]), que realiza cálculos exactos en base 10: es el que usa el ORM de [Django] para las columnas decimales de una base de datos.

2.6.2. El contrato del servicio y su implementación: products/services.py

# products/services.py: el CONTRATO del servicio de productos y una implementación

from abc import ABC, abstractmethod

from .viewmodels import Product


# el CONTRATO: lo que el servicio puede hacer, sin decir cómo. ABC (Abstract Base
# Class): una clase abstracta, de la que no se puede crear ningún objeto
class ProductsService(ABC):
    @abstractmethod
    def find_all(self) -> list[Product]:
        ...

    # Product | None: un producto, o None si no existe
    @abstractmethod
    def find_by_id(self, id: int) -> Product | None:
        ...


# una IMPLEMENTACIÓN del contrato, con datos en memoria
class InMemoryProductsService(ProductsService):
    def __init__(self):
        # para ver, en la consola, cuántas veces se crea el servicio
        print("creation of the InMemoryProductsService service")
        self._products = [
            Product(1, "pen", 150),
            Product(2, "notebook", 320),
            Product(3, "eraser", 80),
        ]

    def find_all(self) -> list[Product]:
        # una COPIA de la lista: quien llama no puede modificar la del servicio
        return list(self._products)

    def find_by_id(self, id: int) -> Product | None:
        # next: el primer elemento producido por el generador, o None si no hay ninguno
        return next((p for p in self._products if p.id == id), None)
  • Líneas 3, 10: el contrato del servicio: lo que puede hacer, sin especificar cómo. [Java] o [C#] lo definirían mediante una interfaz; [Python] lo define mediante una clase abstracta que hereda de la clase [ABC] (Abstract Base Class) del módulo [abc]. No se puede crear un objeto a partir de una clase abstracta;
  • Líneas 11–18: los métodos del contrato, marcados con [@abstractmethod]: una clase hija debe implementarlos todos; de lo contrario, tampoco se podrá crear un objeto de esa clase hija. Su cuerpo, [...] (el objeto [Ellipsis]), no hace nada: está ahí porque una función de [Python] debe tener un cuerpo. Las anotaciones de tipo describen el contrato: [find_all] devuelve una lista de productos ([list[Product]]); [find_by_id] recibe un entero y devuelve un producto, o [None] si no existe ([Product | None]);
  • línea 22: la implementación hereda el contrato;
  • líneas 23–30: el constructor. [self._products] es un atributo del objeto; el guion bajo inicial es una convención en [Python] para indicar “privado”: nada impide que otro módulo lo use, pero sabe que no debería. La línea 25 muestra un mensaje en la consola para que podamos ver cuándo se crea el servicio;
  • líneas 32–34: el método devuelve una copia de la lista de productos ([list(...)] crea una lista nueva): quien llama puede modificarla sin afectar los datos del servicio (los objetos [Product] en sí no se copian, pero son inmutables);
  • líneas 36–38: [(p for p in self._products if p.id == id)] es una expresión generadora, similar a la comprensión de listas del ejemplo 03: produce, uno por uno, los productos cuyo identificador es [id]. La función [next] devuelve el primer elemento generado, o el valor de su segundo parámetro ([None]) si no hay ninguno.

2.6.3. El proveedor del servicio: products/provider.py

Las vistas no crean el servicio por sí mismas: lo solicitan a una función, el proveedor, que decide qué implementación crear y se asegura de que solo se cree una:

# products/provider.py: el PROVEEDOR del servicio de productos

from functools import cache

from django.conf import settings
from django.utils.module_loading import import_string

from .services import ProductsService


# @cache: la función se ejecuta una sola vez; las llamadas siguientes devuelven el
# resultado de la primera. Por lo tanto, el servicio se crea una sola vez y es COMPARTIDO por todas
# las vistas y todas las solicitudes, mientras el servidor esté en ejecución
@cache
def products_service() -> ProductsService:
    # la clase elegida por la configuración (ajuste PRODUCTS_SERVICE)
    cls = import_string(settings.PRODUCTS_SERVICE)
    return cls()
  • Línea 5: [django.conf.settings] da acceso a la configuración de la aplicación, que es la del archivo [config/settings.py] complementada con los valores predeterminados: [settings.DEBUG], [settings.LANGUAGE_CODE]... Así es como cada módulo de la aplicación lee su configuración;
  • línea 6: [import_string] importa un objeto indicado por su ruta completa, como cadena: así es como [Django] encuentra el middleware de la configuración [MIDDLEWARE];
  • Líneas 14–18: la función proveedora. Lee el nombre de la clase seleccionada en la configuración [PRODUCTS_SERVICE], la carga, crea un objeto de esa clase ([cls()]) y lo devuelve. El decorador [@cache], del módulo [functools] de la biblioteca estándar, almacena en caché el resultado de la primera llamada: las llamadas posteriores devuelven el mismo objeto sin ejecutar la función. Por lo tanto, el servicio se crea una sola vez, en la primera llamada, y luego lo comparten todas las vistas y todas las solicitudes mientras el servidor esté en ejecución. Esto es lo que en otros lugares se conoce como singleton. También es diferido: mientras ninguna vista lo haya solicitado, no se crea. La anotación ***[-> ProductsService]*** especifica el tipo de retorno: el contrato, no la implementación.

Solo queda elegir la implementación, en el archivo [config/settings.py]:

# config/settings.py: la configuración del ejemplo 06

from pathlib import Path

BASE_DIR = Path(__file__).resolve().parent.parent
DEBUG = True
SECRET_KEY = "django-insecure-%ooh-uyk3pt43f_st+x1hr@b&84t#^-&nia4-xk7v3mpy%1w(j"
ALLOWED_HOSTS = []
LANGUAGE_CODE = "en"
TIME_ZONE = "Europe/Paris"
ROOT_URLCONF = "config.urls"
WSGI_APPLICATION = "config.wsgi.application"

INSTALLED_APPS = [
    "products",
    "clients",
]

MIDDLEWARE = [
    "config.middleware.ReadableJson",
]

# un ajuste PROPIO de la aplicación: la ELECCIÓN de la implementación del servicio
# de productos, designada por la ruta completa de su clase (véase products/provider.py)
PRODUCTS_SERVICE = "products.services.InMemoryProductsService"
  • línea 25: una configuración específica de la aplicación. [Django] acepta, en el archivo de configuración, cualquier variable escrita en mayúsculas y la pone a disposición mediante [django.conf.settings]. Es aquí, y solo aquí, donde se elige la implementación del servicio. Para cambiar a una implementación que lea de una base de datos, bastaría con modificar esta línea: las vistas, que solo conocen el contrato, permanecerían sin cambios. Este es el beneficio de la inyección de dependencias, logrado aquí sin un contenedor: cada parte de la aplicación depende de contratos, y un único lugar determina las implementaciones. El paquete [products] también se llama [products] en la configuración [INSTALLED_APPS] (línea 15): [Django] lo importa al iniciarse.

2.6.4. Vistas de productos y de clientes

# products/views.py: las vistas de /products

from dataclasses import asdict

from django.http import JsonResponse
from django.views.decorators.http import require_GET

from .provider import products_service


@require_GET
def list_all(request):
    # la vista le pide su servicio al proveedor: solo conoce el contrato
    # (ProductsService), no la implementación elegida
    service = products_service()
    return JsonResponse([asdict(p) for p in service.find_all()], safe=False)


@require_GET
def one_product(request, id):
    product = products_service().find_by_id(id)
    if product is None:
        return JsonResponse({"message": f"Product no. {id} not found"}, status=404)
    return JsonResponse(asdict(product))
  • Línea 8: la vista importa el proveedor, no la clase [InMemoryProductsService]; no sabe que los productos están en memoria;
  • Líneas 12–16: la vista delega el trabajo en el servicio. La lista de productos se convierte en una lista de diccionarios, que se convierte en un arreglo de tipo JSON (ejemplo 03);
  • Líneas 20–24: un producto desconocido devuelve una respuesta 404, con un mensaje en JSON. El conversor [<int:id>] de la ruta (archivo [products/urls.py]) garantiza que [id] sea un entero.
# clients/views.py: una segunda aplicación, que usa el MISMO servicio

from django.http import JsonResponse
from django.utils.formats import number_format
from django.views.decorators.http import require_GET

from products.provider import products_service


@require_GET
def cart(request):
    products = products_service().find_all()
    # la suma de los precios, en centavos: enteros, por lo tanto un cálculo exacto
    total = sum(p.price_cents for p in products)
    return JsonResponse({"client": "Jean Martin", "items": len(products),
                         "total_cents": total,
                         # number_format: el número escrito según el idioma (en: 5.50)
                         "total": number_format(total / 100, 2) + " €"})
  • líneas 7, 12: esta segunda aplicación usa el mismo servicio que la de los productos, importándolo desde el paquete [products]. El proveedor le devuelve el mismo objeto;
  • línea 14: [sum] suma los elementos producidos por la expresión generadora;
  • líneas 15–18: [len] devuelve el número de elementos de una lista. El total se devuelve en centavos y se formatea en euros: [number_format], del módulo [django.utils.formats], escribe un número con dos decimales según las convenciones del idioma de la aplicación: un punto como separador decimal para el inglés. La división [total / 100] produce un [float], pero solo para fines de visualización: los cálculos reales se realizaron con enteros. El ejemplo 16 mostrará una forma mucho mejor de dar formato a los importes.

Por último, unas palabras sobre el ciclo de vida de este servicio compartido. Como vimos en el ejemplo 01: en [Python], la aplicación permanece en memoria de una solicitud a la siguiente. Por lo tanto, el servicio es único para toda la aplicación: la siguiente solicitud recibirá el mismo objeto que la anterior, y cualquier dato modificado por una solicitud sería visible para todas las solicitudes posteriores. Para un servicio que solo lee datos estáticos, como este, esto es ideal: se crea una sola vez. Para un servicio cuyos datos cambian (la lista de tareas del ejemplo 20), esto es cómodo (los datos sobreviven entre solicitudes, sin archivo ni base de datos), pero hay que tomar dos precauciones: dos solicitudes simultáneas pueden modificar los datos al mismo tiempo, por lo que deben protegerse con un bloqueo; y los datos desaparecen cuando el servidor se apaga (o se reinicia, después de un cambio en el código). Esto es exactamente lo opuesto a [PHP], donde cada solicitud tiene sus propios servicios, recreados cada vez.

2.6.5. Ejecución

La consola del servidor muestra el mensaje del constructor en la primera solicitud que llama al servicio, y solo en esa solicitud:

curl -i http://localhost:8000/products/
HTTP/1.1 200 OK
Content-Type: application/json

[
    {
        "id": 1,
        "name": "pen",
        "price_cents": 150
    },
    {
        "id": 2,
        "name": "notebook",
        "price_cents": 320
    },
    {
        "id": 3,
        "name": "eraser",
        "price_cents": 80
    }
]
curl -i http://localhost:8000/products/9
1
2
3
4
5
6
HTTP/1.1 404 Not Found
Content-Type: application/json

{
    "message": "Product no. 9 not found"
}
curl -i http://localhost:8000/clients/cart
1
2
3
4
5
6
7
8
9
HTTP/1.1 200 OK
Content-Type: application/json

{
    "client": "Jean Martin",
    "items": 3,
    "total_cents": 550,
    "total": "5.50 €"
}

La consola del servidor:

1
2
3
4
5
creation of the InMemoryProductsService service
[27/Sep/2026 19:19:51] "GET /products/ HTTP/1.1" 200 249
Not Found: /products/9
[27/Sep/2026 19:19:51] "GET /products/9 HTTP/1.1" 404 44
[27/Sep/2026 19:19:51] "GET /clients/cart HTTP/1.1" 200 96

El servicio se creó una sola vez, para las tres solicitudes y las dos aplicaciones. Si se modifica un archivo del proyecto, el servidor se reinicia y el mensaje reaparece en la siguiente solicitud.