Taller Django

Introducción
El desarrollo web no es tarea fácil, en los tiempos que corren actualmente se están
gestando cambios significativos en los paradigmas orientados a la web.

Crear funcionalidades completas, que comprendan todas, el dinamismo que el usuario

busca, creando librerías para automatizar parcialmente el trabajo, manejadores de bases de
datos, interfaces gráficas sencillas para la administración, pero a la vez potentes, para brindar
una solución completa. Esto sin entrar en el asunto de la seguridad, estabilidad y compatibilidad
de las mismas.

Una vez resuelto el asunto de las funcionalidades, comienza el arduo trabajo de

actualización de estas “librerías mágicas”, con las que están basados todos nuestros desarrollos
hasta el momento.

Cuando hayamos terminado este paso, nos daremos cuenta que empleamos nuestro
tiempo, creando y manteniendo funcionalidades, en vez de emplearlas en nuestros proyectos.

Como solución completa a este problema, algunos programadores comenzaron a agrupar

en paquetes funcionalidades orientadas a las labores básicas, que la mayoría de los
desarrolladores de sistemas emplean en sus proyectos. De este modo surgieron los Frameworks,
que permiten, pasar menos tiempo programando funcionalidades, para utilizarlo en los aspectos
más fundamentales de los sistemas que estamos desarrollando.
 Taller Django

Django Framework
Django es un framework de desarrollo web de código
abierto, escrito en Python, que cumple en cierta
medida el paradigma del Modelo Vista Controlador.
Fue desarrollado en origen para gestionar varias
páginas orientadas a noticias de la World Company
de Lawrence, Kansas, y fue liberada al público bajo
una licencia BSD en julio de 2005; el framework fue
nombrado en alusión al guitarrista de jazz gitano Django Reinhardt. En junio del 2008 fue
anunciado que la recién formada Django Software Foundation se haría cargo de Django en el
futuro.

La meta fundamental de Django es facilitar la creación de sitios web complejos. Django

pone énfasis en el re-uso, la conectividad y extensibilidad de componentes, el desarrollo rápido y
el principio No te repitas (DRY, del inglés Don't Repeat Yourself). Python es usado en todas las
partes del framework, incluso en configuraciones, archivos, y en los modelos de datos.

Preparando el entorno
Antes de nada, cabe recordar, que Django está totalmente escrito en el Lenguaje de
Programación Python, por lo que lo deberás tener instalado en tu sistema.

Si usas GNU/Linux o Mac OS X, es más que seguro, de que tengas instalado una versión
de python, de lo contrario puedes visitar http://www.python.org/ para descargar según la
plataforma donde lo necesites usar.

Un método simple de saber si tienes instalado python en tu computadora es abrir una

consola y escribir “python” (sin comillas). Y deberías ver algo similar a esto:

Python 2.7.1+ (r271:86832, Apr 11 2011, 18:05:24)

[GCC 4.5.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

Esto significa que tienes python, corriendo sin problemas en tu sistema.

Descargar e Instalar Django

Ahora que sabes que tienes python instalado, es momento oportuno para comenzar a
trabajar con Django, y comenzar a embeber un par de procedimientos que realizarás cada vez
que comiences un proyecto desde cero.
 Taller Django

Para obtener una copia de Django, en su última versión, visita

http://www.djangoproject.com/ y sigue las instrucciones para descargar tu copia. (Hacer clic en
descargar y guardar el archivo, así de simple)

Cuando ya tengas tu archivo comprimido, debes descomprimirlo usando el descompresor

que tengas en tu sistema.

Bajo GNU/Linux y Mac OS X, escribe en una consola:

tar xzvf Django-*.tar.gz

Esto, generará una carpeta con el Nombre “Django-*versionActual*” (*versionActual*
es la versión de Django que hayas descargado).

Si utilizas otro sistema operativo, usa el descompresor que tengas instalado para realizar
la operación anterior.

Con estos archivos, tenemos lo necesario para instalar Django en nuestro sistema, para
ello navega, hasta la carpeta generada en la extracción del archivo .tar.gz, abre una consola en
ese lugar (o bien navega desde una que hayas abierto) y escribe:

sudo python setup.py install

Su estas en otras plataformas, puedes abrir una terminal de sistema, con privilegios
administrativos, y escribir:

python setup.py install

Setup.py creará los directorios necesarios, como así también todos los enlaces y librerías
que necesites para comenzar a crear y modelar tus proyectos con Django.

Primeros Pasos con Django

Una vez finalizada la instalación, estamos listos para verificar, si todo esta en orden y preparado
para comenzar a desarrollar, para ello, verificar la versión instalada de Django es un buen
comienzo. Abre una consola python y escribe lo siguiente.

>>> import django

>>> print django.VERSION
 Taller Django
Corriendo estos comandos, obtendrás una serie de números, que representan la versión
exacta de Django que tienes corriendo. Por ejemplo, Django 1.4 estable imprimiría en pantalla
algo como (1, 4, 0, 'final', 0), lo que significa, que estas corriendo la versión 1.4, que fue
liberada como estable.

Nota:
Este material, está pensado para entornos de desarrollo bajo GNU/Linux, la mayoría de
las instrucciones explícitas y comandos estarán orientadas al mismo, exceptuando instrucciones
de Django, que son estándares para todas las plataformas que este soporte.
 Taller Django

Primer proyecto Django

El momento esperado, ¡comenzar a desarrollar! . Antes de cualquier cosa que queramos

iniciar con Django, primero debemos crearlo (se supone, que el desarrollador tiene almenos una
idea dispersa del proyecto y sus elementos), para que el framework genere los elementos básicos
que necesitamos para empezar a construir nuestro sistema.

Para ello, nos situamos en un directorio, que utilicemos para nuestro desarrollo, (se
aconseja crear un directorio vacío, que únicamente albergue elementos relacionados con este
propósito), y escribimos en una terminal (ubicada en el antes mencionado directorio) el
comando.

django-admin.py startproject miProyecto

Django-admin.py recibe como parámetro la sentencia “startproject” para crear una

carpeta llamada “miProyecto”, y en su interior 4 archivos, en su interior y un subdirectorio
llamado de igual forma que nuestra aplicación, en este caso “miProyecto”.

Expliquemos un poco, la filosofía o el modo de trabajo de Django, es un poco diferente

que el de otros sistemas que quizás hemos utilizado. Django “mira” a los proyectos como el
nombre lo dice “projects” que se refiere a todo nuestro desarrollo, es decir, el proyecto es
nuestro sistema.
En cambio, cada funcionalidad o requerimiento de manejo de datos, se denomina
“aplicación” o “app”, que están incluidos en nuestro proyecto. Debido a este enfoque, nuestra
aplicación inicial, del proyecto “miProyecto”, albergada en el subdirectorio “miProyecto”, con
el mismo nombre, aparece como parte del mismo.

Cerrando el asunto, y volviendo al grano, un proyecto de Django, se compone de una

serie de archivos, que utilizaremos a lo largo de nuestro desarrollo.

__init__.py: Es un archivo vacío. Por ahora, no necesitas poner nada allí, éste es usado,
para señalar a python que el directorio, es un módulo completo.

manage.py: Es el manejador, del proyecto, contiene los manipuladores y referencias de

todas las aplicaciones que tendrá nuestro sistema, además es el punto de arranque para
iniciar el servidor que hace referencia a nuestro proyecto.

settings.py: Este es el módulo de configuraciones de Django, que contiene toda la

configuración de nuestro proyecto.
 Taller Django
urls.py: En este archivo, se encuentra el manejador principal de rutas del proyecto,
Django maneja las urls, como por ejemplo “www.misitio.com/articulos”, como si fueran
rutas referenciadas a las aplicaciones que configuremos, usando un método similar al de
subdirectorios en un servidor como “Apache”.

Nota: en las nuevas versiones de Django, el subdirectorio de cada aplicación contiene los
archivos antes mencionados, exceptuando manage.py, dado que una aplicación, no debería
manejar todo un proyecto, y agregando en su lugar wsgi.py, que permite enlazar el servidor
Django de nuestro proyecto como elemento CGI a, por ejemplo Apache.
 Taller Django

Un simple CMS
Uno de los desarrollos más populares, es crear un Sistema de Manejo de Contenidos
(CMS), que le permite al usuario crear y administrar páginas basándose en una interfaz
administrativa.

Para ello, crea un proyecto llamado “cms”, al igual que creamos nuestro ejemplo
“miProyecto”, en el inciso anterior. Sitúate en el directorio del directorio “cms” del proyecto, y
abre con tu editor preferido, el archivo settings.py .

• Bases de datos
Una vez abierto, verás, cuan largo es, pero no te compliques todavía en pensar que es
todo eso, simplemente vamos a modificar un par de líneas para enlazarlo a nuestro motor de
base de datos. Comienza a moverte en el archivo, y busca la línea “DATABASE_ENGINE”,
encontrarás algo similar a esto.

DATABASES = {
'default': {
'ENGINE': 'django.db.backends.',
'NAME': '',
'USER': '',
'PASSWORD': '',
'HOST': '',
'PORT': '',
}
}

ENGINE: El motor de bases de datos, que emplearemos en el proyecto. Agrega, “mysql”,

“postgresql_psycopg2”, “postgresql”, “sqlite3” u “oracle”, según corresponda.
NAME: El nombre de la base de datos, o la ruta del archivo, si usas Sqlite
USER: Usuario de la base de datos, (no es necesario en Sqlite)
PASSWORD: Clave del usuario, (no es necesario en Sqlite)
HOST: La ip, o la dirección, del servidor de bases de datos.
 Taller Django
PORT: El puerto del servidor, donde corre el motor de bases de datos.

Ahora, tenemos configurado nuestro acceso al motor de bases de datos, que emplearemos
para el proyecto.

• Templates

Seguiremos en el archivo, configurando el directorio de “Templates”, que utilizaremos,

para especificar el lugar donde se encuentran las plantillas que se renderizarán en los retornos
de vista. Busca la línea del archivo de configuración, en la que aparezca algo así.

TEMPLATE_DIRS = (
'primerBlog/templates', #Agrega esto, como elemento de la tupla
)

Y agrega la línea 'primerBlog/templates', como elemento de la tupla. Seguido a esto, crea

una carpeta, llamada “templates” dentro de la carpeta de la aplicación del proyecto. En este
caso dentro de /mipath/primerBlog/primerBlog.

• Aplicaciones Instaladas

Una vez configuradas las opciones de bases de datos y templates, solo nos falta un paso
más, el inciso de “aplicaciones instaladas”, que contiene las aplicaciones que django, enlaza
para utilizarlas como disponibles. Para ello navegamos hasta la línea que contenga algo similar
a esto.

INSTALLED_APPS = (
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.sites',
'django.contrib.messages',
'django.contrib.staticfiles',
'primerBlog', # Agregamos esta línea para habilitar a nuestra aplicación
'django.contrib.admin', # Agregamos esta línea para habilitar el administrador
)
 Taller Django
• Modelos
Una forma de desarrollo organizado, debe implementar técnicas genéricas que
permitan la flexibilidad de expresar los datos, que nuestro proyecto necesita para
funcionar. Por ejemplo en un blog, los artículos se componen de elementos individualizados
que agrupados forman un artículo completo, el título, bajada, contenido y fecha.
En Django, estos elementos se ven reflejados en las bases de datos, con lo que los
modelos deben ser de intermediarios entre las bases de datos y nuestro esquema de
abstracción. En Django, los modelos se encuentran en el archivo “models.py”, (de no
existir, crearlo), con el siguiente código en su interior.

from django.db import models

class articulo(models.Model):

titulo = models.CharField(max_length = 100)

fecha = models.DateTimeField(auto_now_add=True)
bajada = models.TextField()
cuerpo = models.TextField()

El objeto models, contiene todos los tipos de datos soportados, o serializados para
ser soportados por la mayoría de las bases de datos. Por “ejemplomodels.CharField()”
contiene las instrucciones para generar campos VarChar de longitud definida por
“max_length”. Un modelo instanciado, es un objeto capaz de editar, eliminar y generar
nuevos registros en las bases de datos.

• Admin

Un problema esencial en el desarrollo de sistemas, son los las interfaces que

permiten al usuario, tener el control de su sistema. El framework nos ofrece una plataforma
flexible, seguro y potente que es autogenerado en base a un archivo de configuración, que
por supuesto está escrito en python.
Situados en el directorio de la aplicación, el archivo “admin.py”, contiene toda la
información necesaria para que Django pueda generar los elementos necesarios, vistas, y
esquemas de administración. El script admin.py debe contener.

from django.contrib import admin # Importa el módulo de admin

from primerBlog.models import articulo # Importa el modelo de datos

admin.site.register(articulo) # Enlazamos el modelo al

# administrador
 Taller Django
• Views

Desde un principio mencionamos, y en varias ocasiones interfaces gráficas, vistas,

hasta configuramos un directorio “templates” en nuestro archivo de configuración para
almacenar las plantillas que se usarán para renderizar las respuestas, al llegar a este
punto, algunos suelen pensar ¿que otra cosa hará una vista?, en teoría sí, una vista, como
el nombre hace referencia, debería devolver al cliente una “vista” del proceso realizado.
Pero en Django, las vistas toman un nuevo rumbo, una vista es una interfaz
intermedia, que relaciona datos recibidos, con los modelos de datos, y genera una
respuesta apropiada al cliente. Probablemente estés pensando “no es tan complicado, es
solo HTML”, ¡pero no es así!, porque las vistas pueden generar vistas HTML, inclusiones
CSS organizadas, hasta respuestas AJAX, inclusiones JQuery controladas, y hasta usarse
como servidor de funciones JavaScript.

Bien, con esta breve pero descriptiva introducción a las vistas, comencemos a
generar la nuestra, las vistas, es decir cada interacción, se guarda dentro del archivo
“views.py”. La estructura básica de una vista es la siguiente.

from django.shortcuts import render_to_response # Renderizador de respuesta

from primerBlog.models import articulo # Modelo, para acceder a la
# base de datos
def home(request):
pass

Para organizar un poco las cosas, definamos algunos elementos que aparecen en
este script.

El objeto “render_to_response”, es el encargado de generar una respuesta para el

cliente, este es el objeto que puede configurarse para responder desde un documento
HTML, hasta una cadena JSON.

En este caso “articulo”, es el objeto del modelo, que permite la consulta con las
bases de datos, pero puede ser una librería de manejo de sockets, una función que lea un
archivo, o simplemente cualquier objeto que genere una respuesta “String”, si es que se
desea responder al cliente, caso contrario, puede ser cualquier objeto que ejecute una
función, el único detalle, es que ese objeto no podrá referirse como elemento de respuesta a
la plantilla.

La función “home()”, hereda del objeto “request”, que contiene las funciones
necesarias para manejar consultas desde el servidor. Cada función que definamos, es
considerada como una vista individual, y accesible desde los patrones ubicados en
“urls.py”. Tener en cuenta que cada función debe heredar al objeto “request”.
 Taller Django
Ahora que tenemos claro como se compone una vista, expliquemos un poco, como
funciona la asignación dinámica en las plantillas. La función “render_to_response”, puede
recibir de modo opcional un diccionario, con las referencias de las claves, donde son
reemplazadas por su valor explícito. Así que generemos una para nuestro ejemplo.

def home(request):
entradas = articulo.objects.all()[:10]
data = {"articulos" : entradas}
return (render_to_response("home.html", data))

Expliquemos un poco esto, “articulo.objects.all()[:10]”, invoca al modelo de datos,

y obtiene todos los registros de la base de datos, en la tabla “articulo”. Recuerda que el
modelo es el “capacitado” para manejar la base de datos, en un inciso posterior se
expondrá mejor el funcionamiento de “models”. Bien, esta consulta la almacenamos en la
variable “entrada”, que se compone como valor de la clave “articulos” del diccionario
almacenado en “data”, queda más que razonable mencionar que pueden agregarse más
claves y valores a este diccionario y pasarlos al renderizador.
Y como ultima línea “render_to_response” como retorno de esta vista, aquí nos
detenemos un momento. Si recuerdas bien, en el inciso de “setting.py”, creamos un
directorio llamado “templates”, que luego enlazamos al archivo de configuración bajo el
parámetro “TEMPLATE_DIRS”, bueno allí mismo crearemos un archivo llamado,
lógicamente “home.html” con el siguiente código dentro de la estructura básica de un
archivo html (DOCType, etiquetas html, etc), dentro de las etiquetas “body”.

<body>
<h3>Blog</h3>
<hr />
{% for post in articulos %}
<h2>{{ post.titulo }}</h2>
<h3> Posteado el {{ post.fecha }}</h3>
<p> {{ post.bajada }}</p>
<p> {{ post.cuerpo }}</p>
<hr />
{% endfor %}

</body>

Ahora bien, pongamos atención total al sistema de plantillas que ofrece Django. Si
recuerdas bien, a la función “render_to_response”, pasamos como parámetro un
diccionario que contenía la clave “articulos”, bien, esa misma clave es referenciada para
obtener su valor asociado, y como ese valor asociado es un objeto, podemos iterar sobre él.

Cada vez que necesitemos mostrar una variable en una plantilla, lo único que
 Taller Django
tenemos que hacer es encerrarla en llaves dobles “{{ mivariable }}”, y estas pueden estar
iteradas por una función. Y vamos otra vez pero con funciones, cada vez que necesitemos
hacer una función iterable lo único que necesitamos hacer es encerrarla dentro de llaves
seguidas del carácter porcentual “{% funcionIterable %}”, podemos incluir bucles “for” y
validaciones “if” por ejemplo, y terminamos la iteración de dicha función con una llave
seguida del carácter porcentual y la palabra “end” seguida del nombre de la función “{%
endfuncionIterable %}”.

Ahora bien, aparece la pregunta clásica, ¿que hace post.titulo?, y obtiene una
respuesta muy fácil, “post.titulo”, hace referencia al objeto “models” asociado en el
diccionario, donde “titulo”, “fecha”, “bajada” y “cuerpo”, son los atributos del objeto, es
decir los campos de la base de datos.

• Manage.py

Una vez llegado a este punto, tenemos nuestro CMS configurado, y listo para
funcionar, pero antes unos comandos esenciales. Sincronizar los modelos con las bases de
datos y correr el servidor, para ello.

python manage.py syncdb

Con este comando sincronizamos todos los modelos a las bases de datos, y Django,
crea por nosotros los necesarios para generar el Administrador, para ello, nos solicitará
usuarios y claves durante este proceso.

python manage.py runserver

Con este comando arrancamos el servidor y podemos empezar a utilizar nuestro

proyecto sin problemas, opcionalmente, runserver toma como parámetro extra ip y puerto
para resolver por red, o acceso externo. Para implementarlo se ejecuta de la siguiente
forma.

python manage.py runserver 192.168.0.102:8000

• Models Extra

Como anexo, al manejo de modelos proponemos como ejemplo, el uso de creación,

obtención y eliminación de registros. Tomamos como ejemplo el modelo articulo, que
utilizamos en el desarrollo del cms.
 Taller Django
Crear un nuevo registro.

b2 = articulo(titulo='Titulo de articulo', fecha=None, bajada='Mi bajada de

articulo', cuerpo='Cuerpo de articulo')

b2.save()

Primero, generamos un objeto artículo, asignando a cada campo un contenido, y lo

almacenamos en b2, ahora es este último el que contiene un nuevo elemento de registro.
Por último guardamos los datos llamando al método “save”.

Obtener un registro

b2 = articulo.objects.all() # Obtenemos todos los elementos

b2 = articulo.objects.get(titulo='MiTitulo') # Obtenemos un objeto en base a un
# criterio

Filtros Específicos

b2 = articulo.objects.filter(titulo__startswith= “MiTitulo”)
# Titulo inicia con “MiTitulo”, por ejemplo si tenemos “MiTitulo1”, “MiTitulo2”,
# etc en nuestra base de datos

b2 = articulo.exclude(titulo__icontains= “Excluir”)
# Excluir si el titulo contine “Excluir”

b2 = articulo.objects.filter(titulo=“mitutulo”)
# Filtro cuando titulo es igual a “mititulo”

b2 = articulo.objects.order_by(“titulo”)[0]
# Primer artículo, ordenado por “titulo”

b2 = articulo.objects.get(titulo__iexact= “MiTituloExacto”)
# El título contiene exactamente “MiTituloExacto”

b2 = articulo.objects.get(cuerpo__contains= “Python”)
# El cuerpo contiene la cadena “Python”

Los filtros pueden tomar como parámetros más de una limitante, es decir
“articulo.objects.filter(titulo=“mititulo”, bajada= “bajada1”)” y enlazar una salida a
otra, es decir “articulo.objects.filter(titulo=“mititulo”).filter(bajada= “bajada1”)”.
 Taller Django
Eliminar un registro

b2 = articulo.get(titulo= “mitituloEliminar”)
b2.delete()

Obtenemos un objeto con una condición, lo eliminamos con “delete()”.

Actualizar un registro

# Método 1
b2 = articulo.get(titulo = “miTutulu”)
b2.update(titulo= “miTitulo”)

# Método 2
b2 = articulo.get(titulo = “miTutulu”)
b2.titulo = “miTitulo”
b2.save()

Obtenemos un objeto filtrado, y podemos optar si cambiamos explícitamente o

implícitamente, dependiendo de los métodos que empleemos, y guardamos las
modificaciones.