Django en una ojeada

Porque Django se desarrolló en un entorno de noticias con ritmo rápido, fue diseñado para hacer comunes tareas de desarrollo web rápidas y fáciles. Aquí tienes una visión general informal de cómo escribir una aplicación web con base de datos con Django.

El objetivo de este documento es darte suficientes detalles técnicos como entender cómo funciona Django, pero no pretende ser una tutoría o referencia – aunque tenemos ambas! Cuando estés listo para empezar un proyecto, puedes empezar con la tutoría o sumergirte en más documentación detallada.

Diseña tu modelo

A continuación te dejo las traducciones de los textos originales manteniendo todas sus etiquetas intactas.

La sintaxis del modelo de datos ofrece muchas formas ricas de representar tus modelos – hasta ahora ha resuelto muchos problemas de esquema de bases de datos. Aquí tienes un ejemplo rápido:

news/models.py
from django.db import models


class Reporter(models.Model):
    full_name = models.CharField(max_length=70)

    def __str__(self):
        return self.full_name


class Article(models.Model):
    pub_date = models.DateField()
    headline = models.CharField(max_length=200)
    content = models.TextField()
    reporter = models.ForeignKey(Reporter, on_delete=models.CASCADE)

    def __str__(self):
        return self.headline

Instálalo

A continuación, ejecuta las utilidades de línea de comandos de Django para crear automáticamente las tablas de la base de datos:

$ python manage.py makemigrations
$ python manage.py migrate

El comando makemigrations analiza todos tus modelos disponibles y crea migraciones para aquellas tablas que no existen todavía. migrate ejecuta las migraciones y crea tablas en tu base de datos, además de proporcionar opcionalmente un control del esquema mucho más rico: muchos controles del esquema.

Disfruta de la API gratuita

Con eso, tienes una API gratuita y rica para acceder a tus datos. La API se crea en tiempo real, sin necesidad de generación de código:

# Import the models we created from our "news" app
>>> from news.models import Article, Reporter

# No reporters are in the system yet.
>>> Reporter.objects.all()
<QuerySet []>

# Create a new Reporter.
>>> r = Reporter(full_name="John Smith")

# Save the object into the database. You have to call save() explicitly.
>>> r.save()

# Now it has an ID.
>>> r.id
1

# Now the new reporter is in the database.
>>> Reporter.objects.all()
<QuerySet [<Reporter: John Smith>]>

# Fields are represented as attributes on the Python object.
>>> r.full_name
'John Smith'

# Django provides a rich database lookup API.
>>> Reporter.objects.get(id=1)
<Reporter: John Smith>
>>> Reporter.objects.get(full_name__startswith="John")
<Reporter: John Smith>
>>> Reporter.objects.get(full_name__contains="mith")
<Reporter: John Smith>
>>> Reporter.objects.get(id=2)
Traceback (most recent call last):
    ...
DoesNotExist: Reporter matching query does not exist.

# Create an article.
>>> from datetime import date
>>> a = Article(
...     pub_date=date.today(), headline="Django is cool", content="Yeah.", reporter=r
... )
>>> a.save()

# Now the article is in the database.
>>> Article.objects.all()
<QuerySet [<Article: Django is cool>]>

# Article objects get API access to related Reporter objects.
>>> r = a.reporter
>>> r.full_name
'John Smith'

# And vice versa: Reporter objects get API access to Article objects.
>>> r.article_set.all()
<QuerySet [<Article: Django is cool>]>

# The API follows relationships as far as you need, performing efficient
# JOINs for you behind the scenes.
# This finds all articles by a reporter whose name starts with "John".
>>> Article.objects.filter(reporter__full_name__startswith="John")
<QuerySet [<Article: Django is cool>]>

# Change an object by altering its attributes and calling save().
>>> r.full_name = "Billy Goat"
>>> r.save()

# Delete an object with delete().
>>> r.delete()

Una interfaz administrativa dinámica: no es solo un armazón – es toda la casa

Una vez que hayas definido tus modelos, Django puede crear automáticamente una interfaz administrativa profesional y lista para producción – un sitio web que permite a los usuarios autenticados agregar, cambiar y eliminar objetos. El único paso requerido es registrar tu modelo en el sitio de administración:

news/models.py
from django.db import models


class Article(models.Model):
    pub_date = models.DateField()
    headline = models.CharField(max_length=200)
    content = models.TextField()
    reporter = models.ForeignKey(Reporter, on_delete=models.CASCADE)
La traducción de los textos es la siguiente:
from django.contrib import admin

from . import models

admin.site.register(models.Article)

La filosofía aquí es que tu sitio web está editado por un personal, o un cliente, o tal vez solo tú – y no quieres tener que lidiar con crear interfaces de backend sólo para gestionar el contenido.

Un flujo de trabajo típico en la creación de aplicaciones Django es crear modelos y obtener los sitios administrativos funcionando lo más rápido posible, así que tu personal (o clientes) puedan empezar a poblar datos. Luego, desarrolla la forma en que se presenta el dato al público.

Diseña tus URLs

Un esquema de URL limpio y elegante es un detalle importante en una aplicación web de alta calidad. Django fomenta diseños de URL hermosos y no pone ningún «cruft» en las URL, como .php o .asp.

Para diseñar URLs para una app, creas un módulo de Python llamado URLconf. Una tabla de contenido para tu app, contiene una asignación entre patrones de URL y funciones de llamada de Python. Los URLconfs también sirven para desacoplar las URLs del código de Python.

Aquí está lo que un URLconf podría verse como para el ejemplo Reporter/Article anterior:

news/urls.py
from django.urls import path

from . import views

urlpatterns = [
    path("articles/<int:year>/", views.year_archive),
    path("articles/<int:year>/<int:month>/", views.month_archive),
    path("articles/<int:year>/<int:month>/<int:pk>/", views.article_detail),
]

El código anterior mapea rutas de URL a funciones de llamada de Python («vistas»). Las cadenas de ruta utilizan etiquetas de parámetro para «capturar» valores de las URLs. Cuando un usuario solicita una página, Django recorre cada ruta, en orden, y se detiene en la primera que coincida con la URL solicitada. (Si ninguna de ellas coincide, Django llama a una vista especial de error 404.) Esto es increíblemente rápido, porque las rutas se compilan en expresiones regulares en tiempo de carga.

Una vez que uno de los patrones de URL coincida, Django llama a la función de vista correspondiente, que es una función de Python. Cada vista recibe un objeto de solicitud – que contiene metadatos de solicitud – y los valores capturados en el patrón.

Si un usuario solicita la URL «/artículos/2005/05/39323/», Django llamaría a la función noticias.views.detalle_artículo(request, año=2005, mes=5, pk=39323).

Escribe tus vistas

Cada vista es responsable de realizar una de dos cosas: Devolver un objeto HttpResponse que contiene el contenido de la página solicitada, o levantar una excepción como Http404. El resto está a tu cargo.

En general, una vista recupera datos según los parámetros, carga un template y renderiza el template con los datos recuperados. Aquí tienes un ejemplo de vista para year_archive desde arriba:

noticias/views.py
from django.shortcuts import render

from .models import Article


def year_archive(request, year):
    a_list = Article.objects.filter(pub_date__year=year)
    context = {"year": year, "article_list": a_list}
    return render(request, "news/year_archive.html", context)

Este ejemplo utiliza el sistema de plantillas de Django :doc:` </topics/templates>`, que tiene varias características poderosas pero busca mantenerse lo suficientemente simple como para que los no programadores puedan usarlo.

Diseña tus plantillas

El código anterior carga la plantilla noticias/year_archive.html.

Django tiene un camino de búsqueda de plantillas, lo que te permite minimizar la redundancia entre plantillas. En tus configuraciones Django, especificas una lista de directorios para buscar plantillas con DIRS. Si una plantilla no existe en el primer directorio, busca en el segundo y así sucesivamente.

Supongamos que la plantilla noticias/year_archive.html se encontró. Aquí tienes qué podría ser eso:

news/templates/news/year_archive.html
{% extends "base.html" %}

{% block title %}Articles for {{ year }}{% endblock %}

{% block content %}
<h1>Articles for {{ year }}</h1>

{% for article in article_list %}
    <p>{{ article.headline }}</p>
    <p>By {{ article.reporter.full_name }}</p>
    <p>Published {{ article.pub_date|date:"F j, Y" }}</p>
{% endfor %}
{% endblock %}

Las variables están rodeadas por llaves dobles. {{ artículo.título }} significa «Imprime el valor del atributo de título del artículo.» Pero los puntos no se utilizan solo para la búsqueda de atributos. También pueden hacer una búsqueda de clave de diccionario, una búsqueda de índice y llamadas a funciones.

Nota {{ artículo.fecha_pub|date:"F j, Y" }} utiliza un estilo Unix «pipe» (el carácter «|»). Esto se llama un filtro de plantilla y es una forma de filtrar el valor de una variable. En este caso, el filtro de fecha formatea un objeto datetime de Python en el formato dado (como se encuentra en la función date de PHP).

Puedes encadenar tantos filtros como desees. Puedes escribir filtros de plantilla personalizados. Puedes escribir etiquetas de plantilla personalizadas, que ejecutan código Python personalizado detrás del escenario.

Finalmente, Django utiliza el concepto de «herencia de plantillas». Eso es lo que hace {% extends "base.html" %}. Significa «Carga primero la plantilla llamada “base”, que ha definido un conjunto de bloques, y rellena los bloques con los siguientes bloques.» En resumen, eso te permite reducir drásticamente la redundancia en las plantillas: cada plantilla tiene que definir solo lo que es único para esa plantilla.

Aquí está qué podría ser la plantilla «base.html», incluyendo el uso de archivos estáticos.

templates/base.html
{% load static %}
<html lang="en">
<head>
    <title>{% block title %}{% endblock %}</title>
</head>
<body>
    <img src="{% static 'images/sitelogo.png' %}" alt="Logo">
    {% block content %}{% endblock %}
</body>
</html>

Simplificando, define la apariencia del sitio (con el logo del sitio) y proporciona «huecos» para que las plantillas hijas rellenen. Esto significa que un rediseño de sitio se puede hacer cambiando un solo archivo – la plantilla base.

También te permite crear varias versiones de un sitio, con diferentes plantillas base, mientras reutilizas plantillas hijas. Los creadores de Django han utilizado esta técnica para crear versiones móviles impresionantes de sitios cambiando solo una plantilla base.

Ten en cuenta que no tienes que usar el sistema de plantillas de Django si prefieres otro sistema. Si bien el sistema de plantillas de Django está particularmente bien integrado con la capa de modelos de Django, nada te obliga a usarlo. Por lo demás, tampoco tienes que usar la API de base de datos de Django. Puedes utilizar otra capa de abstracción de bases de datos, puedes leer archivos XML, puedes leer archivos en disco o cualquier cosa que desees. Cada pieza de Django – modelos, vistas, plantillas – está decoupled del siguiente.

Esta es solo la superficie

Esto ha sido solo una visión general rápida de la funcionalidad de Django. Algunas características más útiles:

  • Un marco de caché que se integra con memcached o otros backends.

  • Un marco de sindicación que te permite crear feeds RSS y Atom escribiendo una pequeña clase Python.

  • Más características del administrador automáticamente generadas más atractivas – esta visión general apenas ha rozado la superficie.

Los siguientes pasos son para ti descargar Django, leer el tutorial y unirte a la comunidad. Gracias por tu interés!

« previous | up | next »