Django lo hizo un mago


En las películas, a menudo, se encuentran errores imposibles de explicar: un tarro que se derrama y aparece lleno, gafas que aparecen y desaparecen, espadas que se transforman en martillos... En esos casos decimos que "lo hizo un mago".

En esta ocasión no es que un mago haya hecho Django, sino que hay un equipo impresionante detrás. Pero sí es cierto que Django hace mucha magia.

Me gustaría comenzar aquí un pequeño tutorial rápido para usar Django, utilizando toda la magia. Este tutorial no valdrá en todos los casos, pero dará un buen punto de comienzo para aplicaciones más avanzadas.

Este artículo utiliza el mismo ejemplo que el que escribí hace tiempo Django: Creación de un sitio básico, pero creo que lo encontraréis muy mejorado.

Creación de un blog

Como ejemplo, vamos a crear un blog personal. No tendrá grandes cosas: nos basta con que sea funcional. Tendrá lo típico: posts, tags y paginación. Por no complicarnos la vida, no tendrá ni comentarios, aunque no sería difícil añadirlos.

Ése es nuestro objetivo, y vamos a conseguirlo lanzando "balas trazadoras", es decir, definiendo una funcionalidad e implementándola de pincipio a fin. Veremos así cómo la aplicación va obteniendo la forma...

Me gustaría comenzar por la vista, pero en este caso creo que es mejor comenzar por el modelo. Empezar por la vista tiene sus ventajas: evita añadir cosas que uno no necesita. Sin embargo, en este caso, comenzar por el modelo nos va a dar mejor perspectiva de lo que estamos haciendo.

1. Entorno

Vamos a crear el entorno. Para ello voy a crear un entorno aislado:

$ virtualenv venv
New python executable in venv/bin/python
Installing setuptools, pip...done.
$ . venv/bin/activate
(venv)$ pip install Django==1.7.1
Downloading/unpacking django
Installing collected packages: django
Successfully installed django
Cleaning up...
(venv)$

Con esto tenemos nuestro entorno aislado. No voy a hablar aquí sobre Virtualenv, pip ni otras herramientas. Voy a centrarme en Django.

Ahora voy a crear la estructura básica de la aplicación. Para evitar problemas, voy a llamar al proyecto app:

(venv)$ django-admin startproject app
(venv)$ tree  app
app
├── app
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py

1 directory, 5 files
(venv)$

Bien. Con esto tenemos lo justo para empezar. A partir de ahora, todo lo que hagamos estará dentro del directorio app (el de nivel superior, se entiende).

No voy a generar más archivos. A partir de ahora todo lo escribiremos nosotros. De todas maneras, os dejo con "los planos" de lo que vamos a hacer:

app
├── app
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
├── blog
│   ├── admin.py
│   ├── __init__.py
│   ├── models.py
│   └── views.py
├── db.sqlite3
├── manage.py
└── templates
    └── blog
        └── post_list.html

Si no os apetece ir creando los archivos, podéis descargaros el código así:

$ git clone git@github.com:magmax/django-blog.git
$ git checkout 0.1.0

2. Aplicación

Lo primero es crear una aplicación. En Python un paquete es cualquier directorio con el fichero __init__.py. En Django, una aplicación es un paquete Python con un archivo models.py. Así que vamos a crear una aplicación blog:

(venv)app$ mkdir blog
(venv)app$ touch blog/__init__.py
(venv)app$ touch blog/models.py
(venv)app$

Y ahora hay que registrarla. Para ello se edita el archivo app/settings.py. Veremos que es un archivo Python normal, definiendo variables. Buscamos INSTALLED_APPS y añadimos 'blog':

python-django/001/app/app/settings.py

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'blog',
)

Ya hemos creado una aplicación.

Podemos crear la base de datos mediante:

$(env)app$ python manage.py syncdb

Y siguiendo los pasos. Con eso vamos a crear una base de datos sqlite con las tablas necesarias para las aplicaciones instaladas.

Veámoslo:

$(env)app$ python manage.py runserver 8000

Tendréis la app funcionando en http://localhost:8000 y también podréis acceder a la interfaz de administración en http://localhost:8000/admin (luego lo explico).

Bien... Suficiente para empezar.

3. El modelo

Al grano:

python-django/001/app/blog/models.py

from django.db import models


class Tag(models.Model):
    name = models.CharField(max_length=100)

    def __unicode__(self):
        return self.name


class Post(models.Model):
    title = models.CharField(max_length=100)
    teaser = models.TextField()
    body = models.TextField()

    tags = models.ManyToManyField(Tag, related_name="posts",
                                  null=True, blank=True)

    created = models.DateTimeField(auto_now_add=True)
    updated = models.DateTimeField(auto_now=True)

    def __unicode__(self):
        return self.title

Lo explico: Tenemos dos clases que heredan de django.db.models.Model: Tag y Post.

La clase Tag se sencilla: tiene un único campo (field) llamado name, de longitud 100. Si trato de pintar la clase se ejecutará el método __unicode__, mostrando sólo el título.

La clase Post es más compleja: Tiene un título, un teaser y un body. Además puede contener cero o más Tags:

  • related_name: permite una relación inversa. En este caso, dado un objeto de tipo Tag podría acceder a todos los Post relacionados mediante tag.posts.
  • null: Permite valores nulos.
  • blank: Permite insertar valores vacíos (sutil diferencia con null).

Además tenemos los campos created y updated de los que no nos preocuparemos. Son de tipo fecha y se gestionan automáticamente.

Aplicamos:

(venv)app$ python manage.py migrate

Pero yo quiero crear posts....

4. Admin

Ahora vamos a acrear el archivo app/admin.py:

python-django/001/app/blog/admin.py

from django.contrib import admin

from . import models


admin.site.register(models.Tag)
admin.site.register(models.Post)

Y si volvemos a lanzar el servidor:

$(env)app$ python manage.py runserver 8000

Y nos vamos a la interfaz de administración en http://localhost:8000/admin, veremos que Django nos ha creado todo lo que necesitamos para añadir posts. Adelante, cread alguno :D

5. Enrutado

Todo está funcionando, pero nos falta la interfaz de usuario. Temo que en este apartado vamos a romper lo poco que llevamos.

Editamos el archivo app/urls.py y añadimos una ruta nueva:

python-django/001/app/app/urls.py

from django.conf.urls import patterns, include, url

from django.contrib import admin
admin.autodiscover()

from blog import views


urlpatterns = patterns('',
    url(r'^$', views.PostListView.as_view(), name='home'),
    url(r'^admin/', include(admin.site.urls)),
)

(Ojo, que hay varios cambios). En general, se parece a una de las líneas que nos ofrecen...

En Django hay dos maneras de crear una vista: mediante una clase o mediante una función. En este caso he optado por la clase, ya que pretendo aprovechar el sistema de herencia.

Y esto no funciona porque aún no existe la clase views.PostListView, así que vamos a crearla:

6. El controlador (Views)

Por desgracia, en Django llaman "view" al controlador. Así que tenemos que escribir el archivo blog/views.py:

python-django/001/app/blog/views.py

from django.views.generic.list import ListView

from . import models


class PostListView(ListView):
    model = models.Post

Y podemos intentar acceder a http://localhost:8000/ para ver un bonito error: nos falta el archivo blog/post_list.html.

Lo primero será editar el archivo app/settings.py para indicar dónde estarán las plantillas (templates), por lo que añadiremos:

python-django/001/app/app/settings.py

TEMPLATE_DIRS = [
    os.path.join(BASE_DIR, 'templates'),
]

Y después editaremos el archivo templates/blog/post_list.html por algo muy básico:

python-django/001/app/templates/blog/post_list.html

<ul>
  {% for post in post_list %}
  <li>{{ post.title }}</li>
  {% endfor %}
</ul>

Magia. En este momento todo cuadra y funciona.

El truco

Ahora es cuando contamos secretos de magos: ¿Dónde está el truco?

Bien... lo que hemos usado son un montón de convenciones.

Cuando en el navegador se indica una URL, Django comprueba cada expresión regular del archivo app/url.py hasta que una de ellas se cumple. Entonces invoca a la función que tenga asociada. En nuestro caso, esta función es el wrapper .as_view(), que devuelve una función.

Esta función as_view(), sabe que debe invocar ciertos métodos de esa clase. En nuestro caso hemos dejado las implementaciones por defecto de la clase django.views.generic.list.ListView. Ésta necesita un modelo, que le hemos indicado en la variable PostListView.model y con esto se pone a funcionar:

  • obtiene la lista de elementos del modelo
  • genera una variable de "contexto"
  • asigna la lista de elementos a una variable "<model>_list" en el contexto
  • busca la plantilla "<application>/<model>_list.html"
  • renderiza la plantilla con el contexto.

Django nos ofrece la posibilidad de sobreescribir cualquiera de esos puntos, pero estamos aprendiendo y, en este momento, lo mejor es dejarle hacer a él. Si este tutorial tiene tirón, veremos cómo hacerlo.

Más información

Podéis encontrar toda la información en el tutorial de Django

Este artículo continúa en Django lo hizo un mago: paginación y detalle, donde creamos el detalle de cada post y paginamos la página de índice. Después sigue en Django lo hizo un mago: plantillas y contextos, donde se crea un menú con las categorías y se mejoran las plantillas.


Comentarios

Comments powered by Disqus