Concevez votre modèle¶

Bien que vous puissiez utiliser Django sans base de données, il est livré avec un mapper de relations d’objets avec lequel vous décrivez la structure de votre base avec du code Python.

La syntaxe de modèles de données (en) offre un moyen élégant de représenter vos modèles – jusqu’ici, cela a résolu deux ans de problèmes de schéma de base de données. Voici un exemple rapide:

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

    def __unicode__(self):
        return self.full_name


class Article(models.Model):
    pub_date = models.DateTimeField()
    titre = models.CharField(max_length=200)
    content = models.TextField()
    reporter = models.ForeignKey(Reporter)

    def __unicode__(self):
        return self.titre

Déployez-le¶

Ensuite, lancez l'utilitaire en ligne de commande pour créer les tables de données automatiquement :

manage.py syncdb

La commande syncdb regarde tous vos modèles disponibles et crée les tables correspondantes dans votre base de données pour toutes celles qui n'existent pas déjà.

Aimez l'API libre¶

Avec cela, vous avez une API Python (en) riche et libre pour accéder à vos données. L'API est générée à la volée, sans avoir besoin d'écrire du code :

>>> from mysite.models import Reporter, Article

# Aucun reporters n'est dans le systeme actuellement.
>>> Reporter.objects.all()
[]

# Creons un nouveau reporter.
>>> r = Reporter(full_name='John Smith')

# Enregistrez l'objet dans la base de donnees. Vous devez appeler save()
# explicitement.
>>> r.save()

# Maintenant il a un ID
>>> r.id
1

# Le reporter est dans la base de donnees.
>>> Reporter.objects.all()
[<Reporter: John Smith>]

# Les champs sont representes par des attributs d'un objet Python.
>>> r.full_name
'John Smith'

# Django fournit une API de recherche de donnees puissante
>>> 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.

# Créons un article
>>> from datetime import datetime
>>> a = Article(pub_date=datetime.now(), titre='Django est cool',
...     content='Yeah.', reporter=r)
>>> a.save()

# L'article est maintenant dans la base.
>>> Article.objects.all()
[<Article: Django est cool>]

# Les objets Article ont une API pour acceder aux objets Reporter associés.
>>> r = a.reporter
>>> r.full_name
'John Smith'

# Et vice versa : Les objets Reporter ont une API pour acceder aux objets
# Article.
>>> r.article_set.all()
[<Article: Django est cool>]

# L'API suit les relations aussi loin que vous en avez besoin, exécutant des
# JOINs en arrière plan. # Ceci trouve tous les articles d'un reporter dont
# le nom commence par "John".
>>> Article.objects.filter(reporter__full_name__startswith="John")
[<Article: Django est cool>]

# Modifier un objet en modifiant ses attributs et en appelant save().
>>> r.full_name = 'Billy Goat'
>>> r.save()

# Supprimer un objet avec delete().
>>> r.delete()

Une interface d'administration dynamique : ce n'est pas juste un échafaudage -- c'est une vraie maison.¶

Une fois que nos modèles sont définis, Djando peut créer automatiquement une interface d'administration (en) professionnelle et apte à la production -- un site Web qui permet aux utilisateurs authentifiés d'ajouter, modifier et supprimer des objets. C'est aussi simple que d'enregistrer votre modèle dans l'administration:

# Dans models.py...

from django.db import models

class Article(models.Model):
    pub_date = models.DateTimeField()
    titre = models.CharField(max_length=200)
    content = models.TextField()
    reporter = models.ForeignKey(Reporter)

# Dans admin.py, dans le même repertoire...

import models from django.contrib import admin

admin.site.register(models.Article)

Ici la philosophie est que votre site peut être modifié par un membre du personnel, ou un client, ou peut-être juste par vous -- et vous ne voulez pas créer l'interface d'administration juste pour gérer votre contenu.

Le rythme de travail pour créer une application Django est de créer les modèles et mettre en place l'administration aussi vite que possible, pour que votre personnel (ou clients) puisse commencer à entrer les données. Ensuite, développer la manière dont les données sont présentées au public.

Concevez vos URL¶

Un schéma d'URL propre et élégant est un détail important dans une application Web de qualité. Django encourage la conception de belles URL et ne place aucune extension dans celles-ci comme .php ou .asp.

Pour concevoir les URL d'une application, vous créez un module Python appelé URLconf (en). C'est un sommaire pour votre application, il contient les liaisons entre vos modèles d'URL et les fonctions Python associées. URLconfs sert aussi à séparer les URL de votre code Python.

Voici à quoi URLconf peut ressembler pour l'exemple de Reporter/Article précédent:

from django.conf.urls.defaults import *

   urlpatterns = patterns('',
       (r'^articles/(\d{4})/$', 'mysite.views.year_archive'),
       (r'^articles/(\d{4})/(\d{2})/$', 'mysite.views.month_archive'),
       (r'^articles/(\d{4})/(\d{2})/(\d+)/$', 'mysite.views.article_detail'),
   )

Le code ci-dessus relit, avec de simples expressions régulières, les URL au fonctions réceptrices ("views"). L'expression régulière utilise les parenthèses pour "capturer" les valeurs depuis les URL. Quand un utilisateur demande une page, Django passe par tous les motifs, dans l'ordre, et s'arrête dès qu'un correspond à l'URL demandée. Si aucun d'eux ne correspond, Django appelle un vue 404 spéciale. Ceci est extrêmement rapide car les expressions régulières sont compilées au chargement.

Une fois qu'une des expressions régulières correspond, Django importe et appelle la vue associée, qui est une simple fonction Python. Chaque vue reçoit un objet requête (request, ndt) -- qui contient les méta-données de la requête -- ainsi que les valeurs capturées dans l'expression régulière.

Par exemple, si un utilisateur demande l'URL "/articles/2005/05/39323/", Django appellera la fonction mysite.views.article_detail(request, '2005', '05', '39323').

Ecrivez vos vues¶

Chaque vue est responsable de faire une des deux choses suivantes : Retourner un objet HttpResponse contenant le contenu de la page demandée, ou lever un exception comme par exemple Http404. Le reste est pour vous.

Généralement, une vue récupère des données d'après les paramètres, charge un template et affiche le template avec les données récupérées. Voici un exemple de vue pour le précédent year_archive:

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

Cet exemple utilise le système de templates (en) de Django qui a plusieurs fonctions puissantes mais s'efforce de rester assez simple à l'utilisation pour les non-programmeurs.

Elaborez vos templates¶

Le code ci-dessus charge le template news/year_archive.html.

Django a un chemin de recherche des templates, ce qui vous permet de minimiser la redondance parmi les templates. Dans vos paramètres de Django, vous spécifiez une liste des dossiers à vérifier pour les templates. Si un template n'existe pas dans le premier dossier, Django vérifie le second, etc.

Disons que le template news/article_detail.html a été trouvé. Voilà à quoi il peut ressembler :

{% extends "base.html" %}
{% block title %}Articles pour l'année {{ year }}{% endblock %}

{% block content %}
    <h1>Articles pour l'année {{ year }}</h1>
    {% for article in article_list %}
        <p>{{ article.headline }}</p> <p>Par {{ article.reporter.full_name }}</p>
        <p>Publié le {{ article.pub_date|date:"F j, Y" }}</p>
    {% endfor %}
{% endblock %}

Les variables sont entourées de deux accolades. {{ article.headline }} veut dire "Afficher la valeur de l'attribut titre de l'article.", mais les points ne sont pas utilisés uniquement pour l'utilisation des attributs : ils peuvent aussi être utilisés pour la recherche des clés de dictionnaires, d'index, ou pour appeler des fonctions.

Notez que {{ article.pub_date|date:"F j, Y" }} utilise des "tuyaux" de type Unix (le caractère "|"). Ceci est appelé un filtre pour templates, et c'est un moyen de filtrer la valeur d'une variable. Dans le cas présent, le filtre date formate un objet datetime Python dans le format donné (comme dans la fonction PHP date; oui, c'est une bonne idée dans PHP).

Vous pouvez enchaîner autant de filtres que vous le voulez. Vous pouvez écrire vos propres filtres. Vous pouvez écrire des tags pour templates personnels qui utilisent du code Python en arrière-plan.

Enfin, Django utilise le concept d'"héritage de templates" : c'est ce que fait {% extends "base.html" %}. Cela veut dire "Premièrement charge le template nommé 'base', qui a déjà défini un lot de blocks, et remplit-les avec les blocks suivantes.". Pour résumer, cela vous permet de diminuer significativement la redondance dans les templates : chaque template n'a à définir que ce qui est unique à ce template.

Voilà à quoi le template "base.html" peut ressembler :

<html>
    <head>
        <title>{% block title %}{% endblock %}</title>
    </head>
    <body>
        <img src="sitelogo.gif" alt="Logo" />
        {% block content %}{% endblock %}
    </body>
</html>

De façon simplifiée, cela définit l'agencement de votre site (avec le logo), et fournit des "trous" que les templates enfant peuvent remplir. Cela rend le changement de style d'un site aussi simple que de changer un seul fichier -- le template de base.

Cela vous permet aussi de créer plusieurs versions d'un site, avec des templates de base différents, en réutilisant les templates enfants. Les créateurs de Django ont utilisé cette technique pour créer des versions du site pour téléphones portables remarquablement différentes -- en créant simplement un nouveau template de base.

Notez que vous n'avez pas à utiliser le système de templates de Django si vous en préferez un autre. Bien que le système de templates de Django soit particulièrement bien intégré avec la couche modèle de Django, rien ne vous force à l'utiliser. Vous n'avez pas non plus à utiliser l'API de base de données de Django. Vous pouvez utiliser une autre couche d'abstraction de base de données vous pouvez lire des fichiers XML, vous pouvez lire des fichiers depuis un disque, ou ce que vous voulez. Chaque partie de Django -- models, views, templates -- est séparée des autres.

Ceci n'est que la base¶

Ceci n'est qu'un rapide coup d'oeil sur les fonctions de Django. En voici quelques autres utiles :

• Un framework de cache (en) qui s'intègre avec memcached ou d'autres terminaux.
• Un framework de syndication (en) qui rend la génération de flux RSS et Atom aussi simple que d'écrire des petites classes Python.
• D'autres sympatiques fonctionalités automatiquement générées pour l'interface d'administration -- ce coup d'oeil a à peine écorché la surface.

Pour vous, les étapes suivantes sont évidement de télécharger Django, lire le didacticiel et rejoindre la communauté. Merci de votre attention !