Cet article présente d'une façon générale le framework web Django, il est déstiné à toutes personnes ayant déjà quelques notion de programmation orienté web et qui désire apprendre les bases de Django. Cet article ne présente qu'une petite partie des possibilité que nous offre ce framework.

- Titre : Introduction à Django

- Auteur : Cédric Salaun

- Parution : 27 juillet 2012

- Licence : Copyright © 2012 Cédric Salaun. CDATA[Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 € de dommages et intérêts. Droits de diffusion permanents accordés à Developpez LLC. Cette page est déposée à la SACD.

Sommaire

- I. Introduction

- I-A. Présentation du framework Django

- II. Installation

- II-A. Sous Windows

- II-B. Sous Ubuntu

- III. Premier pas avec Django

- III-A. Hello world

- III-B. Les templates

- III-C. Template et héritage

- IV. Le modèle de données

- IV.A. Mise en place

- IV.B. Administration

- IV.C. Affichage d'objet

- V. Conclusion

- VI. Remerciement

I - Introduction

La programmation web évolue très vite et il faut de nombreuses compétences pour entrer dans ce club : html, javascript, css et un autre langage au choix ( php, ruby, java, python..) puis une connaissance dans les base de données. Dans ce cadre, les framework web apportent une certaine stabilité et un socle de programmation agréable pour les développeurs web. Ils permettent aux développeurs de se focaliser sur le contenue et le détail du site web, plutôt que la conception pure du site web, en leurs fournissant un base de travail robuste et documenté. Le seul bémol dans le monde des framework c'est leur nombre, il en existe des centaines et ce n'est pas toujours facile de s'y retrouver pour celui qui cherche à débuter avec un nouveau framework. Django est un framework populaire basé sur le langage python et caractérisé par sont approche MTC "model" "template" "contrôleur".

I-A - Présentation du framework Django

Django est présenté officiellement comme la Plateforme de développement Web pour les perfectionnistes sous pression, ce titre résume bien l'objectif et le principe de Django, très simple d'utilisation avec un système de template très bien pensé et intuitif, il est aussi possible de pousser le framework à un niveau très détaillé, en codant ses propres "tag", ou ses propres "middleware". Django ce base sur un aspect plus normatif que descriptif, mais il est tout à fait possible de faire des réglages fin dans le fichier de configuration, encore une fois : de base tout est fait pour que vous puissiez coder rapidement, mais à tout moment vous pouvez prendre les commandes et modifier le moindre détail.

II - Installation

II-A - Sous Windows

Au préalable, il faut installer python 2.7 que vous trouverez ici : http://www.python.org. ( la version à l'heure ou j'écris ces lignes est 2.7.3 )

Vous aurez besoin de modifier votre variable PATH, en y ajoutant : C:\Python27\;C:\Python27\Scripts; (si vous avez installé python dans C:\Python27)

Pour modifier la variable PATH de windowss :

- Clique droits sur "Ordinateur" (sur le bureau ou dans le menu directement)

- Dans le menu cliquez sur "Proprietés"

- Allez dans "paramètre système avancé"

- Cliquez sur le bouton "varaible d'environnement"

- Dans la liste variable système, cliquez sur la variable "path"

- Cliquez sur modifier

- Ajouter le chemin que vous voulez à la suite de la liste

- Fermer toutes les fenètre avec le bouton "ok"

Pour vérifier que python est bien installé, taper la commande suivante :

python --version

Une fois que python est bien installé allez sur la page de téléchargement de Django puis télécharger Django ( à l'heure ou j'écris, le fichier se nomme Django-1.4.1.tar.gz ). Pour décompresser ce fichier je vous conseil d'utiliser 7zip, En effet le format tar.gz est propre à unix, 7zip est tout à fait capable de décompresser correctement ce genre d'archive. La premier décompression vous donnera un fichier .tar, refaite une décompression de ce fichier pour avoir le dossier décompressé de Django.

Si vous vous retrouvez comme moi avec un chemin long vers le dossier de Django (Django-1.4.1.tar\dist\Django-1.4.1\Django-1.4.1) n'hésiter pas à copier le dernier dossier et à le placer dans C:\ directement. Normaement vous devriez vous retrouver avec C:\Django-1.4.1\django.

Lancer la commande suivante :

python setup.py install

Il ne reste plus qu'a modifier la variable PATH, comme vous l'avez fait pour python en ajoutant : C:\Django-1.4.1\django\bin.

Pour vérifier que Django est opérationel, taper la commande :

django-admin.py --version
1.4.1

Il faut relancer la console à chaque fois que vous modifier la variable PATH

II-B - Sous Ubuntu

Sur ubuntu l'installation se fait en une ligne :

sudo apt-get install python-django

III - Premier pas avec Django

III-A - Hello world

Nous allons commencer par écrire un premier projet qui affichera "Hello world" pour nous assurer que Django est prêt. Commencer par ouvrir une invite de commande, puis taper la commande suivante :

django-admin.py startproject mysite

placer vous dans le répertoire nouvellement crée : mysite.
Vous devriez retrouver les éléments suivant :

manage.py
settings.py
urls.py
__init__.py

- Le dossier /mysite contient tout les éléments de votre projet.

- manage.py est l'utilitaire vous permetra d'interagire avec Django.

- settings.py est le fichier de configuration de votre projet.

- urls.py est la table des url de votre projet.

A ce stade, nous avons créé un projet Django, maintenant nous allons créer une application. Il est possible de décomposer sont site web en plusieurs applications, ceci permet de faire des choses réutilisables par la suite dans d'autre projet.
Taper la commande suivante :

python manage.py startapp myapp

Django va créer pour nous le squelette de l'application dans le répertoire /myapp.

models.py
tests.py
views.py
__init__.py

Le fichier models.py contiendra le modèle de donnée de notra application, le fichier views.py est un fichier particulier qui servira à écrire notre code métier.
Nous allons maintenant démarrer le serveur d'application fournis avec Django, taper la commande :

manage.py runserver

Validating models...

0 errors found
Django version 1.3.1, using settings 'mysite.settings'
Development server is running at http://127.0.0.1:8000/
Quit the server with CTRL-BREAK.

Vous pouvez ouvrir un navigateur et aller à l'url indiqué : http://127.0.0.1:8000/

Premier lancement de Django

Maintenant que tout est en place, nous allons faire notre première page.
Commencer par editer le fichier mysite/urls.py :

urls.py

urlpatterns = patterns('',
url(r'^$', 'mysite.myapp.views.home', name='home'),

)

Ici nous voulons que l'index du site [http://127.0.0.1:8000/] appèle l'action home du fichier view.py
Editier ensuite le fichier mysite/myapp/views.py pour ajouter cette action :

views.py

from django.http import HttpResponse

def home(request):
return HttpResponse("Hello, world.")

Maintenant, relancer la page web :

Si vous avez cette page, vous pouvez passer à la section suivante.

III-B - Les templates

Nous allons maintenant voir comment Django intégre une page HTML.
Pour cela nous allons modifier le fichier settings.py pour lui donner le repertoire ou serons placé les fichier HTML, ce que Django nomme les templates. Commencer par ajouter le répertoire templates dans mysite/ puis modifier le fichier settings.py :

settings.py

TEMPLATE_DIRS = (
"C:/mysite/templates"
)

Le chemin vers le dossier templates doit être absolut.

Dans le nouveau repertoire templates, créer votre premier template : home.html

home.html

1.
2.                 <html>
3.                 <head></head>
4.                 <body>
5.                 Hello Template !
6.                 </body>
7.
8.                 </html>
9.

Ensuite, il faut indiquer dans notre fichier view.py, que nous allons passer par un template :

1.
2.                 from django.shortcuts import render_to_response
3.
4.                 def home(request):
5.                    return render_to_response('home.html')
6.

Notez le changement ici on utilise render_to_response, et non plus HttpResponse, puisque nous passons maintenant par un template (home.html) alors qu'avec HttpResponse, c'est directement du HTTP qui était renvoyé.
render_to_response nous permet d'injecter un certain nombre d'objet dans une page HTML pour être ensuite rendue au client dans ça forme définitive.

Relancer votre serveur puis recharger la page web :

III-C - Template et héritage

Maintenant que vous savez utiliser un template, regardons ce que Django nous propose pour nous facilité la vie. Il y a bien longtemps, dans une galaxie lointaine, très lointaine.. Nous utilisions les frames et frameset pour ne pas avoir de redondance de code entre les pages web, puisque souvent le menu, le header et le footer sont les mêmes sur toutes les paes. Django nous propose un système d'héritage au niveau des pages web, voyons ça de plus près ensemble.

Commencer par créer une page web dans le dossier de template, que nous allons appeler base.html :

base.html

1.
2.                 <html>
3.                 <head>
4.                     <title>mon site web</title>
5.                 </head>
6.                 <body>
7.                     <h1>Mon premier site web</h1>
8.                     {0lock content %} { 0.000000e+000ndblock %}
9.                 </body>
10.                 </html>
11.

Ici nous voyons pour la première fois le langage de template propre à Django.
{% block content %}{% endblock %} est une déclaration de block, qui nous permetra de venir inserer à cette endrois du contenu.

Il faut maintenant modifier notre page home.html pour se servire de ce fichier :

home.html

1.
2.                 { 0.000000e+000xtends "base.html" %}
3.
4.                 {0lock content %}
5.
6.                 Première page du site
7.
8.                 { 0.000000e+000ndblock %}
9.

Pour dire à Django que cette page va hériter de la page base.html, nous lui indiquons : {% extends "base.html" %}

Ensuite, il suffit de reprendre le ou les blocks déclaré dans la page mère, ici {% block content %}. Quand Django va rendre cette page, il va aller chercher base.html, puis y inclure les differents block. L'exmple n'est pas très parlant mais il faut imaginer que le fichier base.html est le squelette complet de notre site, cela permet de ne pas dupliquer le code, et aussi d'avoir un seule endrois à modifier pour changer l'aspect générale du site web.

Le résultat de notre page web :

IV - Le modèle de données

IV.A - Mise en place

Nous allons voir une des forces de Django : l'abstraction de la base de données. Django utilise un fichier -modele.py- qui défini clairement les objetcs du projet. Tout comme le Python, Django est très orienté objet. Ici nous ne vérons pas de requêtes sql, de connexion à la base de données, ou de commit; Cela pourrait paraitre comme une limitation mais Django à été pensé et construit pour cela, vous avez donc une multitude d'outils pour aller aussi loin que vous le voulez.

Pour illustrer cela, nous allons créer une liste de note puis l'afficher.
Je concidère que vous avez une base de donnée MySQL installée sur votre machine.

Premièrement, il faut définir la base de données dans le fichier settings.py :

settings.py

1.
2.                 DATABASES = {
3.                    'default': {
4.                        'ENGINE':     'mysql',
5.                        'NAME':     'django_db',
6.                        'USER':     'root',
7.                        'PASSWORD': 'root',
8.                        'HOST': '',
9.                        'PORT': '',
10.                    }
11.                 }
12.

Donc ici j'ai créer un schema qui se nomme django_db sur ma base de donnée MySQL.
Ces données sont utilisé pour que Django dialogue avec votre base de données, commme vous pouvez le voir, votre projet pourra aussi bien tournée sur MySQL que sqlite3 ou encore oracle sans changer une sule ligne de code !

Maintenant que le paramétrage est fait, ouvrer le fichier models.py et copier le code suivant :

models.py

1.
2.             from django.db import models
3.
4.             class Note(models.Model):
5.                 libelle = models.CharField(max_length=200)
6.                 status =  models.IntegerField()
7.
8.                 def __unicode__(self):
9.                     return self.libelle
10.

Il faut déclarer notre application dans le fichier de configuration :

settings.py

1.
2.             INSTALLED_APPS = (
3.                'django.contrib.auth',
4.                'django.contrib.contenttypes',
5.                'django.contrib.sessions',
6.                'django.contrib.sites',
7.                'django.contrib.messages',
8.                'django.contrib.staticfiles',
9.                 'myapp',
10.                # Uncomment the next line to enable the admin:
11.                # 'django.contrib.admin',
12.                # Uncomment the next line to enable admin documentation:
13.                # 'django.contrib.admindocs',
14.             )
15.
16.

Je déclare donc une nouvelle class Note avec deux attribts : libelle qui sera le texte de la note et le status pour savoir si c'est fait ou pas. la fonction __unicode__ nous servira pour plus tard, c'est le texte qui sera renvoyé pour l'objet.

Nous arrivons à une phase typique de Django : le liens avec la base de données à été défini ainsi que notre modèle, Django est donc capable de créer la base de données, taper la commande suivante :

Penser à installer le support de mysql pour python. (http://www.codegood.com/archives/129)

commande

manage.py syncdb

d:\DEV\mysite>manage.py syncdb
Creating tables ...
Creating table auth_permission
Creating table auth_group_permissions
Creating table auth_group
Creating table auth_user_user_permissions
Creating table auth_user_groups
Creating table auth_user
Creating table auth_message
Creating table django_content_type
Creating table django_session
Creating table django_site
Creating table myapp_note

You just installed Django's auth system, which means you don't have any superuse
rs defined.
Would you like to create one now? (yes/no): yes
Username (Leave blank to use 'administrateur'): root
E-mail address: cedric.salaun@gmail.com
Password:
Password (again):
Superuser created successfully.
Installing custom SQL ...
Installing indexes ...
No fixtures found.

Commme vous pouvez le constater, Django met en place plusieurs tables que nous n'avons pas défini, ce sont des tables "système" qui sont là pour nous facilité la vie, par exemple pour la gestion des utilisateurs, la gestions des droits etc... La seule ligne qui nous interesse vraiment ici c'est Creating table myapp_note Pour la création de notre table Note.

IV.B - Administration

Django est livré avec un site d'administration des données, un peux comme phpMyAdmin. Il permet d'ajouter/créer et supprimer des objets en base de données. Cela est très utile quand vous débuter avec votre site web, et que tout n'est pas encore terminé. Voyons comment il fonctionne.

Pour commencer, il faut déclarer l'objet Note dans l'administration, sinon il n'apparaitra pas. Pour cela, créer un nouveau fichier admin.py dans le répertoire /mysite/myapp

admin.py

1.
2.             from myapp.models import Note
3.             from django.contrib import admin
4.
5.             admin.site.register(Note)
6.

Ensuite, il faut paramétrer différent fichier pour que l'administration soit en place :
Dans settings.py, décommenter les lignes relatives à l'administration :

settings.py

1.
2.             INSTALLED_APPS = (
3.                'django.contrib.auth',
4.                'django.contrib.contenttypes',
5.                'django.contrib.sessions',
6.                'django.contrib.sites',
7.                'django.contrib.messages',
8.                'django.contrib.staticfiles',
9.                 'myapp',
10.                # Uncomment the next line to enable the admin:
11.                 'django.contrib.admin',
12.                # Uncomment the next line to enable admin documentation:
13.                 'django.contrib.admindocs',
14.             )
15.

Ainsi que dans le fichier des urls :

urls.py

1.
2.             from django.conf.urls.defaults import patterns, include, url
3.             from django.contrib import admin
4.
5.             admin.autodiscover()
6.
7.             urlpatterns = patterns('',
8.                 url(r'^$', 'mysite.myapp.views.home', name='home'),
9.                 url(r'^admin/', include(admin.site.urls)),
10.             )
11.

Resynchronisez la base de données avec syncdb.

commande

1.
2.             manage.py syncdb
3.             Creating tables ...
4.             Creating table django_admin_log
5.             Installing custom SQL ...
6.             Installing indexes ...
7.             No fixtures found.
8.

Redémarer votre serveur, puis rendez-vous à la page http://127.0.0.1:8000/admin/.
Connecter vous avec le compte que vous avez crée précédement en ligne de commande. (avec syncdb) Si tout ce passe bien vous arriverez à cette page :

Nous pouvons directement créer des Notes ici :
Cliquez sur Notes, puis Add Note.

Créer deux notes.

IV.C - Affichage d'objet

Maintenant, nous avons deux notes en base de données, voyons comment les afficher sur notre page web.
Pour ce faire, nous allons utiliser une boulce for dans le template.

Avant tout, il faut séléctionner les notes dans la contrôleur et les envoyer au template :

views.py

1.
2.             from django.shortcuts import render_to_response
3.             from myapp.models import Note
4.
5.             def home(request):
6.                notes = Note.objects.all()
7.                return render_to_response('home.html', {'notes': notes})
8.

Les deux éléments importants ici :
notes = Note.objects.all() , Je récupère tout les enregistrements Note (équivalent à select * from myapp_note)
{'notes': notes} , la variable notes est transmit sous le nom 'notes' à mon template.

Comme vous le voyez, nous n'utilisons pas de SQL pour récuperer les enregistrements en base de données. Ici tout est objet.
Voyons maintenant comment afficher les notes dans mon fichier html :

home.html

1.
2.             { 0.000000e+000xtends "base.html" %}
3.
4.             {0lock content %}
5.
6.             <h2>Todo :</h2> <br>
7.             <ul>
8.             { 0.000000or n in notes %}
9.                 <li>{{ n.libelle }}</li>
10.             { 0.000000e+000ndfor %}
11.             </ul>
12.             { 0.000000e+000ndblock %}
13.

Django nous permet d'iterer sur l'objet notes avec une boucle {% for n in notes %}. l'affichage de l'attribut se fait avec {{ objet.attribut }}

V - Conclusion

Ce bref aperçu des possibilités offertes par Django vous aura j'espère permis de comprendre sa philosophie, car plus qu'un simple framework, c'est aussi une façon de penser diférente et plus abstraite que l'on peut trouver sur du php par exemple. Django conviendra parfaitement au développeur python ou ruby, car c'est la même philosophie que l'on y trouve.

- Documentation officiel

- Communauté francophone des utilisateurs du framework Django

VI - Remerciement

Relécture technique : LittleWhite, Torgar.

Introduction à Django

Auteur

Cédric Salaun