La clase Forms de django

Los formularios en django son clases que heredan la clase Forms del módulo django.forms, las partes más interesantes de este módulo son los:

• Widgets: son los elementos que forman un formulario, por ejemplo: un cuadro para la introducción de texto (<input type="text">).
• Campos: Son clases que representan el tipo de datos que tendrán las diferentes partes del formulario, de modo que al enviar el formulario se validarán que se introducirán ese tipo de datos. Por ejemplo: CharField indicará un campo de texto (como se puede ver es similar a los datos de los modelos).
  Además, los campos se transforman automáticamente en widgets que tienen asociados de forma predeterminada, o indicándoles el widget que se quiere usar.

En el caso que se ha venido realizando en estos posts, un formulario para introducir los datos del usuario podría ser:

# forms.py
#-*- coding: utf-8 -*-

from django import forms

class FormularioUsuario (forms.Form):
    """Formulario para guardar un usuario en la base de datos."""

    nombre = forms.CharField (max_length=40)
    apellidos = forms.CharField (max_length=40)
    email = forms.EmailField ()

Este formulario se podrá utilizar en la vista correspondiente de modo que cualquiera pueda introducir los datos de un usuario y que la vista los procese para guardarlos en la base de datos.

Utilizando el formulario en una vista de django

Una vez creado el formulario se podrá utilizar desde una vista, de modo que se puedan recibir y validar los datos que alguien introduzca en dicho formulario. En el caso de ejemplo se podría tener una vista para guardar nuevos usuarios:

# views.py
# -*- coding: utf-8 -*-

from proyecto.aplicación.forms import FormularioUsuario
from proyecto.aplicación.models import Usuario
from django.shortcuts import render_to_response

def guardar_usuario (request):
    """Guarda los datos de un usuario en la base de datos."""

    # Se ha enviado el formulario utilizando POST
    if request.method == 'POST':

        # Se consiguen los datos del formulario
        form = FormularioUsuario (request.POST)

        # Se validan los campos del formulario
        if form.is_valid():
            usuario = Usuario ()

            # Se consiguen los datos filtrados del formulario
            usuario.nombre = form.cleaned_data['nombre']
            usuario.apellidos = form.cleaned_data['apellidos']
            usuario.email = form.cleaned_data['email]

            try:
                usuario.save ()

                # Se redirecciona a la página que confirma que
                # se ha guardado el usuario
                return HttpResponseRedirect ('/usuario/guardado/')

            # No se ha podido guardar
            except:
                return HttpResponseRedirect ('/usuario/incorrecto/')    

    # Algún dato del formulario es incorrecto
    else:
        # Se crea un formulario vacío
        form = FormularioUsuario ()

    # Se vuelve a la página del formulario
    return render_to_response ('usuario.html', { 'form': form })

Para mostrar el formulario en el archivo «usuario.html» (que es una plantilla de django) se puede utilizar el siguiente trozo de código:

<form action="/guardar/" method="post">
    {{ form.as_p }}
    <input type="submit" value="Guardar" />
</form>

Con esto se muestra el formulario separando los elementos de éste entre párrafos, existen otras formas de mostrar el formulario utilizando otro tipo de separadores, como siempre para más información está la documentación sobre cómo representar los formularios en las plantillas de django.

Creando un formulario a partir de un modelo de django

Si como en este caso se quiere crear un formulario que contendrá los mismos datos que un modelo ya creado, django permite crear formularios a partir de modelos ya creados. Para ello sólo se debe crear la clase del formulario que herede la clase ModelForm del módulo django.forms y luego crear una clase Meta dentro de la del formulario.

En este caso sería algo así:

# forms.py
#-*- coding: utf-8 -*-

from proyecto.aplicación.models import Usuario
from django import forms

class FormularioUsuario (forms.ModelForm):
    """Formulario generado a partir del modelo Usuario."""

    class Meta:
        model = Usuario

Este ejemplo es bastante básico, ya que este método de creación de formularios partiendo de modelos tiene bastante más opciones, como la posibilidad de excluir campos del modelo en el formulario, ordenarlos, etc.

Como siempre lo mejor es consultar la documentación sobre cómo crear formularios partiendo de modelos de django.

Las vistas

Las vistas se encargan de la capa lógica de la aplicación web, esto es realizan las tareas necesarias sobre los datos recibidos y devuelven los datos necesarios para que se muestren en la web.

En el caso de django, las vistas son funciones de python que reciben un objeto HttpRequest y que devolverán un objeto HttpResponse. Estas funciones se relacionarán con diferentes direcciones de la aplicación web, gracias al archivo «urls.py».

Creando una vista

Como ya se explicó brevemente en el post de introducción a django, las vistas se definen en el archivo «views.py» de la aplicación a desarrollar.

Siguiendo con el ejemplo del modelo de un usuario, se podrían definir las siguientes vistas:

# views.py
# -*- coding: utf-8 -*-

from proyecto.aplicación.models import Usuario
from django.shortcuts import render_to_response

def mostrar (request):
    """Muestra los datos de los usuarios de la base de datos."""

    usuarios = Usuario.objects.all ()
    return render_to_response ('mostrar.htm',
                               { 'usuarios' : usuarios })

En este ejemplo se ha definido una vista para mostrar todos los usuarios de la base de datos, para ello se puede ver que se hace uso de un «QuerySet» (explicado en el post sobre los modelos de django).

Además, se puede observar que la función de la vista recibe un parámetro request (que será un objeto HttpRequest) y devuelve un objeto HttpResponse mediante la función render_to_response, que genera una página HTML a partir de una plantilla y los datos que se le proporcionen mediante un diccionario (en este ejemplo el diccionario sólo contendrá los usuarios de la base de datos).

Asociando direcciones a las vistas

Una vez creadas las funciones de las vistas, éstas se deberán asociar con sus correspondientes direcciones dentro de la aplicación web, todo esto se realiza editando el archivo «urls.py». Este archivo contiene, básicamente, una variable llamada urlpatterns a la que se asignan una serie de tuplas de expresiones regulares que definen las direcciones y sus funciones asociadas.

Siguiendo el ejemplo, la aplicación tendría el siguiente archivo «urls.py»:

# urls.py
# -*- coding: utf-8 -*-

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'^usuario/mostrar/$', 'proyecto.aplicación.views.mostrar'),
)

El archivo «urls.py» se crea a nivel de proyecto, pero se puede dividir en varios, de modo que se puedan definir las direcciones a nivel de aplicación para una mayor modularidad y reutilización.

Como siempre, para más información se puede consultar la documentación sobre cómo asociar direcciones a las vistas en django.

Una breve introducción a las plantillas

Django usa un lenguaje de plantillas para generar las páginas web de la aplicación, estas plantillas son archivos HTML con algunas etiquetas propias de Django, que éste procesará y sustituirá por el contenido adecuado. Las etiquetas del lenguaje de plantillas de django permiten hacer muchas cosas, como: bucles, condiciones, herencia de plantillas, internacionalización, …

Los archivos de las plantillas se pueden crear a nivel de proyecto o de aplicación. Normalmente, se suele crear una plantilla base de la que se heredará la estructura en las plantillas de las diferentes aplicaciones del proyecto, de modo que éstas tengan una mayor modularidad.

Estos archivos se pueden guardar en cualquier directorio dentro del proyecto y/o aplicación, pero por conveniencia se suelen crear directorios llamados «templates» a nivel de proyecto y aplicación, además django suele buscar en estos directorios de forma predeterminada, mientras que si se les da otro nombre, se deberán configurar las rutas de estos directorios en el archivo «settings.py».

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
    "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

<html>

<head>
    <meta http-equiv="Content-type" content="text/html; charset=utf-8" />

    {% if usuario %}
        <title>Lista de usuarios</title>
    {% else %}
        <title>No hay ningún usuario</title>
    {% endif %}

</head>

<body>

    {% if usuarios %}

        {% for usuario in usuarios %}
        <h1>{{ usuario.email }}</h1>

        <p>{{ usuario.nombre }} {{ usuario.apellidos }}</p>
        {% endfor %}

    {% else %}

        <h1>No hay ningún usuario.</h1>

        <p>La base de datos de usuarios está vacía.</p>

    {% endif %}

</body>

</html>

En este ejemplo se puede ver que la plantilla trata la lista de usuarios que recibe de la vista y muestra cada usuario, o un mensaje de error si la lista no tuviera ningún usuario. El lenguaje de las plantillas de django intenta ser lo más parecido a Python, siempre que no tengamos en cuenta las llaves y los porcentajes necesarios para marcar las etiquetas de la plantilla.

Para más información se puede consultar la documentación sobre el lenguaje de las plantillas de django.

Los modelos

Al basarse django en el MVC, divide la aplicación en dos partes la vista (que ya se pudo ver en el anterior post) y el modelo. El modelo define los datos que utilizará la aplicación, como podrían ser los datos de un usuario (nombre, apellidos, dirección, …).

En el caso de django, los modelos serán clases de python que heredarán la clase Model y que utilizarán unos tipos de datos especiales para definir sus atributos. Más tarde, django, gracias a su ORM, transformará estas clases en tablas de la base de datos del proyecto.

Creando un modelo

Los modelos se definen en el archivo «models.py» de la aplicación de django que los vaya a utilizar. Cada modelo será una clase de python que heredará la clase django.db.models.Model, los atributos de las clases de cada modelo deberán ser instancias de unas clases que ofrece django para poder traducir estos atributos en campos de las tablas de la base de datos. Por ejemplo, para crear el modelo de un usuario:

# models.py
# -*- coding: utf-8 -*-

from django.db import models

class Usuario (models.Model):
    """Datos del usuario utilizados en la aplicación."""

    nombre = models.CharField (max_length=40)
    apellidos = models.CharField (max_length=60)
    email = models.EmailField (unique=True)

    def __unicode__ (self):
        return '%s %s (%s)' % (self.nombre, self.apellidos, self.email)

Una breve explicación sobre el ejemplo anterior:

• Los atributos nombre y apellidos serán dos campos de texto con una longitud máxima de 40 y de 60 caracteres respectivamente en la base de datos.
• El atributo email será un campo de texto cuyo valor deberá ser único y que además sólo aceptará direcciones de correo electrónico bien formadas.
• El método __unicode__ es el equivalente a __str__ en python, es decir, se usará cuando se quiera mostrar una instancia de la clase como una cadena de caracteres.

Para conocer los tipos existentes para los atributos de los modelos, siempre se puede consultar la lista de los tipos de los modelos de django.

Una vez se tengan los modelos creados, se deberán sincronizar con la base de datos utilizada.

Configurando la base de datos

Configurar la base de datos a utilizar en django es muy sencillo, sólo hay que editar el archivo «settings.py» del proyecto. Concretamente las siguientes variables:

• DATABASE_ENGINE indica el gestor de base de datos utilizado, actualmente django sólo dispone de los siguientes módulos: postgresql_psycopg2, postgresql, mysql, sqlite3 u oracle.
• DATABASE_NAME indica el nombre de la base de datos, menos en el caso de sqlite3 que indica la ruta al archivo de la base de datos.
• DATABASE_USER indica el usuario con acceso a la base de datos anterior.
• DATABASE_PASSWORD indica la contraseña del usuario anterior.
• DATABASE_HOST indica la dirección del servidor de la base de datos, se debe dejar vacío para la máquina local.
• DATABASE_PORT indica el puerto del servidor de la base de datos, se debe dejar vacío para usar el puerto predeterminado.

Aviso: El usuario, la contraseña, la dirección y el puerto del servidor no se usan con sqlite3, ya que no son necesarios.

Una vez configurada la base de datos y creados los modelos necesarios, se podrá sincronizar los modelos de las aplicaciones del proyecto con la base de datos, sólo hay que ejecutar:

$ python manage.py syncdb

Nota: Hay que recordar que las aplicaciones del proyecto aparecen en la variable INSTALLED_APPS del archivo «settings.py», yo recomendaría (para estos ejemplos) quitar o comentar las que vienen de manera predeterminada.

Trabajando con la base de datos

Esta es una de las mejores cosas que tiene django, y es que para acceder (ya sea para consultar, insertar, actualizar o borrar una entrada) a la base de datos, gracias al ORM sólo se usan las clases definidas como modelos.

Para probar todo lo que se va a explicar sin tener que crearse vistas (que todavía no se han explicado en profundidad) siempre se puede ejecutar la consola de django:

$ python manage.py shell

Insertar, actualizar y borrar entradas

Tomando como ejemplo la clase Usuario anterior, se podría realizar:

from proyecto.aplicación.models import Usuario

# Insertar un nuevo usuario
usuario = Usuario (nombre='Pepe', apellidos='Garcia',
                   email='pepe@garcia.es')
usuario.save ()

# Actualizar los datos del usuario
usuario.nombre = 'Jose'
usuario.save ()

# Borrar el usuario
usuario.delete ()

Como se puede ver es tan sencillo como trabajar con cualquier clase de python.

Los «QuerySets»

Los «QuerySets» son conjuntos de objetos de la base de datos, es decir, los resultados de una consulta a la base de datos en forma de objetos de python.

Las clases de los modelos disponen de una instancia del gestor de objetos de la base de datos Clase.objects, en esta instancia se definen los diferentes métodos para realizar las consultas sobre la base de datos, que devolverán un «QuerySet» que contendrá los resultados.

De este modo, tomando el ejemplo de la clase Usuario:

from proyecto.aplicación.models import Usuario

# Insertar varios usuarios
usuario = Usuario (nombre='Pepe', apellidos='Garcia',
                   email='pepe@garcia.es')
usuario.save ()

usuario = Usuario (nombre='Maruja', apellidos='Perez',
                   email='maruja@perez.es')
usuario.save ()

usuario = Usuario (nombre='Pedro', apellidos='Garcia',
                   email='pedro@garcia.es')
usuario.save ()

# Conseguir todas las entradas de la base de datos
todos_los_usuarios = Usuario.objects.all ()
print 'Todos los usuarios %s' % todos_los_usuarios

# Conseguir los usuarios que se apelliden Garcia
garcias = Usuario.objects.filter (apellidos='Garcia')
print 'La familia Garcia %s' % garcias

# La familia Garcia ordenada por nombre
print 'La familia Garcia ordenada por nombre %s' % garcias.order_by ('name')

Como siempre esto no es más que una mota de polvo de lo que en realidad se puede hacer, para profundizar lo mejor es consultar la documentación de django sobre los «QuerySets».

¿Qué es django?

Django es un entorno de desarrollo (lo que en inglés se denomina framework) para la creación rápida de aplicaciones web, basándose en el MVC (Modelo-Vista-Controlador).

Entre todas las posibilidades que ofrece están que permite trabajar con las bases de datos como si no existieran, la creación de URL bonitas sin tener que tocar nada del servidor web, el uso de plantillas en (X)HTML para la creación de las diferentes páginas, y muchas cosas más, todas ellas estupendas y supongo que todas ellas también las tendrán otros entornos similares que utilicen otros lenguajes de programación.

Iniciando un nuevo proyecto

Lo primero que se debe hacer en django es crear lo que se denomina un proyecto, éste a su vez contendrá aplicaciones que serán las que contengan el código utilizado en la aplicación web. Por poner un ejemplo: el proyecto sería un CMS y las aplicaciones las diferentes funcionalidades de dicho CMS.

Para ello se deberá ejecutar:

$ django-admin.py startproject nombre_del_proyecto

Esto creará un directorio, llamado «nombre_del_proyecto», con los archivos básicos de todo proyecto de django:

• __init__.py es el archivo de inicialización de cualquier paquete de python.
• manage.py permitirá la gestión del proyecto de django, como: crear las aplicaciones del proyecto, crear las bases de datos, ejecutar un servidor web para probar el proyecto, …
• settings.py contiene la configuración del proyecto, básicamente contiene un montón de variables que utilizará django para la configuración.
• urls.py contiene los patrones de las direcciones de las diferentes vistas del proyecto de django.

Lo malo es que sólo con esto no se va a poder hacer nada más que cambiar unos cuantos valores de la configuración, para que un proyecto haga algo deberá tener al menos una aplicación que contendrá el código necesario.

Iniciando una nueva aplicación

Para crear una aplicación se debe usar el archivo «manage.py» del proyecto del siguiente modo:

$ python manage.py startapp nombre_de_la_aplicación

Esto creará un directorio, llamado «nombre_de_la_aplicación», con los archivos básicos de toda aplicación de django:

• __init__.py igual que antes, es el archivo de inicialización de cualquier paquete de python.
• models.py contendrá los modelos de la aplicación, estos modelos son clases de python que se traducirán en tablas en la base de datos.
• tests.py contendrá tests de la aplicación. Nota: Este archivo sólo se crea a partir de la versión 1.1 de django.
• views.py contendrá las vistas de la aplicación, estas vistas son funciones de python que realizarán las tareas necesarias para mostrar el resultado como una página web.

Para que esta aplicación esté disponible en el proyecto, hay que añadirla a la lista de aplicaciones del proyecto que está en el archivo «settings.py».

INSTALLED_APPS = (
    'hello_world.hello_app',
)

Nota: Cuando se crea un nuevo proyecto django crea una lista de aplicaciones predeterminada, que en este caso daría lo mismo borrarlas.

Creando un «hola mundo»

Lo primero será crear un proyecto («hello_world») y una aplicación («hello_app») para dicho proyecto, tal y como se ha mencionado antes. Una vez hecho, se deberá crear una vista para la página web.

Creando una vista

Para la creación de una vista, se debe editar el archivo «views.py» de la aplicación creada del siguiente modo:

# views.py
# -*- coding: utf-8 -*-
# Views used in hello world application.

from django.shortcuts import render_to_response

def hello (request):
    """Hello view function."""

    return render_to_response ('hello.htm',
                               { 'hello_msg' : '¡Hola mundo!' })

La función render_to_response usa una plantilla (que ahora se explicará) para crear la página web de la vista.

Creando una plantilla

Django dispone de un lenguaje propio para la creación de plantillas, básicamente son archivos HTML con unas etiquetas especiales, que se marcan con llaves dobles, que django se encargará de rellenar.

De este modo, crear una plantilla es tan sencillo como crear un archivo HTML en un directorio llamado «templates» dentro del directorio del proyecto o de la aplicación. En este caso valdría crear un archivo llamado «hello.htm» (es el que se usa en la función hello) en el directorio «templates» de la aplicación «hello_app».

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
    "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">

<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">

<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
    <title>{{ hello_msg }}</title>
</head>

<body>
    <p>{{ hello_msg }}</p>
</body>
</html>

Esta es una plantilla muy sencilla, el lenguaje de las plantillas de django permite realizar muchas más cosas, como herencia entre plantillas, definir bloques, bucles, …

Definiendo una dirección para la vista

Una vez creada la vista y su plantilla, habrá que definir una dirección para poder acceder a la vista. Como se mencionó al principio, para eso está el archivo «urls.py» del proyecto. Este archivo contiene una lista de direcciones a las que se les asignará unas vistas, de modo que cuando se abra esa dirección la vista asignada se encargue de crear su correspondiente página web.

En este caso, el archivo «urls.py» quedaría del siguiente modo:

# urls.py
# -*- coding: utf-8 -*-
# Django URL patterns for hello world project.

from django.conf.urls.defaults import *

urlpatterns = patterns('',
    (r'', 'hello_world.hello_app.views.hello'),
)

Como se puede ver, lo único que se hace es añadir un patrón (una expresión regular) con una vista asociada. En este caso se trata de una dirección vacía (r''), la raíz del dominio, a la que se asocia la función hello que se definió en las vistas de la aplicación.

Probando la aplicación web

Una vez llegado a este punto, ya se puede probar la aplicación web, para ello no hace falta tener ningún servidor web instalado, ya que django dispone de uno para realizar pruebas. Para ejecutarlo, desde el directorio del proyecto:

$ python manage.py runserver

Y aquí concluye esta introducción básica, pero larga, próximamente más. Si os ha gustado y queréis ir aprendiendo por vuestra cuenta, siempre podéis leer la documentación oficial de django.

Python es un lenguaje interpretado, similar a Java en la forma de ejecutarse, ya que se ejecuta sobre una MV.

En este libro se explican todos los aspectos de Python, para gente que desconozca completamente este lenguaje (como me pasaba a mí cuando lo leí). El libro es bastante grande, el índice marca como última página la 681, pero es que abarca todos los aspectos básicos de Python, no incluye todos los módulos que forman parte de Python.

El libro se divide en siete partes más los apéndices:

1. Comenzando (Getting started)
2. Tipos y operaciones (Types and operations)
3. Estamentos y sintaxis (Statements and syntax)
4. Funciones (Functions)
5. Módulos (Modules)
6. Clases y POO (Classes and OOP)
7. Excepciones y herramientas (Exceptions and tools)
8. Apéndices (Appendixes)

En general, me ha parecido un libro genial para introducirte en este lenguaje, quizá muchas veces peca de, podríamos decir, ingenuo y cuenta cosas que cualquiera que se dedique a la programación sabe y se puede saltar.

Recomendación: Alta.
Nivel: Bajo/Medio.
Idioma: Inglés.