Iniciación al framework web Django

En este tutorial veremos cómo dar nuestros primeros pasos en el framework web Django con Python. Crearemos una aplicación básica, con la cual trabajemos con la mayor parte de los elementos que nos proporciona el framework

Índice de contenidos

• 1. Introducción
• 2. Entorno
• 3. Instalación de dependencias
• 4. Creación del proyecto
• 5. Creación de aplicaciones
• 6. Creación de los modelos de datos
• 7. Plantillas y creación de vistas
• 8. Rutas
• 9. Interfaz de administración
• 10. Conclusiones
• 11. Referencias

1. Introducción

Django es un framework web escrito en Python, creado en base a la arquitectura MVC. Crearemos una aplicación básica de ejemplo, en la cual mostraremos una serie de cursos disponibles y el profesor que impartirá el curso.

2. Entorno

El tutorial está escrito usando el siguiente entorno:

• Hardware: Portátil MacBook Pro 15’ (2.5 GHz Intel Core i7, 16 GB 1600 MHz DDR3).
• Sistema Operativo: Mac OS X El Capitán 10.11.2
• Python 2.7.x
• Django 1.9.1

3. Instalación de dependencias

La version «El Capitán» de OSX viene con Python instalado por defecto, pero no con la herramienta «pip», un gestor de paquetes que simplifica mucho la tediosa tarea de tener que instalarlos a mano. Según la fuente de la instalación de Python, «pip» puede venir instalado de serie o no. El instalador para OSX disponible en https://www.python.org/ lo instala de serie, y en Linux variará según la distribución. En caso de no tenerlo instalado, basta con ejecutar el comando:

sudo easy_install pip

Para la creación del esqueleto del proyecto utilizaremos una herramienta de Python llamada “virtualenv” que nos permite crear entornos virtuales para cada proyecto, de forma que se puedan mantener distintas versiones de una dependencia para distintos proyectos sin que interfieran los unos con los otros. Para instalar la herramienta «virtualenv» en caso de que aun no la tengamos instalada ejecutamos el siguiente comando:

sudo pip install virtualenv

Una vez instalada, crearemos un directorio en un directorio de nuestro sistema en el que almacenar nuestro proyecto. En su interior, utilizaremos el comando:

virtualenv env

El cual nos creará un directorio llamado “env” donde python guardará las distintas dependencias que vayamos incluyendo en nuestro proyecto. Para activar el entorno virtual, utilizaremos

source env/bin/activate

Una ve activado el entorno virtual, haremos uso de «pip» para instalar las distintas dependencias que necesitaremos para nuestro proyecto. Al haber activado un entorno virtual estas dependencias se almacenarán en el directorio “env”. Vamos a instalar Django para este entorno:

pip install django

Con esto instalaremos la última versión de Django que haya disponible, si quisiéramos instalar una versión en concreto se le puede indicar a pip de la siguiente forma:

pip install <paquete>==<version>

4. Creación del proyecto

Una vez instalado Django, crearemos el esqueleto del proyecto, al cual llamaré “cursosproject” usando el comando (cuidado con el “.” al final del comando):

django-admin startproject cursosproject .

Con esto django creará el esqueleto mínimo de un proyecto de Django que por defecto utilizará SQLite como base de datos con la siguiente estructura:

.
├── cursosproject
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── env
│   └── ...
└── manage.py

Los dos ficheros mas interesantes de momento son el fichero settings.py y el fichero urls.py.

En el fichero settings.py se configura todo lo necesario para que Django funcione. Existen un monton de opciones disponibles (https://docs.djangoproject.com/en/1.9/ref/settings/), y ademas podemos crear nuestras propias variables de configuración.

El fichero urls.py actua como router y configura como responderá python a las distintas peticiones.

Para probar que todo ha ido bien podemos ejecutar el comando

python manage.py runserver

Y deberíamos ser capaces de ver lo siguiente en el navegador

5. Creación de aplicaciones

La mejor forma de trabajar con Python es mediante la creación de aplicaciones. De esta forma nos permite la creación de distintas funcionalidades que luego podremos integrar a nuestro proyecto.

Para crear una aplicación, utilizaremos el comando:

django-admin startapp cursos

Django nos creará un directorio con la siguiente estructura

cursos
├── __init__.py
├── admin.py
├── apps.py
├── migrations
│   └── __init__.py
├── models.py
├── tests.py
└── views.py

Por el momento nos centraremos en los ficheros models.py y tests.py. En el fichero models.py definiremos nuestro modelo de datos para nuestra aplicación. El el fichero tests.py crearemos nuestros tests unitarios.

Una vez creada nuestra aplicación, debemos indicarle a Django que la utilice añadiendola a la lista de aplicaciones instalada dentro del fichero settings.py del proyecto.

INSTALLED_APPS = [
    …,
    'cursos'
]

6. Creación de los modelos de datos

Vamos a crear un modelo sencillo para nuestra aplicación.

from django.db import models

class Curso(models.Model):
	activo = models.BooleanField()
	titulo = models.CharField(max_length=50)
	num_horas = models.PositiveIntegerField()
	profesor = models.ForeignKey('Profesor', on_delete=models.CASCADE)

	BASICO = 'B'
	INTERMEDIO = 'I'
	AVANZADO = 'A'
	NIVELES = (
		(BASICO, 'Basico'),
		(INTERMEDIO, 'Intermedio'),
		(AVANZADO, 'Avanzado'),
	)
	nivel = models.CharField(max_length=1,
							 choices=NIVELES,
							 default=BASICO)

	def __unicode__(self):
		return "Curso " + self.titulo

class Profesor(models.Model):
	nombre = models.CharField(max_length=20)
	apellidos = models.CharField(max_length=40)

	def __unicode__(self):
		return self.nombre + " " + self.apellidos

Django se encargará de convertir cada una de las subclases de la clase Models a una tabla de la base de datos. Cada atributo que definamos dentro de estas clases se transformará en una columna de dicha tabla. Existen una gran cantidad de campos predefinidos en Django (https://docs.djangoproject.com/en/3.0/ref/models/fields/), y ademas estos pueden ser extendidos según nuestras necesidades. También existe una gran cantidad de métodos que se pueden sobreescribir para modificar el comportamiento por defecto, como por ejemplo el método “__unicode__()” que nos devuelve la descripción del objeto.

Una vez hemos terminado de definir nuestro modelo de datos, necesitamos indicarle a Django que construya o altere el esquema de la base de datos, para hacerlo utilizamos primero el siguiente comando:

python manage.py makemigrations

Este comando genera el código SQL necesario para modificar el esquema de la base de datos que irá almacenando en el directorio “migrations” dentro del directorio de la aplicación y que podremos revisar. La primera vez que lo ejecutemos se dedicará básicamente a construir las tablas, pero si modificamos a posteri el modelo de lo que se encargará será de generar el código necesario para modificar el esquema. Hay que tener cuidado en ciertos casos ya que si por ejemplo, renombramos una subclase de “Models”, puede suceder que al generar las migraciones este decida eliminar la tabla X y construir una tabla Y. En cualquier caso Django suele avisar cuando va a hacer cosas arriesgadas de este tipo.

Una vez realizadas las migraciones, para indicarle a Django que realice la modificación del esquema utilizaremos el comando:

python manage.py migrate

7. Plantillas y creación de vistas

Ahora que tenemos nuestro modelo de datos, es hora de mostrar la información. Existen múltiples formas de devolver la información que deseamos con Django, pero quizá una de las más interesantes es el mecanismo de templates que proporciona Django.

El sistema de templates combina código HTML con sintaxis propia de Django, de tal forma que cuando Django reemplaza su sintaxis propia con lo que corresponda genera el código HTML (https://docs.djangoproject.com/es/1.9/ref/templates/builtins/). Para empezar a utilizar el sistema de plantillas crearemos nuestra plantilla en la siguiente estructura de directorios dentro del directorio de nuestra aplicación.

cursos
├── ...
├── templates
│   └── cursos
│       └── listado_cursos.html

Aunque no es estrictamente necesaria esta estructura de directorios, si que es la que recomiendan los desarrolladores de Django. Añadiremos el siguiente código a la plantilla:

<head>
<style>
table, th, td {
	border: 1px solid black;
	border-collapse: collapse;
}
th, td {
	padding: 5px;
}
</style>
</head>
<body>
	<h1>Listado de cursos</h1>
	<table style="width: 100%">
		<thead>
			<td>Titulo</td>
			<td>Horas</td>
			<td>Nivel</td>
			<td>Profesor</td>
		</thead>
		{% for curso in cursos %}
		<tr>
			<td>{{curso.titulo}}</td>
			<td>{{curso.num_horas}}</td>
			<td>{{curso.nivel}}</td>
			<td>{{curso.profesor.nombre}} {{curso.profesor.apellidos}}</td>
		</tr>
	{% endfor %}
	</table>
</body>

El siguiente paso es hacer que nuestra vista renderice la plantilla. Para ello añadiremos el siguiente código a nuestro fichero “views.py”

from django.shortcuts import render
from cursos.models import Curso

def lista_cursos(request):
	lista_cursos = Curso.objects.all()
	return render(request, 'cursos/listado_cursos.html', {"cursos": lista_cursos})

Con esto le diremos a Django que consulte en base de datos todos los objetos de la clase curso. La función render se encarga de combinar el template con el diccionario, de tal forma que en el template se encargará de reemplazar las ocurrencias de “cursos” por el contenido de “lista_cursos“.

8. Rutas

En este punto la aplicación ya cuenta con un modelo de datos básico y una vista con la que mostrar los datos. Ahora necesitamos que cuando una URL concreta, ya sea root o por ejemplo “/cursos”, nos muestre la página que nosotros queramos. Para ello emplearemos el fichero “urls.py” que se encuentra en el directorio “cursosproject” y añadiremos lo siguiente.

from django.conf.urls import url
from django.contrib import admin
from cursos import views as cursos_views

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^$', cursos_views.lista_cursos)
]

Las URL están formadas por una expresión regular, y la función que queremos que Django ejecute para responder a la petición cuando solicita una URL que coincide con dicha expresión regular.

Podemos comprobar en nuestro navegador que accediendo a la URL raíz nos muestra la respuesta a nuestra petición.

Se puede ver que Django nos devuelve nuestra plantilla pero, como aún no hemos introducido ningún dato en nuestra base de datos la tabla está vacía. Podemos refactorizar el código de nuestra plantilla para mejorarla un poco.

<head>
<style>
table, th, td {
	border: 1px solid black;
	border-collapse: collapse;
}
th, td {
	padding: 5px;
}
</style>
</head>
<body>
	<h1>Listado de cursos</h1>
	{% if cursos %}
		<table style="width: 100%">
			<thead>
				<td>Titulo</td>
				<td>Horas</td>
				<td>Nivel</td>
				<td>Profesor</td>
			</thead>
		{% for curso in cursos %}
			<tr>
				<td>{{curso.titulo}}</td>
				<td>{{curso.num_horas}}</td>
				<td>{{curso.nivel}}</td>
				<td>{{curso.profesor.nombre}} {{curso.profesor.apellidos}}</td>
			</tr>
		{% endfor %}
		</table>
	{% else %}
		<p> Actualmente no hay cursos disponibles </p>
	{% endif %}
</body>

De esta forma ahora mostrará un mensaje algo más detallado cuando la tabla de cursos aún esté vacía.

9. Interfaz de administración

Ahora que tenemos los elementos básicos de nuestra aplicación, solo nos hacen falta datos. Existen muchas maneras de generar esos datos, como por ejemplo usando directamente SQL sobre la base de datos, creando una vista con un formulario que permita introducir esos datos… Pero una de las formas más simples y a la vez uno de los componentes más potentes de Django es su interfaz de administración.

La interfaz de administración nos permite realizar CRUD sobre los modelos que hayamos creado con tan solo registrarlos. Lo mejor de todo es que Django se encarga de crear la interfaz pertinente mediante introspección de los modelos.

Por defecto, cuando se genera un proyecto con la ayuda de “django-admin”, este se genera con la interfaz de administración habilitada. Si le echamos un vistazo a nuestro “urls.py”, se puede ver que existe la siguiente ruta:

url(r'^admin/', admin.site.urls)

Si accedemos a dicha URL veremos la siguiente página:

Para poder utilizar la interfaz de administración, antes debemos crear un superusuario. Para hacerlo utilizaremos el comando.

python manage.py createsuperuser

Que nos pedirá un nombre de usuario y una contraseña. Una vez creado, nos podremos loguear en la interfaz de administración.

Si queremos que se muestre en otro idioma distinto a la lengua de Shakespeare, podemos editar el fichero “settings.py”:

LANGUAGE_CODE = 'es-es'

Si queremos poder manipular los objetos de nuestro modelo, debemos indicarle a Django que los utilice en nuestra interfaz de administración. Para ello debemos modificar el fichero “admin.py” que se encuentra en el directorio de nuestra aplicación y añadir el siguiente código.

from django.contrib import admin
from cursos.models import Curso, Profesor

admin.site.register(Curso)
admin.site.register(Profesor)

Si volvemos a acceder a la interfaz de administración, podemos ver que aparece un nuevo apartado llamado “Cursos” (el nombre de nuestra aplicación):

Ahora podemos crear, editar y eliminar objetos cómodamente desde la interfaz de administración.

Una vez hemos añadido contenido veremos que la vista que creamos empieza a mostrar el contenido:

10. Conclusiones

Django es un framework muy completo y muy interesante. En este tutorial solo hemos rascado un poco de la superficie, pero existen múltiples temas a tratar.

Sin duda uno de sus puntos fuertes es su interfaz de administración, de una forma rápida, sencilla y cómoda se puede añadir a nuestra aplicación web la posibilidad de editar el contenido con un usuario autenticado con unos permisos específicos.

También es ampliamente personalizable, tanto los modelos, la etiquetas de las vistas e incluso la interfaz de administración puede ser personalizada según nuestras propias necesidades, ya sea creando nuevos tipos de datos, nuevos widgets, nuevos tags.

El propio framework también contiene numerosas aplicaciones y middleware para funcionalidades como la autenticación de usuarios, internacionalización, sesiones, y un largo etcétera. Y por si esto fuera poco, también es fácil incorporar aplicaciones o middleware creados por la comunidad, como por ejemplo “django rest framework” para facilitar el desarrollo de una API REST.

Como desventajas, hay que decir que la curva de aprendizaje es un poco dura, sobre todo al principio. Otra posible desventaja es el hecho de que Django está planteado para trabajar con sistemas de gestión de bases de datos relacionales, algo que hay que tener en cuenta en función de la aplicación a desarrollar.