Erhalten Sie Zugang zu diesem und mehr als 300000 Büchern ab EUR 5,99 monatlich.
- Herausgeber: Marcombo
- Kategorie: Wissenschaft und neue Technologien
- Sprache: Spanisch
Descubra el proceso completo para desarrollar aplicaciones web profesionales con Django. Este libro le guiará a través de la creación de cuatro proyectos prácticos con Django para saber cómo resolver problemas comunes e implementar las mejores prácticas de desarrollo. A lo largo de la lectura aprenderá a construir una aplicación blog, un sitio web social para compartir imágenes, una tienda online y una plataforma e-learning. El libro no solo trata el desarrollo de aplicaciones web con Django, sino también cómo mejorar la experiencia de usuario mediante AJAX y JavaScript, integrar otras tecnologías como Redis y Celery, así como crear APIs REST para exponer servicios a terceros. Al finalizar el libro, dispondrá de un conocimiento profundo sobre cómo construir aplicaciones web avanzadas con Django. Contenidos del libro: Crear proyectos web profesionales con Django Utilizar Django con otras tecnologías como Redis y Celery Desarrollar aplicaciones Django reutilizables Crear funcionalidades avanzadas, optimizar código y utilizar la caché Añadir internacionalización a proyectos Django Mejorar la experiencia de usuario utilizando JavaScript y AJAX Añadir funcionalidades sociales a los proyectos 2Construir APIs REST para exponer funcionalidades a terceros
Sie lesen das E-Book in den Legimi-Apps auf:
Seitenzahl: 434
Veröffentlichungsjahr: 2020
Das E-Book (TTS) können Sie hören im Abo „Legimi Premium” in Legimi-Apps auf:
Ähnliche
Django 2
Django 2
Antonio Melé
Copyright © Packt Publishing 2018. First published in the English language under the title Django 2 by Example – (9781788472487).
Primera edición original publicada en inglés por Packt Publishing Ltd. con el título: Django 2 by Example, © 2018 Antonio Melé
Título de la edición en español: Django 2
Primera edición en español, año 2020
© 2020 MARCOMBO, S.L.
www.marcombo.com
Traducción: Aitor Ruiz Fajardo y Jaime Fernández Martín
Correctora: Nuria Barroso
Directora de producción: M.a Rosa Castillo
«Cualquier forma de reproducción, distribución, comunicación pública o transformación de esta obra solo puede ser realizada con la autorización de sus titulares, salvo excepción prevista por la ley. Diríjase a CEDRO (Centro Español de Derechos Reprográficos, www.cedro.org) si necesita fotocopiar o escanear algún fragmento de esta obra».
ISBN: 978-84-267-2866-1
Producción del ebook: booqlab.com
Para mi hermana
Acerca del autor
Antonio Melé es CTO de Exo Investing y fundador de Zenx IT. Antonio ha desarrollado proyectos Django desde 2006 para clientes de distintas industrias. También ha trabajado como CTO y consultor de tecnología para múltiples startups y ha gestionado equipos de desarrollo tecnológico para negocios digitales. Antonio es ingeniero superior en informática por la Universidad Pontificia Comillas. Su padre le inspiró su pasión por los ordenadores y la programación.
Acerca de los traductores
Aitor Ruiz Fajardo es Senior Software Development Engineer en Voysis en Dublín. Aitor ha trabajado principalmente en el desarrollo de arquitecturas y aplicaciones Java en proyectos para múltiples empresas en distintos sectores. Entusiasta del software y la gestión desde bien pequeño, Aitor es ingeniero superior en informática por la Universidad Carlos III de Madrid.
Jaime Fernández Martín es un consultor digital especializado en la implantación de software para negocios. Lleva trabajando con Python desde hace más de 10 años y ha sido coorganizador de Python-Madrid. Ha trabajado en diferentes sectores como: biotecnología, aeronáutica, telecomunicaciones, energía y financiero, aplicando la tecnología como medio para mejorar los procesos de negocio. Jaime es ingeniero informático por la Universidad Politécnica de Madrid, con un máster en inteligencia artificial por la misma universidad, y un MBA por CESMA Business School.
Contenido
Prefacio
1. Crear un blog
Instalar Django
Crear un entorno de desarrollo Python
Instalar Django mediante pip
Crear el primer proyecto
Arrancar el servidor de desarrollo
Configuración del proyecto
Proyecto y aplicaciones
Crear una aplicación
Esquema de datos del blog
Activar la aplicación
Crear y activar migraciones
Sitio de administración para los modelos
Crear un superusuario
El sitio de administración de Django
Añadir modelos al sitio de administración
Personalizar la vista de modelos
Trabajando con QuerySets y Managers
Crear objetos
Actualizar objetos
Recuperar objetos
Valiéndose del método filter()
Uso de exclude()
Uso de order_by()
Eliminar objetos
Cuándo se evalúan los QuerySets
Crear gestores de modelos
Elaborar listas de detalle y listado
Creación de vistas de detalle y listado
Añadir patrones de URL para las vistas
Crear plantillas para vistas
Añadir paginación
Usar vistas basadas en clase
Resumen
2. Funciones avanzadas del blog
Compartir artículos por email
Crear formularios en Django
Usar formularios en vistas
Enviar emails con Django
Renderizar formularios en plantillas
Crear un sistema de comentarios
Crear formularios de un modelo
Funcionamiento de ModelForms en vistas
Añadir comentarios a la plantilla de detalle de artículos
Añadir funcionalidad de etiquetado
Recuperar artículos por similitud
Resumen
3. Extensiones para el blog
Crear filtros y etiquetas de plantilla personalizados
Crear etiquetas de plantilla personalizadas
Crear filtros de plantilla personalizados
Añadir un mapa de sitio
Sistema de feeds
Crear un sistema de búsqueda para el blog
Instalar PostgreSQL
Búsquedas sencillas
Búsqueda sobre múltiples campos
Construir una vista de búsqueda
Lematización y resultados por semejanza
Orden de relevancia en búsquedas
Búsquedas por similitud de trigrama
Otros motores de búsqueda de texto completo
Resumen
4. Construir una aplicación social
Crear un proyecto de red social
Iniciar el proyecto de red social
Utilizar el sistema de autenticación de Django
Crear una vista de inicio de sesión
Utilizar las vistas de autenticación de Django
Vistas para iniciar y cerrar sesión
Vistas para modificar la contraseña
Vistas para restaurar la contraseña
Registro y perfiles de usuario
Registro de usuarios
Extender el modelo de usuario
Usar un modelo de usuario personalizado
Utilizar el sistema de mensajes
Crear un backend de autenticación personalizado
Añadir autenticación social a la web
Autenticación mediante Facebook
Autenticación mediante Twitter
Autenticación mediante Google
Resumen
5. Compartir contenido en su web
Crear un sitio web para compartir imágenes
Construir el modelo imagen
Crear relaciones muchos a muchos
Registrar el modelo imagen en el portal de administración
Enviar contenido desde otros sitios web
Validar campos de formulario
Sobrescribir el método save() de un ModelForm
Elaborar un bookmarklet con jQuery
Crear una vista de detalle para las imágenes
Crear miniatura de imágenes utilizando sorl-thumbnail
Añadir acciones AJAX con jQuery
Cargar jQuery
Falsificación de petición en sitios cruzados con AJAX
Realizar peticiones AJAX con jQuery
Crear decorados para vistas
Añadir paginación AJAX a listados
Resumen
6. Seguimiento de acciones de usuario
Construir un sistema de seguidores
Crear relaciones muchos a muchos a través de un model intermedio
Crear vistas de listado y detalle para perfiles de usuario
Construir una vista AJAX para seguir usuarios
Construir un feed de actividad
Utilizar el sistema de contenttypes
Añadir relaciones genéricas a modelos
Evitar registrar acciones duplicadas
Añadir acciones de usuario al registro de actividad
Mostrar el registro de actividad
Optimizar QuerySets que involucran objetos relacionados
Utilizar select_related()
Utilizar prefetch_related()
Crear plantillas parea acciones
Usar señales para desnormalizar conteos
Trabajar con señales
Clases de configuración de aplicaciones
Usar Redis para contabilizar visualizaciones
Instalar Redis
Usar Redis con Python
Almacenamiento total de visualizaciones en Redis
Almacenar un ranking en Redis
Siguientes pasos con Redis
Resumen
7. Construir una tienda online
Crear un proyecto de tienda online
Modelo de catálogo de productos
Registrar el catálogo en el panel de administración
Construir vistas de catálogo
Crear plantillas de catálogo
Construir un carro de la compra
Sistema de sesiones en Django
Configuración de sesión
Expiración de sesión
Almacenar carros de compra en sesión
Vistas para el carro de la compra
Añadir elementos al carro
Construir una plantilla para mostrar el carro
Añadir productos al carro
Modificar la cantidad de producto en el carro
Crear un procesador de contexto para el carro actual
Registrar órdenes de clientes
Crear modelo de órdenes
Añadir los modelos de órdenes al panel de administración
Crear órdenes de clientes
Ejecutar tareas asíncronas con Celery
Instalar Celery
Instalar RabbitMQ
Añadir Celery al proyecto
Añadir tareas asíncronas a su aplicación
Monitorizar Celery
Resumen
8. Gestión de pagos y pedidos
Integrar una pasarela de pago
Crear una cuenta de prueba en Braintree
Instalar el módulo Python de Braintree
Integrar la pasarela de pago
Integrar Braintree con Hosted Fields
Probar los pagos
Desplegando en producción
Exportar órdenes de pedido a CSV
Añadir acciones en el panel de administración
Personalizar vistas en el panel de administración
Generar facturas en PDF dinámicamente
Instalar WeasyPrint
Crear una plantilla PDF
Renderizar ficheros PDF
Enviar ficheros PDF por email
Resumen
9. Extensión de tienda online
Creación de un sistema de cupones
Modelos para cupones
Aplicar un cupón al carro de la compra
Aplicar cupones a órdenes
Añadir internacionalización y localización
Internacionalización con Django
Configuración de internacionalización y localización
Determinar el idioma en Django
Preparar el proyecto para internacionalización
Traducir código Python
Traducción estándar
Traducciones perezosas
Traducciones incluyendo variables
Traducción de plurales
Traducción de código
Traducir plantillas
La etiqueta de plantilla {% trans %}
La etiqueta de plantilla {% blocktrans %}
Traducir plantillas de la tienda
Rosetta: Interfaz de traducción
Traducciones perezosas
Patrones de URL para internacionalización
Añadir un prefijo de idioma al patrón de URL
Traducir patrones de URL
Permitir cambio de idioma a los usuarios
Traducción de modelos con django-parler
Instalar django-parler
Traducir campos de modelo
Integrar traducciones en el panel de administración
Crear migraciones para traducciones de modelos
Adaptar vista para traducciones
Formato localizado
Validar campos de formulario con django-localflavor
Crear un sistema de recomendación
Recomendar productos en base a compras anteriores
Resumen
10. Construir una plataforma e-learning
Configurar el proyecto e-learning
Construir el modelo curso
Registrar los modelos en el sitio de administración
Usar fixtures para crear datos iniciales para los modelos
Utilizar modelos para contenido diverso
Utilizar herencia de modelos
Modelos abstractos
Herencia multitabla de modelos
Modelos Proxy
Crear los modelos de contenido
Campos de modelo personalizados
Añadir orden a objetos de módulos y contenidos
Crear un CMS
Añadir un sistema de autenticación
Crear las plantillas de autenticación
Crear vistas basadas en clases
Utilizar mixins para las vistas basadas en clases
Trabajar con grupos y permisos
Restringir el acceso a las vistas basadas en clases
Gestionar módulos y contenido de los cursos
Utilizar conjuntos de formularios para los módulos del curso
Añadir contenido a los módulos de un curso
Gestionar módulos y contenidos
Reordenar módulos y contenidos
Utilizar mixins de django-braces
Resumen
11. Renderizar y cachear contenido
Mostrar cursos
Añadir el registro de estudiantes
Crear una vista de registro para estudiantes
Inscribir estudiantes en cursos
Acceder al contenido del curso
Renderizar diferentes tipos de contenido
Utilizar el sistema de caché
Sistemas de caché disponibles
Instalar Memcached
Configurar la caché
Añadir Memcached al proyecto
Monitorizar Memcached
Niveles de caché
Usar la API de caché de bajo nivel
Cachear basándose en datos dinámicos
Cachear fragmentos de plantilla
Cachear vistas
Usar caché a nivel de sitio web
Resumen
12. Construir una API
Construir una API RESTful
Instalar Django REST framework
Definir serializadores
Entender los parsers y renderers
Construir vistas de listado y detalle
Crear serializadores anidados
Crear vistas personalizadas
Gestionar la autenticación de usuarios
Añadir permisos a vistas
Crear conjuntos de vistas y enrutadores
Añadir acciones adicionales a conjuntos de vistas
Crear permisos personalizados
Serializar contenidos de cursos
Resumen
13. Lanzamiento en producción
Crear un entorno de producción
Configuración para distintos entornos
Utilizar PostgreSQL
Comprobar su proyecto
Servir Django mediante WSGI
Instalar uWSGI
Configurar uWSGI
Instalar NGINX
El entorno de producción
Configurar NGINX
Servir archivos estáticos y media
Securizar conexiones con SSL
Crear un certificado SSL
Configurar NGINX para utilizar SSL
Configurar su proyecto con SSL
Crear un middleware a medida
Crear un middleware para gestionar subdominios
Servir múltiples dominios con NGINX
Comandos de administración personalizados
Resumen
Prefacio
Django es un potente framework web escrito en Python que fomenta un desarrollo rápido y un diseño limpio y pragmático, a la par que ofrece una curva de aprendizaje relativamente suave, lo que lo hace atractivo tanto para programadores novatos como expertos.
Este libro le guiará a través de todo el proceso del desarrollo de aplicaciones web profesionales con Django. El libro no solo cubre los aspectos más relevantes del framework, sino que también muestra cómo integrar otras tecnologías populares en proyectos Django.
Este volumen le enseñará a crear aplicaciones reales, solucionar problemas comunes e implementar las mejores prácticas mediante un enfoque paso a paso fácil de seguir.
Después de leer este libro sabrá cómo funciona Django y cómo utilizarlo para elaborar aplicaciones web prácticas con funcionalidades avanzadas.
A quién va dirigido este libro
Este libro va dirigido a programadores con conocimientos de Python que quieren aprender Django de una forma práctica. Tanto si Django es un framework nuevo para usted, como si ha trabajado con él pero quiere dominarlo, este libro es el más adecuado para usted. Le ayudará a dominar las funciones más relevantes del framework creando proyectos completos desde cero. Para leerlo es necesario estar familiarizado con conceptos de programación y tener un conocimiento básico de Python, HTML y JavaScript.
Cómo aprovechar este libro
Para sacar el máximo rendimiento a este libro, se recomienda tener un buen conocimiento de Python y conocimientos básicos de HTML y JavaScript. Antes de adentrarse en sus páginas se recomienda leer las partes 1 a 3 del tutorial de la documentación oficial de Django en https://docs.djangoproject.com/es/2.0/intro/tutorial01/.
Descarga del código asociado al libro
En la parte inferior de la primera página del libro encontrará el código de acceso que le permitirá acceder de forma gratuita a los contenidos adicionales en www.marcombo.info.
1
Crear un blog
Con este libro aprenderá a desarrollar proyectos Django, listos para su funcionamiento en producción. En caso de que aún no haya instalado Django, aprenderá cómo hacerlo en la primera parte de este capítulo. En este también se verá cómo crear una sencilla aplicación de blog con Django. El propósito principal de este capítulo es tener una visión general del framework, comprender cómo interactúan los diferentes componentes entre sí y obtener las habilidades necesarias para crear un proyecto Django con funcionalidades sencillas. Este capítulo le guiará en la creación de un proyecto Django completo sin entrar en detalle en cada paso. Los diferentes componentes utilizados en este capítulo se describen en los siguientes capítulos.
Este capítulo trata los siguientes puntos:
• Instalar Django y crear un primer proyecto.
• Diseñar modelos de datos y generar migraciones.
• Crear un sitio de administración para modelos de datos.
• Utilizar QuerySets y Managers.
• Construir vistas, plantillas y URLs.
• Añadir paginación a vistas de listado.
• Usar vistas basadas en clases.
Instalar Django
Si ya ha instalado Django puede saltar a la siguiente sección Crear mi primer proyecto. Django es un paquete Python y, como tal, puede instalarse en cualquier entorno Python. Si aún no ha instalado Django, los siguientes pasos le guiarán para instalarlo en un entorno local de desarrollo.
Django 2.0 requiere la versión de Python 3.4 o superior. En los ejemplos de este libro utilizaremos Python 3.6.5. Si usa un sistema operativo Linux o macOS X, probablemente tenga instalado Python por defecto. Si usa otro tipo de plataformas, como Windows, puede descargar un instalador de Python desde https://www.python.org/downloads/windows/.
En caso de duda, puede comprobar si Python está instalado en su ordenador introduciendo el comando python en una consola. Si tras ejecutarlo aparece un texto similar al mostrado a continuación, Python está instalado en su sistema:
Si la versión de Python instalada es inferior a la 3.4, o si no tiene Python instalado en su sistema, descargue Python 3.6.5 desde https://www.python.org/downloads/ e instálelo. Si dispone de un sistema de gestión de paquetes en su sistema operativo, es recomendable realizar la instalación a través de él.
Al utilizar Python 3 no es necesario instalar una base de datos, ya que esta versión de Python incluye la base de datos SQLite en la instalación por defecto. SQLite es una base de datos ligera que se puede usar con Django para entornos de desarrollo. Para desplegar una aplicación en un entorno de producción, es necesario utilizar otro tipo de bases de datos avanzadas como PostgreSQL, MySQL u Oracle. Puede obtener más información sobre cómo configurar una base de datos con Django en https://docs.djangoproject.com/en/2.0/topics/install/#database-installation.
Crear un entorno de desarrollo Python
Es recomendable utilizar la librería virutalenv para crear un entorno de desarrollo aislado. De esta manera podremos disponer de diferentes versiones de paquetes en los distintos proyectos en los que estemos trabajando. El uso de virutalenv también ofrece independencia de la instalación de Python que haya en nuestro propio sistema. De esta manera, también se cuenta con la ventaja de no necesitar permisos de administración para la instalación de paquetes Python. Para instalar virutalenv ejecute la siguiente instrucción en una línea de comandos:
Tras la instalación de virutalenv cree un entorno de desarrollo independiente con el comando:
Esto generará un directorio my_env/ incluido el nuevo entorno Python. Cualquier librería Python que se instale mientras el entorno virtual permanezca activo se almacenará en el directorio my_env/lib/python3.6/site-packages.
Si su sistema incluía una versión Python 2.X y ha instalado Python 3 es necesario especificar la versión a utilizar durante la creación del entorno virtual con virutalenv.
En caso de querer nuestro entorno virtual con Python 3, es necesario especificar su ubicación durante la creación del mismo. Para ello, se necesita conocer la ruta y crearlo con los siguientes comandos, respectivamente:
Para activar nuestro entorno virtual ejecute el siguiente comando:
Una vez ejecutado, el intérprete de comandos cambiará, incluyendo el nombre del entorno virtual activo entre paréntesis, como se puede apreciar a continuación:
Puede desactivar el entorno virtual en cualquier momento ejecutando el comando deactivate.
Para obtener más información sobre el funcionamiento de virtualenv visite https://virtualenv.pypa.io/en/latest/.
En cuanto a virtualenv puede utilizar la herramienta virtualenvwrapper. Esta herramienta ofrece una abstracción de virtualenv que simplifica la creación y gestión de sus entornos virtuales. Puede descargarlo desde https://virtualenvwrapper.readthedocs.io/en/latest/.
Instalar Django mediante pip
El método más recomendado para instalar Django es haciendo uso del sistema de gestión de paquetes de Python pip. Python 3.6 lleva este paquete preinstalado, pero, en caso necesario, se pueden encontrar instrucciones para su instalación en https://pip.pypa.io/en/stable/installing/.
Ejecute el siguiente comando en intérprete para instalar Django con pip:
Django quedará instalado en el directorio site-packages/ del entorno virtual que esté activo durante la instalación.
Para comprobar que Django se ha instalado correctamente arranque un intérprete de Python. Después importe el paquete recién instalado y compruebe su versión. Para ello es necesario ejecutar:
Si tras la ejecución se obtiene esta salida, Django se ha instalado correctamente.
Django puede instalarse a través de otros métodos. Puede encontrar una guía de instalación más detallada en https://docs.djangoproject.com/en/2.0/topics/install/.
Crear el primer proyecto
El primer proyecto en Django consistirá en construir un blog con toda su funcionalidad. Django ofrece, para su comodidad, un comando que crea toda la infraestructura inicial de ficheros necesaria. Para ello, ejecute el siguiente comando en el intérprete:
Esto generará un directorio de nombre mysite con toda la estructura que necesitará en su interior.
Evite nombres de proyectos que coincidan con los de paquetes que Python tiene por defecto, para que no se produzcan conflictos durante las importaciones.
La estructura de directorios que se acaba de generar es la siguiente:
Estos ficheros son:
•manage.py es un script con diferentes funcionalidades que permiten interactuar con nuestro proyecto. Es un wrapper sobre djangoadmin.py y no es necesario modificarlo.
•mysite/ es el directorio del proyecto, el cual contiene:
○__init__.py es un fichero vacío que permite indicar a Python que mysite sea utilizado como un módulo de Python.
○settings.py incluye la configuración y propiedades principales del proyecto.
○urls.py es un fichero donde se definen los patrones de URL. Cada URL que aparezca apunta a una vista de la aplicación.
○wsgi.py es la configuración para arrancar nuestro proyecto como una aplicación Web Server Gateway Interface (WSGI).
El fichero generado settings.py contiene la configuración del proyecto, incluida una configuración básica para usar la base de datos SQLite3 y una lista llamada INSTALLED_APPS. Esta lista contiene todas las aplicaciones comunes de Django que se añaden al proyecto por defecto. Más adelante, en la sección de Configuración del Proyecto, revisaremos con más detalle este listado de aplicaciones.
Para terminar la instalación del proyecto, se debe crear, en la base de datos, las tablas que necesitan las aplicaciones de la lista INSTALLED_APPS. Para ello, abra una consola y ejecute ejecutamos los siguientes comandos:
Las últimas líneas de la salida que se obtienen serán:
Las líneas previas son las migraciones de base de datos aplicadas por Django. Al aplicar las migraciones, las tablas de las aplicaciones se crean en base de datos. Descubrirá más sobre el comando de gestión migrate en la sección Crear y aplicar migraciones de este capítulo.
Arrancar el servidor de desarrollo
Django trae incorporado un servidor web ligero para ejecutar el código de manera sencilla y rápida que ahorra el tiempo de configurar un servidor de producción. El servidor de desarrollo de Django revisa los posibles cambios que haya en nuestro código y es capaz de volver a desplegarlos de manera automática tras su detección. Sin embargo, no es sensible a todos los cambios que realicemos, como por ejemplo la incorporación de un nuevo fichero en el proyecto. Por lo que para estos casos se debe de parar el servidor y volverlo a arrancar.
Para arrancar el servidor de desarrollo solo se necesita escribir desde un intérprete el siguiente comando. Es importante que se haga desde la raíz del proyecto:
La salida debería ser similar a:
Acceda a la URL http://127.0.0.1:8000/ desde un navegador. Debería ver una página similar a la siguiente, indicando que el proyecto funciona correctamente:
La imagen anterior refleja que Django está en funcionamiento. Si se mira la consola en la que se ejecuta el servidor, se puede ver una petición GET realizada por el navegador:
Esta petición HTTP es registrada por el servidor de desarrollo en la consola. Cualquier error que se produzca durante la ejecución también se verá aquí.
El servidor de desarrollo de Django admite cierta configuración. Puede indicarle un host y puerto específicos o que cargue una configuración diferente del siguiente modo:
En el caso de que disponga de diferentes entornos en los que desplegar la aplicación, es una buena práctica disponer de un fichero de configuración por entorno.
Es importante recordar que este servidor está solo pensado para su uso durante el desarrollo y que en ningún caso debe utilizarse para un entorno de producción. Para desplegar la aplicación Django en un entorno real se debe de ejecutar como una aplicación WSGI sobre un servidor web como Apache, Gunicorn o uWSGI. Puede obtener más información sobre cómo realizar esta tarea con Django en https://docs.djangoproject.com/en/2.0/howto/deployment/wsgi/.
En el capítulo 13, Lanzamiento en producción, se explica cómo configurar un entorno de producción real para sus proyectos Django.
Configuración del proyecto
Toda la configuración del proyecto se encuentra en el fichero settings.py. Por defecto, durante la creación del mismo, Django incluye en este fichero información relevante que permite arrancar el proyecto, pero en él solo hay una parte de todas las variables que puede llegar a tener. Puede encontrar información sobre todas las variables de configuración y sus posibles valores en https://docs.djangoproject.com/en/2.0/ref/settings/.
A continuación, se repasan las principales variables de configuración:
•DEBUG es una variable booleana que activa o desactiva el modo de depuración en nuestro proyecto. Si está activo (con valor True), Django mostrará una página de error con la traza e información de contexto en caso de excepciones no tratadas. Cuando se despliega sobre un entorno de producción esta variable debe tener valor False. En caso contrario, se expone información sensible del proyecto.
•ALLOWED_HOSTS no se aplica cuando DEBUG está activo o cuando se ejecutan los test. Una vez se mueva el proyecto a un entorno de producción y se desactive la variable DEBUG, se deberá también añadir un dominio o host para poder servir la aplicación.
•INSTALLED_APPS es una variable que será necesario modificar en todos los proyectos y contiene información de las aplicaciones que están activas para cada uno de ellos. Por defecto, Django incluye en esta variable las siguientes aplicaciones:
○django.contrib.admin: sitio de administración
○django.contrib.auth: aplicación de autenticación
○django.contrib.contenttypes: aplicación para la gestión de content types
○django.contrib.sessions: aplicación de sesiones
○django.contrib.messages: aplicación de mensajes
○django.contrib.staticfiles: aplicación para la gestión de contenido estático
•MIDDLEWARE es una lista que contiene las capas intermedias que se ejecutarán.
•ROOT_URLCONF identifica el módulo Python donde están definidos los patrones de URL de la aplicación.
•DATABASES es un diccionario que contiene la configuración de nuestra base de datos. Debe haber siempre una base de datos por defecto. La configuración predefinida hace uso de una base de datos SQLite3.
•LANGUAGE_CODE define el idioma por defecto para nuestro sitio web.
•USE_TZ le indica a Django que tenga en cuenta el huso horario definido en caso de estar activo. Esta variable viene activa cuando se crea el proyecto usando startproject.
Esta es una visión general de algunas de las variables de configuración más importantes. Se detallará su utilidad a lo largo de los capítulos de este libro.
Proyectos y aplicaciones
En este libro podrá encontrar muchas menciones a los términos proyecto y aplicación. En Django, un proyecto se considera una instalación Django incluyendo su configuración. Mientras que una aplicación es un conjunto de modelos, vistas, plantillas y patrones de URL con cierta entidad independiente. Las aplicaciones interactúan con el framework Django para proveer de funcionalidad específica y pueden reutilizarse en diferentes proyectos. Se puede pensar en el proyecto como el sitio web, mientras que una aplicación es un blog, una wiki, un foro o un chat, que conforman el sitio web y pueden reutilizarse a su vez en diferentes sitios web.
Crear una aplicación
Se va a crear la primera aplicación Django y construir un blog desde cero. Para ello se ejecuta, desde la raíz del proyecto, el siguiente comando:
Esto creará la estructura principal de una aplicación, que tiene la siguiente jerarquía de ficheros:
A continuación, se dispone de:
•admin.py, que es el fichero donde se registran los modelos para que sean incluidos en el sitio de administración de Django. Hacer uso del sitio de administración de Django no es obligatorio.
•apps.py, que contiene la configuración principal de la aplicación blog.
•migrations, que es un directorio que contendrá las migraciones de base de datos de la aplicación. Esto permite que Django haga un seguimiento de los cambios en los modelos de datos y que puedan sincronizarse con la base de datos de forma coherente.
•models.py, que contiene los modelos de datos de la aplicación. Toda aplicación de Django requiere de un fichero models.py, pero el fichero puede estar vacío.
•tests.py, que es donde se incluirán los test de la aplicación.
•views.py contiene la lógica de la aplicación. Cada vista recibe una petición HTTP, la procesa y devuelve una respuesta.
Esquema de datos del blog
Se va a comenzar por el diseño del esquema de datos del blog definiendo los modelos. Un modelo es una clase Python que hereda de django.db. models.Model, en la que cada atributo representa un campo de base de datos. Por cada uno de los modelos que se ha definido en el fichero models.py Django creará una tabla en la base de datos. A través de estos modelos, Django ofrece una API que permite realizar acciones sobre objetos de la base de datos de manera sencilla.
Para comenzar, se va a definir un modelo Post. Para ello se debe añadir las siguientes líneas en el fichero models.py de la aplicación blog:
Este es el modelo de datos para los artículos del blog. Los campos que se acaban de definir en el modelo son los siguientes:
•title es un campo que contiene el título del artículo y es de tipo CharField, lo que se traduce en una columna de tipo VARCHAR en la base de datos.
•slug es un campo utilizado para la generación de la URL para el artículo. Es una cadena de texto que puede estar formada por letras, números, guiones medios y/o bajos. Se utilizará este campo para construir URLs amigables y aptas para el SEO del sitio web. Se ha incluido el parámetro unique_for_date a este campo para poder añadir también a la URL la fecha de publicación del artículo. De este modo, Django prevendrá de tener múltiples artículos con el mismo slug para la misma fecha.
•author es una clave foránea que define una relación uno a muchos. De esta forma se indica a Django que un artículo está escrito por un usuario y que, a su vez, un usuario puede ser autor de muchos artículos. Django creará esta relación en la base de datos utilizando la clave primaria del modelo al que se hace referencia, en este caso, el modelo User del sistema de autenticación del framework. El parámetro on_delete especifica el comportamiento que debe tener el artículo cuando el objeto referenciado es eliminado. Esto no es específico de Django sino de la base de datos. Si se usa el valor CASCADE, al eliminar un autor se eliminarán también todos los artículos del blog asociados a este. Para el resto de opciones disponibles puede encontrar más información en https://docs.djangoproject.com/en/2.0/ref/models/fields/#django.db.models.ForeignKey.on_delete. Para especificar el nombre de la relación inversa (de User a Post), se utiliza el parámetro related_name. Esto nos permitirá acceder de manera sencilla a los objetos desde el modelo User.
•body contiene el cuerpo del artículo. Este campo es de tipo texto, el cual se convierte en una columna TEXT en lenguaje SQL de base de datos.
•publish es un campo de tipo fecha y hora que indica el momento de publicación del artículo. Por defecto, se usa el valor now del módulo timezone de Django. Este devuelve el momento actual según el huso horario en que se haya definido nuestro proyecto.
•created, al igual que publish, es un campo de tipo fecha y hora, pero que indica el momento de creación del artículo. Haciendo uso de auto_now_add, el valor se guardará automáticamente en la creación del objeto sin tener que especificarlo de forma explícita.
•updated es también un campo de fecha y hora. Como su nombre indica, muestra el momento del último cambio que sufrió el objeto. Para ello, se emplea auto_now, que actualizará automáticamente este valor.
•status es un campo tipo texto que contendrá los estados en los que puede estar el artículo. Haciendo uso del parámetro choices se limita el valor de status a una lista finita de valores.
Django ofrece una amplia variedad de tipos de campos para construir los modelos. En https://docs.djangoproject.com/en/2.0/ref/models/fields/ se puede encontrar una lista completa de todos los que hay disponibles.
La clase Meta dentro del modelo define metadatos del propio modelo. En este caso se indica a Django que, por defecto, cuando se realice una consulta sobre este modelo en base de datos, ordene los resultados por el campo publish en orden descendente. Esto último, se especifica con el prefijo menos. De este modo, los artículos más recientes aparecerán primero.
El método __str__() es la representación legible del objeto. Django utiliza este método en múltiples lugares, entre otros, el sitio de administración.
Si ha usado Python 2.X, tenga en cuenta que en Python 3 todas las cadenas de texto son consideradas Unicode y, por tanto, solo se utiliza el método __str__(). El método __unicode__() está obsoleto.
Activar la aplicación
Para que Django tenga constancia de la aplicación y poder realizar operaciones en ella, como crear las tablas de los modelos en base de datos, es necesario activarla. Para ello, se necesita abrir el fichero settings.py e incluir blog.apps.BlogConfig en la lista INSTALLED_APPS:
La clase BlogConfig es la aplicación de configuración. Al añadirla al setting INSTALLED_APPS Django tiene constancia de la aplicación y es capaz de cargar los modelos de datos que se defina en la misma.
Crear y aplicar migraciones
Una vez creados los modelos de datos del blog, se necesita una tabla de base de datos para gestionarlos. Django incorpora un sistema de migraciones capaz de gestionar los cambios realizados en los modelos y aplicarlos sobre la base de datos. El comando migrate aplica las migraciones de todas las aplicaciones que se encuentren definidas en la variable INSTALLED_APPS, de modo que sincroniza las tablas de la base de datos con la definición de los modelos.
Lo primero que hay que hacer es crear una migración inicial para el modelo Post. Para ello, se debe ejecutar el siguiente comando:
Para el que se debería obtener la siguiente salida:
Django acaba de crear el fichero 0001_initial.py dentro del directorio migrations de la aplicación blog. Si se mira el contenido del fichero, se puede ver cómo una migración define dependencias entre migraciones y operaciones para realizar en la base de datos. Esto permite la sincronización que se mencionó antes entre la base de datos y el modelo.
A continuación, se describe el código SQL que Django ejecutará en la base de datos para crear la tabla del modelo. El comando sqlmigrate recibe el nombre de la migración y devuelve las sentencias SQL correspondientes sin llegar a ejecutarse. Utilice el siguiente comando para revisar la salida SQL de la migración anterior:
La salida debe tener el siguiente aspecto:
La salida dependerá del tipo de base de datos que se utilice. Esta ha sido generada para SQLite. Tal como se puede apreciar en el código SQL, Django genera un nombre de tabla combinando el nombre de la aplicación junto con el nombre del modelo (blog_post). Este comportamiento se puede modificar con el atributo db_table en la clase Meta del modelo. Django también crea por defecto una clave primaria por cada modelo. El campo que utiliza como clave primaria es la columna id de tipo entero con incremento automático. Django también permite modificar la clave primaria utilizando el parámetro primary_key=True en uno de los campos del modelo.
Se va a sincronizar la base de datos con el modelo. Para ello hay que aplicar las migraciones ejecutando el siguiente comando:
Se obtiene una respuesta de varias líneas, correspondiendo la última con:
Con esto se aplican las migraciones de todas las aplicaciones declaradas en INSTALLED_APPS, incluida la aplicación blog. Tras aplicar las migraciones, la base de datos refleja el estado actual de los modelos.
Si se edita el fichero models.py, añadiendo, eliminando o modificando alguno de los campos existentes, o si se añaden nuevos modelos, se deberá crear una nueva migración a través del comando makemigrations. La migración permite a Django estar al tanto de los cambios realizados en los modelos. Una vez generada la migración, se aplica para sincronizar la base de datos mediante el comando migrate.
Sitio de administración para los modelos
Tras haber definido el modelo Post, se va a crear un sitio web de administración para gestionar los artículos del blog. Django incluye un sistema web de administración muy completo para la edición de contenido. Este sistema se construye dinámicamente a través de la metainformación de los modelos y es muy sencillo de configurar.
La aplicación django.contrib.admin correspondiente al sitio de administración, está incluida en la variable de configuración INSTALLED_APPS, por lo que no es necesario añadirla de nuevo.
Crear un superusuario
Lo primero que se necesita es crear un usuario que pueda gestionar el sitio web de administración. Para ello se ejecuta el siguiente comando:
Se obtiene la siguiente salida. Introduce un usuario, un email y un password como se ve a continuación:
El sitio de administración de Django
Inicie el servidor de desarrollo mediante el comando python manage.py runserver y utilice un navegador para acceder a http://127.0.0.1:8000/admin/. Debería ver la siguiente página de autenticación del sitio de administración:
Acceda con las credenciales de usuario creadas anteriormente. Una vez dentro, se ve el panel inicial del sitio de administración:
Los modelos Group y User que se pueden ver en la imagen pertenecen a la aplicación de autenticación de Django correspondiente al paquete django.contrib.auth. Si se pulsa sobre el enlace Users se ve la información del usuario creado anteriormente. El modelo Post de la aplicación blog tiene una relación con este modelo User. Existe una relación declarada en el campo author.
Añadir modelos al sitio de administración
Se van a añadir los modelos del blog en el sitio de administración de Django. Para ello es necesario editar el fichero admin.py de la aplicación blog y añadir el siguiente código:
Para ver los cambios solo hay que recargar la página en el navegador. Ahora aparece el modelo Post en el sitio de administración:
De este modo, se consigue una interfaz amigable y sencilla para el listado, edición, creación y eliminación de objetos para modelos de datos.
Pulse sobre el enlace de Add a la derecha de Posts para crear un nuevo artículo. Esto conduce a un formulario generado dinámicamente por Django para el modelo como se puede ver a continuación:
Django utiliza diferentes widgets en los formularios según el tipo de campo a representar, incluyendo elaborados selectores para campos como el de tipo DateTimeField, que hace uso de selectores en JavaScript.
Tras rellenar el formulario haga clic sobre el botón Save. Si se ha hecho correctamente, le redirigirá a la página de lista de artículos incluyendo un mensaje indicando que el nuevo artículo ha sido creado correctamente:
Personalizar la vista de modelos
En muchas ocasiones interesará personalizar la forma en la que se muestra la información almacenada en el modelo. A continuación se describe cómo personalizar el sitio de administración.
Edite el fichero admin.py de la aplicación blog para que quede de la siguiente forma:
Con este código se indica al sitio de administración de Django que se registra un modelo con una clase propia que hereda de ModelAdmin. De este modo se puede incluir información sobre cómo visualizar la información del modelo y cómo interactuar con él. El atributo list_display permite definir los campos del modelo que aparecerán en el listado de objetos del sitio de administración y su orden. El decorador @admin.register() desempeña la misma tarea que la función admin.site.register(), registrando la clase ModelAdmin que decora.
Se personaliza el modelo de administración con el siguiente código:
Tras añadirlo, se vuelve al navegador y se refresca la página. Ahora debería ver esto:
Como se aprecia, los campos que aparecen en el listado de artículos son los que se especifica en el atributo list_display. Este listado ahora también incluye una barra en el lado derecho para filtrar resultados por los campos especificados en list_filter. Ha aparecido una caja de búsqueda debido a que se ha incluido el atributo search_fields. Con él se puede realizar búsquedas sobre los campos definidos. También han aparecido enlaces bajo la caja de búsqueda que permiten navegar a través de una jerarquía de fechas. Se ha definido en el atributo date_hierarchy. El listado de artículos tiene una ordenación por defecto que viene definida en el atributo ordering. En este caso, por estado y fecha de publicación.
Ahora se va a pinchar sobre el enlace Add Post. Aquí también se aprecian algunas diferencias. Mientras escribe el título del nuevo artículo, el campo slug se va completando de forma automática. Con el código anterior, se ha indicado a Django, a través del atributo prepopulated_fields, que complete este campo a partir del título del artículo. El campo author también cambia, añadiendo un widget de búsqueda en lugar de un desplegable. Esto resulta especialmente útil cuando la base de datos crece y existen miles de usuarios en el sistema que se pueden seleccionar.
Con unas pocas líneas de código se ha personalizado el modo en el que interactuar con el modelo en el sitio de administración. Existen muchos modos de personalizar y extender modelos. Se describen otras formas más adelante.
Trabajando con QuerySets y Managers
Se ha creado un sitio de administración funcional para gestionar el contenido del blog. Ahora se va a aprender cómo recuperar información desde la base de datos e interactuar con ella. Django ofrece una potente API de abstracción de la base de datos que permite crear, recuperar, actualizar y eliminar objetos con facilidad. El mapeador objeto-relacional u Object-Relational Mapper (ORM) es compatible con MySQL, PostgreSQL, SQLite y Oracle. Recuerde que puede definir la base de datos del proyecto en la variable de configuración DATABASES del fichero settings.py. Django es capaz de trabajar con múltiples bases de datos en el mismo proyecto, pudiendo operar con distintos esquemas de enrutado de datos.
Una vez se han creado los modelos de datos, Django ofrece el ORM para interactuar con ellos. Puede ver la referencia de modelos de datos de la documentación oficial en https://docs.djangoproject.com/en/2.0/ref/models/.
Crear objetos
Abra un terminal y ejecute el siguiente comando para abrir el intérprete de Python:
Una vez hecho esto ejecute las siguientes sentencias:
A continuación, se analiza la función de este código. Lo primero que hay que hacer, tras las importaciones, es recuperar el objeto user con el nombre de usuario admin:
El método get devuelve un único elemento de la base de datos. Es importante que la consulta devuelva un único resultado. En caso de no haber resultados, se generará una excepción de tipo DoesNotExist. Si, por el contrario, la consulta devuelve más de un resultado, la excepción generada será MultipleObjectsReturned. Ambas excepciones son atributos de la clase Model sobre la que se procesa la consulta.
Después se crea una instancia de tipo Post con un título, slug y contenido específicos, y se enlaza por autor el usuario anteriormente recuperado.
En este momento, este objeto persiste en la memoria no en la base de datos.
Por último, se guarda el objeto Post en la base de datos utilizando el método save:
Esta sentencia realiza una acción INSERT SQL por debajo. Se ha visto cómo crear un objeto en memoria para después almacenarlo en la base de datos, pero también se puede usar el método create, capaz hacer ambas cosas como una única operación:
Actualizar objetos
Para modificar un objeto, por ejemplo, el título del artículo, solo hay que modificar el atributo y salvar el objeto:
En este caso, el método save() realiza una acción UPDATE de SQL.
Los cambios que sufre un objeto no persisten en la base de datos hasta que no se invoca el método save().
Recuperar objetos
El Object-Relational Mapper (ORM) se basa en QuerySets. Un QuerySet es una colección de objetos de la base de datos que puede tener múltiples filtros para reducir el número de resultados. Ya sabe cómo recuperar un único objeto de la base de datos a través del método get(). Se ha hecho uso de él en Post.objects.get(). Cada modelo de Django tiene al menos un manager que, por defecto, se llama objects. Se puede obtener un objeto QuerySet a través del gestor de modelos. Si quisiera, por ejemplo, obtener todos los objetos de una tabla, solo hay que usar el método all() del gestor por defecto:
Este es el modo en que crear un objeto QuerySet que devuelva todos los objetos en una base de datos. Es importante mencionar, que este QuerySet no se ha ejecutado aún en la base de datos. Los QuerySets en Django tienen un comportamiento perezoso (lazy), es decir, solo se evalúan cuando son forzados a ello, dando como resultado un comportamiento muy eficiente. Si en vez de asignar el QuerySet a una variable, lo escribe en la shell de Python, la sentencia SQL del QuerySet se ejecuta, porque se ha forzado a que los resultados aparezcan por pantalla:
Valiéndose del método filter()
Para filtrar un QuerySet se puede valer del método filter() del gestor. Por ejemplo, para recuperar todos los artículos publicados en el año 2017, utilizaría el siguiente filtrado:
También se puede concatenar múltiples campos de filtrado. Por ejemplo, recuperando los artículos publicados en 2017 y cuyo usuario del autor sea admin:
Esto es lo mismo que construir el mismo QuerySet con múltiples filtros:
Para realizar consultas sobre métodos de búsqueda de campos, se utilizan dos guiones bajos, por ejemplo, publish__year. Sin embargo, la misma notación se utiliza para acceder a campos de modelos relacionados, como author__username.
Uso de exclude()
Se pueden excluir resultados del QuerySet a través del método exclude() del gestor. Por ejemplo, se pueden recuperar todos los posts publicados en 2017 cuyos títulos no empiezan por “Why”:
Uso de order_by()
Los resultados se pueden ordenar con los campos a través del método order_by() del gestor. Por ejemplo, si quisiera obtener los artículos ordenados por el campo title, los obtendría con:
El comportamiento por defecto es en orden ascendente. Si lo quisiera descendente, utilizaría el prefijo negativo del siguiente modo:
Eliminar objetos
Si quiere eliminar un objeto puede hacerlo con el método delete() del mismo:
Eliminar objetos provocará también la eliminación de objetos cuyas relaciones a través de ForeignKey estén definidas con el campo on_delete con valor CASCADE.
Cuándo se evalúan los QuerySets
Ya ha visto que se pueden concatenar tantos filtros a un QuerySet como quiera, y que la base de datos no procesará la acción hasta que el QuerySet sea evaluado. Estos se evalúan en las siguientes situaciones:
• La primera vez que se itere sobre ellos.
• Cuando accedemos a un elemento/s por posición, por ejemplo, Post.objects.all()[:3].
• Cuando los seleccionamos o guardamos en caché.
• Cuando los invocamos con repr() o len().
• Cuando instanciamos una lista sobre ellos.
• Cuando realizamos una operación lógica como bool(), or, and, o if con ellos.
Crear gestores de modelos
Ya mencionamos que objects es el gestor por defecto de cualquier modelo para recuperar objetos de la base de datos. Sin embargo, también se pueden definir gestores personalizados para los modelos. Se va a crear un gestor que recupere todos los artículos con el estado published.
Existen dos maneras de añadir gestores a los modelos: añadiendo métodos a los gestores ya existentes o modificando el gestor por defecto de QuerySets. La primera proporciona un método al API del QuerySet como Post.objects. my_manager() y, la segunda, como Post.my_manager.all(). En este caso, el gestor permitirá recuperar los artículos usando Post.published.all().
Para ello editamos el fichero models.py de la aplicación blog para incluir el nuevo gestor:
El método get_queryset() de un gestor devuelve el QuerySet ejecutado. Modificamos este método para incluir el filtrado al final del QuerySet. Se ha definido el gestor personalizado y añadido al modelo Post. Con esto ya puede utilizarlo para realizar consultas.
Se va a arrancar una consola de desarrollo con el siguiente comando:
Ahora, para recuperar todos los artículos publicados cuyo título empieza por Who, se utiliza la siguiente sentencia:
Elaborar vistas de detalle y listado
Se ha visto cómo se usa el ORM de Django. A continuación, se elaboran vistas en la aplicación del blog. Una vista de Django es una función Python que recibe una solicitud web y devuelve una respuesta web. Toda la lógica de procesamiento se encuentra dentro de la vista.
Lo primero que se va a hacer es crear las vistas de la aplicación, después se definen los patrones de URL para cada una de ellas y, por último, se crean las plantillas de HTML para renderizar el contenido con los datos de la vista. Cada vista renderiza una plantilla que se completa con datos de variables. Esta renderización se devuelve en una respuesta HTTP.
Creación de vistas de detalle y listado
Se empieza con la elaboración de una vista que muestre el listado de artículos disponibles. Para ello se edita el fichero views.py de la aplicación blog con el siguiente código:
Acaba de crear su primera vista de Django, post_list, que recupera un objeto request como único parámetro. Este parámetro es obligatorio para todas las vistas y se recibirá siempre como primer argumento. En esta vista se recuperan todos los artículos con el estado published utilizando el gestor published creado anteriormente.
Por último, se hace uso del atajo render() que ofrece Django. Con él se renderizar la lista de artículos con la plantilla proporcionada como parámetro. Esta función recoge el objeto request, la ruta relativa de la plantilla y el contexto de variables para su correcta renderización, devolviendo un objeto HttpResponse con el texto renderizado (habitualmente HTML). Es necesario pasar el objeto request para que cualquiera de las variables definidas por los procesadores de contexto también sea accesible por la plantilla. Los procesadores de contexto de las plantillas son funciones que inicializan variables en el contexto. Este tema se describe detalladamente en el capítulo 3, Extensiones para el blog.
El paso siguiente es crear una segunda vista que muestre información de un artículo. Para ello hay que añadir el siguiente código al fichero views.py:
Esta es la vista detallada de un artículo. Esta vista toma los parámetros year, month, day y post para recuperar un artículo publicado con dicho slug y fecha. Hay que mencionar que durante la creación del modelo Post, se incluyó el parámetro unique_for_date en el campo slug. De este modo asegurará la singularidad de un slug para un día dado y, por tanto, la posibilidad de recuperar un único elemento dado un slug y una fecha. En la vista detallada se usa el atajo get_object_or_404() de Django para recuperar el artículo. Esta función devuelve un objeto que coincide con los datos proporcionados o lanza una excepción HTTP 404 (no encontrado) en caso de no hallarlo. Por último, se llama a la función render() para renderizar la información del artículo a través de una plantilla.
Añadir patrones de URL para las vistas
Los patrones de URL permiten relacionar URLs con vistas. Un patrón de URL está compuesto por un patrón de texto, una vista y, opcionalmente, un nombre que permite referenciar con mayor facilidad el patrón que va a crear. Django recorre cada uno de estos patrones de URL hasta encontrar el primero que coincida con la URL solicitada. Entonces, Django importa la vista relacionada y la ejecuta, pasándole el objeto de tipo HttpRequest y el resto de parámetros, si los hubiese.
Se va a crear el fichero urls.py en el directorio de la aplicación blog y añadirá las siguientes líneas:
En el código anterior se ha definido un espacio de nombres de aplicación con la variable app_name. Esto permite organizar las URLs por aplicación y usar dicho nombre cuando se refiera a ellas. En este caso, se definen dos patrones usando la función path(). El primer patrón de URL no toma ningún argumento y está relacionado con la vista post_list. El segundo toma cuatro argumentos y ejecuta la vista post_detail:
•year: requiere un entero.
•month: requiere un entero.
•day: requiere un entero.
•post: composición de letras y guiones.
Los elementos encerrados entre símbolos menor-que y mayor-que recuperan valores de las URLs. Cualquier valor especificado en el patrón como <parameter> es recogido como cadena de texto. Se usan conversores para <int:year> para hacer coincidir con la subcadena de la URL y devolver un número entero. Por otro lado, <slug:post> trata de realizar la misma acción, solo que en este caso tratará de hacer coincidir con un slug (una cadena de texto de caracteres ASCII de número y/o letras, pudiendo contener también guiones medios o bajos). Se puede encontrar más información sobre los conversores de Django en https://docs.djangoproject.com/en/2.0/topics/http/urls/#path-converters.
Si la función path() y los conversores no fueran suficientes, se puede hacer uso de re_path() para definir patrones de URL complejos con expresiones regulares Python. Puede obtener más información sobre este método en https://docs.djangoproject.com/en/2.0/ref/urls/#django.urls.re_path. En caso de no haber trabajado antes con expresiones regulares, es conveniente revisar la sección Regular Expression HOWTO en https://docs.python.org/3/howto/regex.html.
La creación de un fichero urls.py por cada aplicación es la mejor manera de mantener aplicaciones reutilizables por otros proyectos.
Ahora hay que incluir patrones que acaba de crear en los patrones raíz del proyecto. Para ello, editará el fichero urls.py localizado en el directorio mysite del proyecto del siguiente modo:
El nuevo patrón de URL definido con un include se refiere a los patrones de URL que se crean en la aplicación blog, de modo que quedan bajo la ruta blog/. También se incluyen bajo el espacio de nombres blog. Esto permite hacer referencia a URL de un modo más sencillo, como, por ejemplo, blog:post_list o blog:post_detail. Más adelante se describe la utilidad que tienen, pero por ahora, basta con que sepa que consisten en reflejar que los espacios de nombres son únicos en todo el proyecto. Puede obtener más información sobre los espacios de nombres en https://docs.djangoproject.com/en/2.0/topics/http/urls/#url-namespaces.
Crear plantillas para vistas
Una vez tiene las vistas y los patrones de URL de la aplicación blog, es momento de añadir las plantillas para mostrar artículos con cierta armonía.
Para ello, se va a crear la siguiente estructura de directorios y ficheros dentro de la aplicación blog:
Esta estructura contendrá las plantillas para las vistas. El fichero base.html incluirá el contenido principal de HTML, que estará dividido por el área de contenido, el menú y una barra lateral. Este contenido será reutilizado por las diferentes plantillas de forma que su edición sea más sencilla y los cambios se propaguen a lo largo de todas las vistas. Los ficheros list.html y detal.html heredarán del fichero base.html para pintar el listado artículos y la vista de detalle, respectivamente.
Django posee un lenguaje de plantillas muy potente que permite especificar los datos a mostrar. Está basado en etiquetas (template tag), variables (template variable) y filtros (template filter) de plantilla:
• Las etiquetas controlan la renderización de la plantilla y son semejantes a {% tag %}.
• Las variables son reemplazadas con valores cuando la plantilla se renderiza y se representan como {{ variable }}.
• Los filtros permiten modificar variables para ser renderizadas de forma personalizada y son {{ variable|filter}}.
Para obtener más detalles sobre los filtros y etiquetas de que dispone Django se puede visitar https://docs.djangoproject.com/en/2.0/ref/templates/builtins/.
Edite el fichero base.html para añadir el siguiente código:
{% load static %} le indica a Django que cargue la plantilla static, contenida en la aplicación django.contrib.staticfiles, el cual está definido en la variable de configuración INSTALLED_APPS. Tras cargarla, se puede utilizar el filtro {% static %} en la plantilla, el cual permite cargar contenido estático, como el fichero blog.css, alojado bajo el directorio static/ de la aplicación blog. Copie el directorio static/ del código disponible para este capítulo en la misma localización del proyecto para aplicar las hojas de estilo CSS.
También se pueden ver dos etiquetas {% block %}. Estas definen una región a Django. Las plantillas que heredan de esta plantilla base pueden incluir contenido dentro de estos bloques. Se han definido dos bloques, uno llamado title y otro content.
Edite el fichero post/list.html con el siguiente código:
Con la etiqueta {% extends %} se indica a Django que herede de la plantilla blog/base.html. De este modo, se puede redefinir el contenido de los bloques title y content de la plantilla base con otro contenido. Para esto se iteran sobre los artículos y se muestra: su título, fecha de publicación, autor y contenido, incluyendo el enlace canónico al artículo en el título. En el contenido se aplican dos filtros: truncatewords, que trunca el valor a un número específico de caracteres, y linebreaks, que convierte la salida en saltos de línea de HTML. Se pueden concatenar tantos filtros como quiera, donde cada uno será aplicado con la salida generada por el filtro anterior.
Abra el intérprete y ejecute el comando
