Django de un vistazo

Debido a que Django fue desarrollado en un ambiente de sala de redacción de ritmo rápido, fue diseñado para hacer tareas comunes de desarrollo web de forma rápida y fácil. Aquí se incluye una introducción informal de cómo escribir una aplicación web que utiliza una base de datos con Django.

El objetivo de este documento es darle suficiente información técnica para entender cómo funciona Django, pero no pretende ser un tutorial o referencia - ¡Aunque tenemos ambas cosas! Cuando esté listo para empezar un proyecto con Django, puede: doc: comenzar con el tutorial </intro/tutorial01> ` o: doc: ir directamente a la documentación más detallada </topics/index> `.

Diseñe su modelo

Aunque es posible usar Django sin una base de datos, Django cuenta con un mapeador objeto-relacional en el que es posible definir la estructura de la base de datos utilizando código Python.

La: doc: `sintaxis de modelo de datos </topics/db/models> ` ofrece muchas formas de representar sus modelos - hasta ahora, ha resuelto una cantidad equivalente a años de problemas de esquemas de base de datos. Aquí hay un ejemplo rápido:

mysite/news/models.py
from django.db import models

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

    def __str__(self):              # __unicode__ on Python 2
        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):              # __unicode__ on Python 2
        return self.headline

Instálelo

A continuación ejecute la utilidad de la línea de comandos de Django para crear las tablas de base de datos de forma automática:

$ python manage.py migrate

El: djadmin: comando migrate analiza todos sus modelos disponibles y crea cualquier tabla faltante en su base de datos, así como ofrece opcionalmente :doc: un control de esquema mucho más rico </topics/migrations>`.

Disfrute de la API sin restricciones

Con esto, usted tiene una: doc: API Python </topics/db/queries> rica y sin restricciones para acceder a sus datos. La API se crea sobre la marcha y no es necesario generar ningún código:

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

# 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 sólo andamios; es toda una casa

Una vez definidos sus modelos, Django puede crear automáticamente una :doc: interfaz administrativa </ref/contrib/admin/index> profesional y lista para la producción; un sitio Web que le permita a los usuarios autenticados añadir, modificar y eliminar objetos. Es tan fácil como registrar su modelo en el sitio administrativo.

mysite/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)
mysite/news/admin.py
from django.contrib import admin

from . import models

admin.site.register(models.Article)

La filosofía aquí es que su sitio es editado por un equipo, un cliente o tal vez sólo por usted y usted no quiere tener que lidiar con la creación de interfaces de backends, sólo quiere administrar el contenido.

Un flujo de trabajo típico en la creación de aplicaciones Django es crear modelos y poner a funcionar los sitios administrativos lo más rápido posible para que su personal (o clientes) puedan empezar a ingresar los datos y luego, perfeccionar la forma como los datos se presentan al público.

Diseñe sus URLs

Un esquema de URL limpio y elegante es un detalle importante en una aplicación web de alta calidad. Django fomenta un diseño de URL hermoso y no añade ningún elemento innecesario en las URLs, como .php `` o `` .asp``.

Para diseñar las URLs de una aplicación, usted debe crear un módulo de Python llamado: doc: `URLconf </topics/http/urls> `. Esta es una tabla de contenidos para su aplicación que contiene un mapeo sencillo entre patrones URLs y funciones callback de Python. Las tablas URLconf también sirven para separar las URLs del código Python.

Así es como se vería una URLconf para el ejemplo Reporter/Article anterior:

mysite/news/urls.py
from django.conf.urls import url

from . import views

urlpatterns = [
    url(r'^articles/([0-9]{4})/$', views.year_archive),
    url(r'^articles/([0-9]{4})/([0-9]{2})/$', views.month_archive),
    url(r'^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail),
]

The code above maps URLs, as simple regular expressions, to the location of Python callback functions (“views”). The regular expressions use parenthesis to “capture” values from the URLs. When a user requests a page, Django runs through each pattern, in order, and stops at the first one that matches the requested URL. (If none of them matches, Django calls a special-case 404 view.) This is blazingly fast, because the regular expressions are compiled at load time.

Una vez que una de las expresiones regulares coincide, Django importa y llama la vista determinada, que es una función simple de Python. Cada vista recibe un objeto de consulta, que contiene metadatos de consulta y los valores capturados en la expresión regular.

Por ejemplo, si un usuario solicitara la URL “/articles/2005/05/39323/”, Django llamaría la función news.views.article_detail(request, '2005', '05', '39323').

Escriba sus vistas

Cada vista es responsable de hacer una de dos cosas: retornar un objeto: clase:~django.http.HttpResponse que incluye el contenido de la página solicitada, o levantar una excepción como: clase:` ~ django.http.Http404` . El resto depende de ti.

Generalmente, una vista recupera los datos de acuerdo con los parámetros, carga una plantilla y crea la plantilla con los datos recuperados. Aquí está una vista de ejemplo para el `` year_archive`` de arriba:

mysite/news/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:doc:el sistema de plantillas de Django </topics/templates> que tiene varias características potentes, pero se esfuerza por mantenerse lo suficientemente simple como para que los que no son programadores lo puedan utilizar.

Diseñe sus plantillas

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

Django tiene una ruta de búsqueda de plantillas lo que le permite a usted minimizar la redundancia entre las plantillas. En su configuración de Django, usted especifica una lista de directorios para verificar si hay plantillas con: configuración: DIRS <TEMPLATES-DIRS>. Si una plantilla no existe en el primer directorio, verifica en el segundo y así sucesivamente.

Digamos que se encontró la plantilla news / year_archive.html`. Así es como podría verse:

mysite/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. `` {{Article.headline}} ‘’ significa “ Enviar el valor del atributo headline del artículo”. Sin embargo, los puntos no sólo se utilizan para las operaciones de búsqueda de atributo. También pueden hacer búsqueda de pares diccionnario-clave, búsqueda de índice y llamadas a funciones.

Tenga en cuenta que {{ article.pub_date|date:"F j, Y" }} utiliza una “tubería” al estilo Unix (el carácter “|”). Esto se conoce como filtro de plantilla, y es una manera de filtrar el valor de una variable. En este caso, el filtro de fecha formatea un objeto datetime de Python en el formato determinado (como se encuentra en la función de fecha de PHP).

Usted puede encadenar tantos filtros como desee. Usted puede escribir: ref: ` filtros de plantillas personalizados <howto-writing-custom-template-filters>`. Usted puede escribir: doc: etiquetas de plantillas personalizadas </howto/custom-template-tags>` que ejecutan el código Python personalizado tras bastidores.

Por último, Django usa el concepto de “herencia de plantillas”. Eso es lo que hace el `` {% extends “base.html”%} ``. Esto quiere decir “Primero cargue la plantilla llamada” base ”, que ha definido un grupo de bloques, y llene los bloques con los siguientes bloques.” En resumen, eso le permite reducir drásticamente la redundancia en las plantillas: cada plantilla tiene que definir sólo lo que es exclusivo de esa plantilla.

Así es como podría verse la plantilla “base.html”, incluyendo el uso de: doc: los archivos estáticos </howto/static-files/index>`:

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

De forma simplista, define el aspecto del sitio (con el logo del sitio) y proporciona “agujeros” a ser llenados por las plantillas hijas. Esto hace un rediseño del sitio tan fácil como cambiar un solo archivo: la plantilla base.

También le permite crear múltiples versiones de un sitio, con diferentes plantillas bases, a la vez que reutiliza las plantillas hijas. Los creadores de Django han usado esta técnica para crear versiones móviles de sitios sorprendentemente distintas, simplemente creando una nueva plantilla base.

Tenga en cuenta que usted no tiene que usar el sistema de plantillas de Django si prefiere otro sistema. Si bien el sistema de plantillas de Django está particularmente bien integrado con la capa modelo de Django, nada lo obliga a usarlo. No tiene tampoco que usar la API de base de datos de Django. Puede usar otra capa de abstracción de base de datos, leer archivos XML, leer archivos desde el disco o lo que desee. Cada parte de Django ,modelos, vistas, plantillas, está separada de la otra.

Esto es sólo la superficie

Esta ha sido solamente una rápida introducción a la funcionalidad de Django. Otras características útiles:

  • Un doc: framework de caché </topics/cache> que se integra con memcached u otros backends.

  • Un :doc: framework de sindicación </ref/contrib/syndication> que hace que la creación de feeds RSS y Atom sea tan fácil como escribir una pequeña clase de Python.

  • Funciones del sitio administrativo más atractivas generadas automáticamente : esta descripción general apenas arañó la superficie.

Los próximos pasos son obvios para usted descargar Django, leer: doc: ` el tutorial </intro/tutorial01>` y unirse a la comunidad. ¡Gracias por su interés!

Back to Top