Introdución

Django, pronunciado "yango" en la que la letra 'D' se hace muda (cosa que no sabía y lo pronuncie mal durante mucho tiempo), es un framework para desarrollar aplicaciones web con el lenguaje de programación Python.

Personalmente considero a Python un lenguaje grandioso, uno de los mejores lenguajes de programación multipropósito que existen:

Python es un lenguaje de programación multiparadigma, ya que soporta orientación a objetos, programación imperativa y en menor medida programación funcional. Es un lenguaje interpretado, usa tipado dinámico y es multiplataforma.

-Wikipedia

Mucha gente estará de acuerdo conmigo en que python es un lenguaje muy bien estructurado en muchos aspectos a comparación de otros lenguajes como php en sus inicios, python en este sentido me parece que ha sido un lenguaje mejor diseñado y planeado, ya que es versátil y tiene una sintaxis bastante simple y limpia entre muchas otras virtudes;  El framework Django fue creado para tener todo el poder del lenguaje python en el backend (lado de servidor) para acelerar el proceso de desarrollo de aplicaciones web y que además me parece bien documentado; Desde hace ya años, aproximadamente desde el 2005 Django comenzó a hacerse popular y ampliamente ser utilizado tras su liberación bajo la licencia BSD.

A estas alturas puede parecer poco innovador, trillado o poco práctico escribir una publicación sobre hacer algo tan básico como es un "Hello world" en Django, cuando incluso ya tiene tiempo de estar dentro del top 10 de los mejores frameworks para desarrollo web, pero tengo la esperanza de que esto sirva como una oportunidad para todos los programadores web que ya programan con otros lenguajes como PHP con frameworks como Laravel o Codeigniter (que somos muchos jaja) que no han usado nunca Django se animen a usarlo, aún en plena era donde incluso NodeJS va adquiriendo un auge impresionante; Recuerden que el conocimiento extra sobre tecnologías como esta no le hacen mal a nadie, y menos en el ámbito de la informática. Ahora que finalmente he terminado un curso de Django, he decidido realizar este ejemplo y clarificar las bases de lo que es construir un proyecto con Django... bien, pues sin tanta habladuría pasemos a lo interesante.

Hello Django

Para iniciar un proyecto Django necesitamos:

1- Tener instalado python en nuestro sistema (si utilizas GNU/Linux no tienes que preocuparte por ello, prácticamente todas las distribuciones cuentan con python ya instalado, puedes comprobarlo escribiendo en la terminal $ python -v) de cualquier manera podemos encontrar la guia de instalación y descargas en el sitio oficial de python: https://www.python.org/downloads/

2- Instalar pip, este es un sistema de gestión de paquetes utilizado para instalar y administrar paquetes de software escritos en python, (precisamente lo utilizaremos para instalar posteriormente el paquete Django)

3- Instalar Django, para instalarlo basta con ir a la línea de comandos y escribir:

1
$ pip install django

Como material de apoyo para este ejemplo les dejo el enlace (al repo en mi github) con el código para que puedan probarlo y los (comandos y pasos) que utilice durante el proceso que son los mismos que estoy describiendo en esta publicación a mayor detalle.

Noten: que el tamaño del proyecto es realmente pequeño, un "hello world" en Django pesa en .zip apenas 11,7 kB, cuándo realizar un "hello world" con otras tecnologías como PHP con Laravel o .net la diferencia entre pesos es grosera (.net en lo personal me desagrada bastante y en general todo lo que sea iniciativa de micro$oft).

Una vez instalados Python, Pip y Django lo que tenemos que hacer es inicializar nuestro proyecto, para ello necesitamos tener ya disponible el comando django-admin desde la terminal justo después de instalar el paquete Django con pip, esta herramienta lo que nos permite entre muchas cosas inicializar nuestro proyecto de la siguiente manera:

1
$ django-admin startproject <nombre_proyecto>

# Con el comando anterior le estamos diciendo a Django que genere toda la estructura de carpetas y archivos necesarios mínimos para un proyecto, es necesario reemplazar <nombre_proyecto>  por el nombre de nuestro proyecto, en este caso lo he nombrado hello_django.

Estructura del proyecto

Ahora analizaremos la estructura de carpetas y archivos de un proyecto en Django enseguida de haber ejecutado el comando anterior:

1
$ tree hello_django/

#Con el comando tree sobre la nueva carpeta de nuestro proyecto ya generada, vamos a ver una estructura similar a la siguiente:

hello_django/ (esta es la carpeta principal del proyecto)
├── hello_django (esta es la carpeta principal que es un paquete para nuestro proyecto)
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py

aquí para mayor información

Descripción de archivos:
__init__.py
Es un archivo que incluso vacio convierte o le indica a python que esa carpeta es un módulo que puede ser importado.

settings.py Es un archivo en el que podremos configurar todo nuestro proyecto cosas globales como el (lenguaje, timezone, etc).

urls.py Este archivo sirve para configurar-definir las rutas de nuestro proyecto (tiene toda la función de un router).

wsgi.py Es un Web Server Gateway Interface, esta es una especificación que describe como el servidor web se comunica con nuestra aplicación, y como la aplicación web puede ser enlazada para procesar a una petición. para más información sobre este archivo (aquí)

manage.py Este archivo lo usaremos a menudo, este archivo nos va a permitir iniciar nuestra aplicación y ponerla a la escucha de cualquier request. No hay que confundir este archivo con el comando django-admin, puede ser común confundirlo ya que con manage.py podemos realizar tareas al pasar como argumento distintas opciones, cuando ejecutamos  este archivo desde la línea de comandos, (este archivo opino que podría compararse un poco en algunas funcionalidades a los comandos/herramientas composer o artisan de laravel en php).

Creando nuestra app dentro de Django

Hay que aclarar que un proyecto django mínimo, es la estructura de archivos descritos anteriormente. Un proyecto puede contener muchas aplicaciones, una aplicación es representada como otra carpeta dentro de la estructura de carpetas de nuestro proyecto, esto es muy interesante puesto que podemos reusar aplicaciones como se explica (aquí) entre proyectos.

Ahora que pretendemos crear nuestra primera app dentro de nuestro proyecto, la cual llamare hello_app , basta con ir al directorio donde encuentra el ya mencionado archivo manage.py, que está en la carpeta raíz de nuestro proyecto e introducir el siguiente comando :

1
$ python3 manage.py startapp hello_app
#Con el comando anterior le decimos al archivo manage.py dentro de la carpeta raiz de nuestro proyecto que inicialice una app que se llamará "hello_app".

NOTA: el comando utilizado es python3 en el caso de mi sistema
para referirme que use python en su versión 3 y no python 2.7,
ya que Django ya es compatible la versión 3 de python y hay que
estar conscientes de ello.

Nuestro comando anterior nos ha creado una app, que es una carpeta con la siguiente estructura:

#Nuevamente hacemos un tree para ver la estructura

1
$ tree hello_app/
├── admin.py
├── apps.py
├── __init__.py
├── migrations
│   └── __init__.py
├── models.py
├── tests.py
└── views.py

admin.py Es un archivo en el que podemos entre algunas cosas, poder registrar los modelos que queremos manejar desde el administrador de Django.

Quiero destacar que el administrador de Django es una de las cosas que más me agradaron y sorprendieron de este framework, prácticamente estamos hablamos de que Django cuenta con una herramienta de administración, con la cual podemos acceder desde el mismo navegador para administrar nuestros modelos, esta herramienta cuenta con un front-end en el cual podemos acceder con un usuario y contraseña para agregar nuevos registros a nuestros modelos.

Con este admin en resumen: podremos por ejemplo agregar un nuevo registro del  modelo persona, sin necesidad de haber programado ni una sola línea de código en una vista y/o controller, en el que sea necesario programar un formulario, incluso tenemos todas las posibilidades que un CRUD nos otorga de manera automática. Con el simple hecho de crear un modelo y registrarlo en el admin.py podemos:

  • Crear registros
  • Ver/leer registros
  • Actualizar registros
  • Eliminar registros

Este admin es muy útil sobre todo cuando queremos evitarnos todo el código necesario en la vista y el controller para implementar las funciones básicas del CRUD, o para ciertos modelos con registros que pueden no ser de alta prioridad en determinado punto del desarrollo de un sistema.

apps.py Es un archivo donde Django lleva un registro de las apps y guarda su configuración (por ejemplo el nombre, versión etc), y donde también nos ofrece la posibilidad de hacer introspección, además de que mantiene una lista de los modelos disponibles, para ver cómo podemos hacer introspección, analizaremos el contenido del archivo cuando es creado:

1
2
3
4
5
6
7
8
9
from django.apps import AppConfig
'''
Podemos darnos cuenta que en este archivo Django importa AppConfig
 en el que se maneja la configuración básica de nuestra app, también
 se ha creado una Clase con un atributo llamado 'name' el cual se le asigna
 el nombre de nuestra app.
'''
class HelloAppConfig(AppConfig):
    name = 'hello_app'

__init__.py Nuevamente tenemos estos archivos para facilitar la modularidad en python.

migrations Esta es una carpeta en la que se irán guardado los archivos intermedios cuando generamos archivos de migración con Django, hay que mencionar que Django tiene mecanismo ORM, esto quiere decir que podemos definir los modelos y el tipo de datos para cada uno de los campos de la base de datos desde archivos modelos .py y tener la posibilidad de ejecutar un comando $ python migrate para que Django automáticamente genere las migraciones con todas las tablas y registros dentro de nuestra base de datos, esto es es similar a los comandos en php con laravel del tipo $ php artisan migrate

models.py Como su nombre lo indica, es el archivo en el cual definiremos los modelos para nuestra app.

tests.py En este archivo podemos programar y correr pruebas unitarias, Django utiliza el módulo de la biblioteca estándar  de Python llamado unittest, este módulo define pruebas aprovechando y haciendo uso de del código basado en clases.

views.py Finalmente tenemos este archivo en el cual programaremos las vistas.

Nota: Muchos definen a Django como un framework que utiliza MVC, sin embargo he visto que la programación dentro de este, es del estilo MTV (no me refiero al canal de televisión jaja), me refiero a ( Model, Template, View) y no es necesario entrar en discusiones (ni enviar a la hoguera a nadie xD), simplemente esto sucede porque como algunos ya pudieron notar no existe un archivo controllers.py, esto quiere decir que toda la lógica de código controller es programada dentro de views.py,  que  prácticamente es equivalente a un controller, y en la que el template son las vistas de un MVC con código HTML para front-end, podemos aclarar esta "inconsistencia" visitando nuestra hermosa wikipedia (aquí).

Hasta este momento si nos posicionamos en la carpeta raíz del proyecto (donde se encuentra el archivo manage.py deberiamos de tener una estructura similar a la siguiente:

. (raíz del proyecto)
├── hello_app (nuestra aplicación que creamos con el comando manage.py startapp)
│   ├── admin.py
│   ├── apps.py
│   ├── __init__.py
│   ├── migrations
│   │   └── __init__.py
│   ├── models.py
│   ├── tests.py
│   └── views.py
├── hello_django (paquete que creamos con el comando django-admin startproject)
│   ├── __init__.py
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── manage.py

¿Ya programaremos nuestro hello_django ?

Después de todo este preámbulo en el que sin duda es necesario primero conocer la estructura de un proyecto Django, ahora sí pasaremos escribir unas poderosas líneas de código :)

En el archivo: hello_app/views.py

Programaremos lo siguiente:

1
2
3
4
5
6
7
from django.shortcuts import render
# to response in HTTP is necessary import form django.http module HttpResponse
from django.http import HttpResponse
# Create your views here.
# this method will return my hello code for the view
def index_hello(request):
    return HttpResponse('Hello world of Django my friend!! :)')

He comentado el código pero aún así explicaré con mayor detalle qué es lo que hace:

#Primeramente importo HttpResponse para poder regresar una respuesta por medio del protocolo HTTP que es generada desde un cliente (comúnmente un navegador web).
line 1: from django.http import HttpResponse

# Ahora para contestar a una petición http necesito definir una función en la que recibo la petición desde el cliente con el parámetro request
line 6: def index_hello(request):

# Esta función hace uso del HttpResponse para poder regresar un mensaje de respuesta de la siguiente manera
line 7:
return HttpResponse('Hello world of Django my friend!! :)');

Ruteando nuestra app

Ahora necesitamos registrar el ruteo hacia nuestra app para contestar a la petición.

En el archivo: hello_django/urls.py

1
2
3
4
5
6
7
8
9
from django.conf.urls import url
from django.contrib import admin
# Is very important to import all view from the app
from hello_app import views
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    #Here we route to my index_hello view from a raw text and using a regular expression
    url(r'^index/', views.index_hello)
]

En este archivo hay dos líneas importantes:

#Con la siguiente línea le indico a Django que importe la vista hello_app/views.py con la respuesta http que acabamos de programar desde nuestra hello_app.
line 4: from hello_app import views

Y con la línea:
# Registro el ruteo con la función url()
line 9: url(r'^index/', views.index_hello)

El primer parámetro r'^index/' es una expresión regular convertida a raw 'literal' es por eso la presencia del prefijo 'r', esta expresión regular hará match con cualquier petición http que contenga '^/index', hay que recordar que en las expresiones regulares el carácter especial o símbolo '^' indica el inicio de una cadena.

El segundo parámetro views.index_hello indicado primeramente que dentro de las views importadas tenemos una función index_hello que será el callback a esta petición cuando la expresión regular haga match.

Hasta aquí es todo lo que tenemos que programar, lo último que hace falta es probar nuestro código y levantar nuestro servicio web con:

output:
Django version 1.11.1, using settings 'hello_django.settings'
 Starting development server at http://127.0.0.1:8000/
 Quit the server with CONTROL-C.

Si todo sale bien podemos observar despues de ejecutar el comando que Django nos indica que la app esta levantada en http://127.0.0.1:8000/ bastaria entonces ir al navegador escribir la dirección http://127.0.0.1:8000/index para comprobar que hemos realizado correctamente nuestro ejemplo, felicidades si ya lo haz logrado :)

Para cerrar está publicación con broche de oro, quiero resaltar que el debugging y el reporte de errores es bantante sencillo de abordar con Django, ya que este es capaz de arrojarnos multitud de datos cuando tenemos un error como programadores, ejemplo:

Request Method: GET
 Request URL: http://127.0.0.1:8000/index/
 Django Version: 1.11.1
 Exception Type: NameError
 Exception Value:

name 'HttpREsponse' is not defined

Exception Location: /hello_django/hello_django/hello_app/views.py in index_hello, line 6
 Python Executable: /usr/bin/python3
 Python Version: 3.5.3

Claramente el error es de tipeo con 'HttpREsponse' en el que la 'E' no debería de ser uppercase, y si no es suficiente con el error log anterior mostrado, la página de error contiene otras secciones como el Traceback, Request information, Settings; Te invito a generar este tipo de errores una vez que hayas realizado tu app en Django a manera de prueba, solo para observar lo fácil que se hace el debugging en Django, recordemos que el debugging puede ser todo un dolor de cabeza en otros lenguajes como php.

¡ Usemos Django !, hasta la próxima.


-Un monster penguin de la gran comunidad GNU/Linux-