Tutorial de Django: comienza con Django 2.0

Django es un marco web Python de talla única que se inspiró en Ruby on Rails y utiliza muchas de las mismas metáforas para hacer que el desarrollo web sea rápido y fácil. Completamente cargado y flexible, Django se ha convertido en uno de los frameworks web más utilizados de Python.

Django incluye prácticamente todo lo que necesita para crear una aplicación web de cualquier tamaño, y su popularidad facilita la búsqueda de ejemplos y ayuda para varios escenarios. Además, Django proporciona herramientas para permitir que su aplicación evolucione y agregue funciones con elegancia, y migre su esquema de datos (si tiene uno).

Django también tiene la reputación de ser complejo, con muchos componentes y una gran cantidad de configuración "interna" requerida. En realidad, puede poner en marcha una aplicación sencilla en un plazo relativamente corto y luego ampliar su funcionalidad desde allí según sea necesario.

En esta guía, analizaremos la creación de una aplicación rudimentaria de Django 2.0 y analizaremos brevemente las características más importantes que ofrece a los desarrolladores web.

Actualización desde Django 1.x

Si tiene experiencia con una edición 1.x anterior de Django, estos son los cambios más importantes que debe tener en cuenta:

  • Django 2.0 solo es compatible con Python 3.4 y versiones posteriores. Python 2.x no será compatible con futuras versiones de Django.
  • Django 2 sigue el patrón de Python 3 de usar cadenas Unicode nativas siempre que sea posible. Algunas funciones de Django ya no aceptarán cadenas de bytes como entrada. 

Hay muchos otros cambios incompatibles con versiones anteriores, pero esos son dos de los más importantes, especialmente al iniciar nuevos proyectos.

Instalando las bibliotecas centrales de Django

Para instalar Django 2.0, necesitará Python 3.4 o mejor. Entonces, la forma más fácil de instalar Django es a través de la piputilidad de Python :

pip install django

Esto instala las bibliotecas centrales de Django y la django-adminutilidad de línea de comandos utilizada para administrar proyectos de Django.

Si desea trabajar con varias versiones de Django en paralelo, cree un entorno virtual, instale la versión deseada de Django allí y utilícela para el proyecto Django en cuestión.

Tenga en cuenta que no es necesario utilizar entornos virtuales para crear varios proyectos con una sola instancia de Django. Solo los necesita para usar diferentes revisiones de puntos del marco de Django  con diferentes proyectos.

Creando un nuevo proyecto de Django

Las instancias de Django están organizadas en dos niveles: proyectos y aplicaciones .

  • Un proyecto es una instancia de Django con su propia configuración de base de datos, configuraciones y aplicaciones. Es mejor pensar en un proyecto como un lugar para almacenar todas las configuraciones a nivel de sitio que usará.
  • Una aplicación es una subdivisión de un proyecto, con su propia ruta y lógica de representación. Se pueden colocar varias aplicaciones en un solo proyecto de Django. 

Para crear un nuevo proyecto de Django desde cero, ingrese al directorio donde desea almacenar el proyecto y escriba:

django-admin startproject

donde es el nombre tanto del proyecto como del subdirectorio donde se almacenará el proyecto. Asegúrese de elegir un nombre que no sea probable que choque con un nombre utilizado por Python o Django internamente. Un nombre como myprojfuncionará bien.

El directorio resultante debe contener un  manage.pyarchivo, que se utiliza para controlar el comportamiento de la aplicación desde la línea de comandos, y otro subdirectorio (también con el nombre del proyecto) que contiene los siguientes archivos:

  • Un __init__.pyarchivo, que Python usa para designar un subdirectorio como módulo de código.
  • settings.py, que contiene la configuración utilizada para el proyecto. Muchas de las configuraciones más comunes se completarán automáticamente.
  • urls.py, que enumera las rutas o URL disponibles para su proyecto Django, o para las que el proyecto devolverá respuestas.
  • wsgi.py, que utilizan los servidores web compatibles con WSGI, como Apache HTTP o Nginx, para servir las aplicaciones de su proyecto.

Antes que nada, pruebe el proyecto para asegurarse de que esté funcionando. Desde la línea de comando en el directorio que contiene el manage.pyarchivo de su proyecto , ejecute:

python manage.py runserver

Esto debería iniciar un servidor web de desarrollo disponible en //127.0.0.1:8000/. Visite ese enlace y debería ver una página de bienvenida simple que le indica que la instalación se realizó correctamente.

Tenga en cuenta que el servidor web de desarrollo no debe utilizarse para ofrecer un proyecto de Django al público. No se escalará para manejar el tráfico necesario.

Creando una aplicación Django

A continuación, necesitamos crear una aplicación dentro de este proyecto. Navegue al mismo directorio que manage.pyy emita este comando:

python manage.py startapp myapp

Esto crea un subdirectorio para una aplicación denominada myapp que contiene lo siguiente:

  • Un migrationsdirectorio. Contiene código utilizado para migrar el sitio entre versiones de su esquema de datos.
  • admin.py. Contiene objetos utilizados por las herramientas de administración integradas de Django. Si su aplicación tiene una interfaz de administración o usuarios privilegiados, debería configurar los objetos relacionados aquí.
  • apps.py. Proporciona información de configuración sobre la aplicación al proyecto en general, a través de un AppConfigobjeto.
  • models.py. Contiene objetos que definen las estructuras de datos que usa su aplicación para interactuar con las bases de datos.
  • tests.py. Contiene todas las pruebas utilizadas para garantizar que las funciones y los módulos de su sitio estén funcionando según lo previsto.
  • views.py. Contiene funciones que generan y devuelven respuestas.

Para empezar a trabajar con la aplicación, primero debemos registrarla con el proyecto. Para hacer esto, edite myproj/settings.pyy agregue una línea en la parte superior de la INSTALLED_APPSlista:

INSTALLED_APPS = [ ‘myapp.apps.MyappConfig’, ‘django.contrib.admin’, ... 

Si miras myapp.apps, verás un objeto pregenerado llamado MyappConfig, que es a lo que nos referimos aquí.

Agregar rutas y vistas a su aplicación Django

Las aplicaciones de Django siguen un patrón básico para procesar solicitudes:

  • Cuando se recibe una solicitud entrante, Django analiza la URL en busca de una ruta a la que aplicarla.
  • Las rutas se definen en urls.py, con cada ruta vinculada a una vista , es decir, una función que devuelve datos para ser enviados de vuelta al cliente. Las vistas se pueden ubicar en cualquier lugar de un proyecto de Django, pero es mejor organizarlas en sus propios módulos.
  • Views can contain the results of a template, i.e. code that formats requested data according to a certain design.

To get an idea of how all these pieces fit together, let’s modify the default route of our sample app to return a custom message.

Routes are defined in urls.py in a list named urlpatterns. If you open the sample urls.py, you’ll see urlpatterns already predefined:

urlpatterns = [ path(‘admin/’, admin.site.urls), ] 

The path function—a Django built-in—takes a route and a view function as arguments and generates a reference to a URL path. By default, Django creates an admin path that is used for site administration, but we need to create our own routes.

Add another entry, so that the whole file looks like:

from django.contrib import admin from django.urls import include, path urlpatterns = [ path(‘admin/’, admin.site.urls), path(‘myapp/’, include(‘myapp.urls’)) ] 

The include function tells Django to look for more route pattern information in the file myapp.urls. All of the routes found in that file will be attached to the top-level route myapp (e.g., //127.0.0.1:8080/myapp).

Next, create a new urls.py in myapp and add the following:

from django.urls import path from . import views urlpatterns = [ path(‘’, views.index) ] 

Django prepends a slash to the beginning of each URL, so to specify the root of the site (/), we just supply a blank string as the URL.

Now edit the file myapp/views.py so it looks like this:

from django.http import HttpResponse def index(request): return HttpResponse(“Hello, world!”) 

django.http.HttpResponse is a Django built-in that generates an HTTP response from a supplied string. Note that request, which contains the information for an incoming HTTP request, must be passed as the first parameter to a view function.

Stop and restart the development server, and navigate to //127.0.0.1:8000/myapp/. You should see Hello, world! appear in the browser.

Adding routes with variables in Django

Django can accept routes that incorporate variables as part of their syntax. Let’s say you wanted to accept URLs that had the format year/. You could accomplish that by adding the following entry to urlpatterns:

path(‘year/’, views.year) 

The view function views.year would then be invoked through routes like year/1996, year/2010, and so on, with the variable year passed as a parameter to views.year.

To try this out for yourself, add the above urlpatterns entry to myapp/urls.py, then add this function to myapp/views.py:

def year(request, year): return HttpResponse(‘Year: {}’.format(year)) 

If you navigate to /myapp/year/2010 on your site, you should see Year: 2010 displayed in response. Note that routes like /myapp/year/rutabaga will yield an error, because the int: constraint on the variable year allows only an integer in that position. Many other formatting options are available for routes.

Earlier versions of Django had a more complex and difficult-to-parse syntax for routes. If you still need to add routes using the old syntax—for instance, for backward compatibility with an old Django project—you can do so by using the django.urls.re_path function.

Django templates

Django’s built-in template language can be used to generate web pages from data.

Templates used by Django apps are stored in a directory that is central to the project: /templates//. For our myapp project, the directory would be myapp/templates/myapp/. This directory structure may seem a little awkward, but Django can look for templates in multiple places, so this avoids name collisions between templates with the same names across multiple apps.

In your myapp/templates/myapp/ directory, create a file named year.html with the following content:

Year: {{year}} 

Any value within double curly braces in a template is treated as a variable. Everything else is treated literally.

Modify myapp/views.py to look like this:

from django.shortcuts import render from django.http import HttpResponse def index(request): return HttpResponse(“Hello, world!”) def year(request, year): data = {’year’:year} return render(request, ‘myapp/year.html’, data) 

The render function, a Django “shortcut” (a combination of multiple built-ins for convenience), takes the existing request object, looks for the template myapp/year.html in the list of available template locations, and passes the dictionary data to it as context for the template.

The amount of processing you can perform on data within Django templates is intentionally quite limited. Django’s philosophy is to enforce separation of presentation and business logic whenever possible. Thus you can loop through an iterable object, and you can perform if/then/else tests, but modifying the data within a template is frowned upon.

For instance, a simple “if” test can be encoded this way:

{% if year > 2000 %} 21st century year: {{year}} {% else %} Pre-21st century year: {{year}} {% endif %} 

The {% and %} markers delimit blocks of code that can be executed in Django’s template language.

If you want to use a more sophisticated template processing language, you can swap in others, such as Jinja2 or Mako. Django includes back-end integration for Jinja2, but any template language that returns a string can be used—for instance, by returning that string in a HttpResponse object as in the case of our ”Hello, world!” route.

Next steps with Django

What we’ve seen here covers only the most basic elements of a Django application. Django includes a great many other components that can be employed in a web project. All of these are worth discussing in detail separately, but I will leave you with a brief overview:

  • Databases and data models. Django’s built-in ORM can be used to define data structures and relationships between them for your app, as well as migration paths between versions of those structures.

  • Formularios . Django proporciona una forma coherente para que las vistas proporcionen formularios de entrada a un usuario, recuperen datos, normalicen los resultados y proporcionen informes de errores coherentes.

  • Seguridad y utilidades . Django incluye muchas funciones integradas para el almacenamiento en caché, el registro, el manejo de sesiones, el manejo de archivos estáticos y la normalización de URL. También incluye herramientas para necesidades de seguridad comunes, como el uso de certificados criptográficos o la protección contra la falsificación de sitios cruzados o el secuestro de clics.