Curso Python. Volumen XIX: Framework Django. Parte VIII

Escrito por Javier Ceballos Fernández

Bienvenidos un día más al curso de Python, en el capítulo anterior os mostramos cómo se pueden personalizar los formularios de administración. Hoy vamos a empezar a crear nuestras primeras vistas para la aplicación que estamos desarrollando con el framework Django. Así que pongámonos manos a la obra.

Lo primero que vamos hacer es saber qué es una vista. Una vista es un “tipo” de página web dentro de nuestra aplicación “Django” que generalmente provee una función específica y tiene una plantilla asociada. Por ejemplo, si estuviéramos diseñando un blog, podríamos implementar las siguientes vistas:

  • Página de inicio del Blog – para mostrar las últimas entradas.
  • Detalle de una entrada – sería la página que corresponde a una entrada o post.
  • Archivo anual – donde mostraríamos los meses de un año con sus correspondientes entradas.
  • Archivo mensual – donde mostraríamos los días de un mes con sus correspondientes entradas.
  • Archivo diario – donde mostraríamos todas las entradas de un día determinado.
  • Acción de comentar – aquí realizaríamos la inserción de comentarios en una entrada determinada.

Si trasladamos este concepto a nuestra aplicación de encuestas, empezaríamos por crear las siguientes vistas:

  • Página de inicio – donde mostraríamos las últimas preguntas publicadas.
  • Detalle de una pregunta – mostraríamos el texto de la pregunta, sin resultados, junto con un formulario para votar.
  • Página de resultados – mostraríamos los resultados para una pregunta determinada.
  • Acción de votar – insertaría el voto por la opción seleccionada en una pregunta determinada.

En Django, las páginas web y otros contenidos se manejan mediante vistas. Cada vista se representa por una simple función Python o método, como es en el caso de las vistas que se basan en clases. “Django” elige una vista examinando la URL que se pidió (para ser precisos, la parte de la URL después del nombre de dominio).

Las URLs que podemos encontrar en la web pueden ser como la siguiente: “ME2/Sites/dirmod.asp?sid=&type=gen&mod=Core+Pages&gid=A6CD4967199A42D9B65B1B”. Para evitar este tipo de URL que resulta ilegible, “Django” nos permite definir patrones de URL para asegurarnos de que sean más fáciles de leer.

Un patrón de URL es simplemente la forma genérica de una URL – por ejemplo: /newsarchive/<year>/<month>/. Para llegar de una URL a una vista, “Django” usa lo que se conoce como un “configurador de URL”. Un “configurador de URL” mapea los patrones de URL (descriptos como expresiones regulares) a vistas.

Si deseáis más información sobre el uso del “configurador de URL”, sólo tenéis que buscar en la documentación de “Django” la librería django.conf.urls.

Escribiendo nuestra primera vista

Vamos a escribir nuestra primera vista. Para ello abriremos el archivo polls/views.py y escribiremos el siguiente código Python:

polls/views.py
from django.http import HttpResponse

def index(request):
    return HttpResponse("Hello, world. You're at the polls index.")

Esta es la vista más simple que podemos realizar en “Django”. Para llamar a esta vista, necesitamos asignarla una URL y para ello necesitamos un “configurador de URL”. Para crear un “configurador de URL”, tendremos que crear un archivo llamado “urls.py” dentro de la carpeta “polls”. Una vez creado el archivo, nuestro árbol de carpetas, debería verse del siguiente modo:

polls/
    __init__.py
    admin.py
    models.py
    tests.py
    urls.py
    views.py

En el archivo “polls/urls.py” que acabamos de crear deberemos introducir el siguiente código:

polls/urls.py
from django.conf.urls import url
from . import views

urlpatterns = [
    url(r'^$', views.index, name='index'),
]

Una vez realizado esto, el siguiente paso será apuntar el “configurador de URL”  raíz al módulo “polls.urls”. En “mysite/urls.py” introduciremos un “include()” del siguiente modo:

mysite/urls.py
from django.conf.urls import include, url
from django.contrib import admin

urlpatterns = [
    url(r'^polls/', include('polls.urls')),
    url(r'^admin/', include(admin.site.urls)),
]

De esta manera, ya habremos conectado una vista “index” en el “configurador de URL”. Si ahora abrimos la dirección http://localhost:8000/polls/ en nuestro navegador, deberíamos ver el texto “Hello, world. You’re at the polls index.”, que definimos en la vista “index”.

La función “url()” tiene cuatro argumentos, dos obligatorios: “regex” y “view”, y dos opcionales: “kwargs”, y “name”. A continuación os vamos a explicar para que sirve cada uno de ellos.

url(): argumento regex

El término “regex” se usa comúnmente como abreviatura para expresión regular, que es una forma de describir patrones que definen un “string”, o en este caso patrones de URL. “Django” empezará con la primera expresión regular e irá recorriendo la lista hacia abajo, comparando la URL solicitada contra cada expresión regular hasta encontrar una cuyo patrón coincida.

Fijaros en que estas expresiones regulares no comprueban los parámetros de GET o POST, o el nombre de dominio. Es decir, que si solicitamos al servidor la siguiente URL: “http://www.example.com/myapp/2, el “configurador de URL” buscará por “myapp/”. Y en el caso de solicitar esta otra: “http://www.example.com/myapp/?page=3”, el “configurador de URL” también buscará por “myapp/”.

Si necesitases ayuda con las expresiones regulares, siempre podrás ver nuestro artículo sobre este tema. Lo podréis encontrar en esta dirección. Finalmente, comentaros que estas expresiones regulares se compilan la primera vez que el módulo del”configurador de URL” es cargado. Son muy útiles de usar y son muy rápidas en su ejecución.

url(): argumento view

Cuando “Django” encuentra una expresión regular que coincide, realiza una llamada a la función “view” que se ha especificado, enviándole un objeto “HttpRequest” como primer argumento y los valores que se hayan “capturado” a partir de la expresión regular como argumentos restantes. Si la “regex” usa capturas simples (sin nombre), los valores se pasan como argumentos posicionales; si se usan capturas con nombre, los valores se pasan como argumentos nombrados.

url(): argumento kwargs

Se utiliza para pasar argumentos arbitrarios dentro de un diccionario a la “view” que vamos a llamar. Esta opción no la utilizaremos en esta aplicación:

url(): argumento name

Nombrar las URL nos permite referirnos a ellas de forma inequívoca desde distintas partes del código, especialmente en las plantillas. Esta característica nos permite hacer cambios globales a los patrones de URL del proyecto cambiando tan sólo un archivo (ya que el nombre permanece sin cambios, y nos referimos a una URL por su nombre).

Hasta aquí el capítulo de hoy, como habréis podido comprobar crear estas vistas no es muy difícil, en los siguientes capítulos seguiremos dando forma a nuestra aplicación de “Django.

Os invitamos como siempre a que sigáis explorando este framework y probando. Y para todos los que se acaban de incorporar indicarles que tenemos un índice con todos los capítulos del curso, ya que nunca es tarde para empezar.

Últimos análisis

Valoración RZ
7
Valoración RZ
9
Valoración RZ
8
Valoración RZ
8
Valoración RZ
8
Valoración RZ
8
Valoración RZ
10