(La première partie de cet article est ici)
Cette 2ème partie liste les aspects intéressants de Django et vous propose une bibliographie complète avec des exemples concrets d’implémentation.
Mapping relationnel-objet (ORM pour les intimes)
Avec Django, il suffit de définir des modèles qui mappent les objets Django avec les objets en base de données (« Object-relational mapping »). Ceci s'effectue à l’aide d’une syntaxe propre à Django.
Toutes les requêtes SQL du cycle de vie de ces objets sont ensuite générées automatiquement par Django.
from django.db import models
class Person(models.Model):
first_name = models.CharField(max_length=30)
last_name = models.CharField(max_length=30)
Au lancement de la commande Django « syncdb », les ordres SQL suivants seront exécutés côté base de données :
CREATE TABLE person (
"id" serial NOT NULL PRIMARY KEY,
"first_name" varchar(30) NOT NULL,
"last_name" varchar(30) NOT NULL
);
Il est également possible d’ajouter des clefs étrangères, des relations de type ManyToMany, des listes de valeurs, etc…
job = models.ForeignKey(Job, blank=True, null=True) # metier
skills = models.ManyToManyField(Skill, blank=True, null=True) # competences
Ces modèles peuvent également servir de base aux formulaires WEB (formulaire de création de compte par exemple) : ils permettent en effet d’utiliser des champs appropriés au type de données dans les formulaires.
from django.forms import ModelForm
from models import Person
class PersonForm(ModelForm):
class Meta:
model = Person
Aucun besoin d’écrire des requêtes SQL pour filtrer ces objets, il suffit d’utiliser le langage de requête propriétaire de Django (à la manière d’Hibernate qui possède sa propre syntaxe HQL).
Par exemple, pour récupérer la liste des personnes se prénommant « Jean » :
person_list = Person.objects.filter(first_name="jean")
for person in person_list:
...
Une des forces de Django est donc de partir du modèle de conception et de générer tous les éléments du projet : c'est-à-dire le code SQL, l’interface d'administration des objets, les formulaires pour ces modèles, etc… pour que tout soit centralisé dans le code, rendant l’ensemble cohérent et plus simple à maintenir. Ainsi, toute modification sur le modèle entraîne automatiquement des modifications sur la base de données, les formulaires WEB, l’interface d’administration, etc…
Pour aller plus loin : https://docs.djangoproject.com/en/dev/topics/db/models/
Module d’administration
Comme indiqué précédemment, Django génère également pour vous tout un module d’administration des différents éléments définis dans les modèles, qui vous permet, une fois connecté, d’ajouter, d'éditer, de supprimer, de lister, de rechercher des données issues de vos modèles.
Exemple de page d’administration générée à partir du modèle précédent :
admin.py :
from django.contrib import admin
from models import Person
class PersonAdmin(admin.ModelAdmin):
search_fields = ['firstname', 'lastname']
filter_horizontal = ("skills",)
admin.site.register(Person, PersonAdmin)
IHM générée par Django (http://localhost/admin/) :
De nombreuses options de configuration sont disponibles pour personnaliser l’affichage, exclure certains champs, changer les widgets, modifier les CSS, etc…
Pour aller plus loin : https://docs.djangoproject.com/en/dev/ref/contrib/admin/
Gestion des URL
Django permet de gérer facilement le point d’entrée d'une application WEB que sont les URL. En effet, à partir d’un fichier de configuration nommé « urls.py », il définit des patterns d’URL (« URL mapping ») à l’aide d’expressions régulières qui redirigent la requête vers tel ou tel contrôleur.
On peut passer des paramètres aux contrôleurs (exemple ci-dessous avec people_id), utiliser des valeurs soumises à travers des formulaires (dans request.POST dans le contrôleur), etc…
Les noms donnés aux URL sont repris dans les templates HTML. Par exemple la forme suivante : {% url 'about' %} sera traduite par le gestionnaire de templates en http://mondomaine.com/about/.
# coding=utf-8
from django.conf.urls import patterns, include, url
from django.conf.urls.static import static
from .views import *
from django.contrib import admin
from django.conf import settings
admin.autodiscover()
urlpatterns = patterns('',
url(r'^$', home, name='home'),
#Institutional pages
url(r'^about/$', about, name='about'),
url(r'^team/$', team, name='team'),
# gestion des personnes
url(r'^people/$', classify_in_list, name='classify_in_list'),
url(r'^people/remove/(?P<people_id>[0-9]+)/$', remove_people, name='remove_people'),
url(r'^people/add/(?P<people_id>[0-9]+)/$', add_people, name='add_people'),
url(r'^ people/show/(?P<people_id>[0-9]+)/$', people_details, name='people_details'),
# admin
url(r'^admin/', include(admin.site.urls)),
)
# gestion des ressources media
urlpatterns += static(settings.MEDIA_URL,document_root=settings.MEDIA_ROOT)
# internationalisation
urlpatterns += patterns('',
url(r'^i18n/', include('django.conf.urls.i18n')),
)
Pour aller plus loin : https://docs.djangoproject.com/en/dev/topics/http/urls/
Exceptions et débogage
Les exceptions et stacktraces Python sont bien gérées sous Django. Elles permettent de déboguer aisément les applications WEB grâce à un paramètre de configuration global « Debug=True|False ». En mode debug, à chaque erreur, l’ensemble des variables d’environnement et du code ayant provoqué l’exception sont tracés à l’écran, tandis qu’en mode « non-debug », une page 404 ou 500 est affichée (environnement de production par exemple).
Exemple (erreur dans l’URL) :
D’autres fonctionnalités peuvent être ajoutées, grâce au plugin django-debug-toolbar qui permet de visualiser le temps d’exécution des requêtes AJAX, des requêtes SQL côté serveur, etc…
Django possède un serveur d’applications natif qu’on peut lancer avec la commande Django « runserver », qui permet de déployer instantanément les sites en cours de développement. Il est également assez facile de tester du code (et notamment en debug) sans même avoir besoin de redéployer !
Pour aller plus loin : https://docs.djangoproject.com/en/dev/ref/exceptions/
Tout est fait pour vous aider !
Comme vous avez pu le constater dans les différents points précédents, de nombreux compléments d’informations sont disponibles à propos de Django pour les développeurs, notamment sur le site de la documentation officielle du projet : https://docs.djangoproject.com
Ce framework est également doté d’une communauté assez forte de développeurs passionnés qui continue d'améliorer le framework pour le rendre toujours plus riche afin de rendre le développement web toujours plus simple et rapide (une version majeure releasée tous les ans).
https://www.djangoproject.com/community/
De nombreux packages à disposition
Une des forces de Django est également de disposer de nombreuses applications tierces qui permettent de palier certaines problématiques récurrentes (gestion de calendrier, réseaux sociaux, arborescences, images miniatures, CMS, etc…).
Ces packages sont très facilement intégrables grâce à des outils d’installation et de gestion de packages tels que pip ou easy_install, qui utilisent des dépôts officiels de packages tels que pypi (intégrés aux IDE) : https://pypi.python.org/pypi/
Tout n’est pas rose
Ce framework possède également certaines faiblesses, notamment le fait de ne pas intégrer d’AJAX côté client WEB ou de ne pas gérer les migrations lors des modifications des modèles de données.
Pour l’AJAX, c’est un choix de l’équipe de développement qui considère que c’est au développeur de choisir la librairie AJAX qui lui convient côté client (jQuery, MooTools, Prototype, dojo…).
Pour les migrations de modèles de données, c’est plus ennuyeux. Heureusement, un package tierce nommé South permet de gérer ce genre de problématiques et est d’ailleurs très répandu sur les projets Django aujourd’hui. En attendant peut-être un outil natif pour Django 1.7…
Il est également légèrement plus complexe de déployer un projet en production sous Django par rapport à un projet PHP par exemple, car il nécessite un Apache avec un module WSGI pour s’exécuter et quelques étapes de configuration sur le serveur. Mais rien de bien méchant et de nombreux guides sont là pour vous aider dans cette tâche : https://docs.djangoproject.com/en/dev/howto/deployment/
Lancez-vous !
Django est fait pour vous si vous aimez développer rapidement et simplement des applications Web 2.0 robustes et modulaires.
La montée en compétences sur ce framework est très rapide et permet de gagner un temps précieux sur vos projets (productivité excellente), tout en conservant une qualité de code et une modularité très importante.
De plus, vous pouvez vous appuyer sur une documentation riche et une communauté toujours prête à vous aider alors, pourquoi ne pas vous lancer ?
Des cas pratiques
Code source de l’exemple : https://github.com/mbarroux/django_arolla_example
Travaux pratiques : http://django-story.readthedocs.org/en/latest/#intro-tutorial02
Le site du zéro : http://fr.openclassrooms.com/informatique/cours/developpez-vos-applications-web-avec-django
Documentation et tutoriels : http://docs.django-fr.org/index.html
Tutoriels : https://code.djangoproject.com/wiki/Tutorials
Retour d’expérience d’un ex-PHP : http://www.miximum.fr/methodes-et-outils/1300-https://www.miximum.fr/blog/python-et-django-retour-dexperience-apres-deux-ans/python-et-django-retour-dexperience-apres-deux-ans
1 comment for “Le framework Django – 2e partie”