Tutoriel Django

Django est un framework web Python de haut niveau qui vous permet de créer rapidement des applications web sécurisées et évolutives. Il suit le patron architectural Model-Template-View (MTV) — un proche cousin du MVC — et intègre un ORM, une interface d'administration, le routage d'URL, l'authentification et bien plus encore. La philosophie « batteries incluses » de Django signifie que vous consacrez votre temps à la logique applicative plutôt qu'à assembler une infrastructure.

Ce tutoriel parcourt les étapes essentielles : installer Django dans un environnement virtuel, créer un projet et une application, définir des modèles, écrire des vues, construire des templates, exécuter des migrations de base de données et vérifier le tout dans le navigateur.

Pourquoi utiliser Django

Batteries incluses

Django est livré avec un panneau d'administration intégré, l'authentification des utilisateurs, la gestion des formulaires, un ORM, la prise en charge du cache et des utilitaires d'internationalisation. Il n'est pas nécessaire de chercher des paquets tiers pour couvrir ces besoins fondamentaux.

Sécurité par défaut

Django se protège contre les injections SQL en utilisant des requêtes paramétrées via son ORM. Il offre également une protection intégrée contre les attaques Cross-Site Scripting (XSS), Cross-Site Request Forgery (CSRF) et le clickjacking. La clé secrète, le mode DEBUG et les paramètres ALLOWED_HOSTS réduisent encore davantage la surface d'attaque.

Évolutivité

Django alimente des sites à fort trafic, notamment Instagram et Disqus. Son framework de cache s'intègre avec Memcached et Redis, et l'ORM prend en charge le pooling de connexions à la base de données. Vous pouvez évoluer verticalement ou horizontalement sans modifier votre code applicatif.

Grand écosystème

L'index des paquets Django répertorie des milliers d'applications tierces — API REST (djangorestframework), gestion des images, passerelles de paiement et bien plus encore. La stabilité du framework et son long cycle de versions garantissent que ces paquets sont activement maintenus.

Comment fonctionne le patron MTV de Django

Le distributeur d'URL (urls.py) associe les chemins de requêtes entrantes à la vue appropriée. La vue interroge les modèles, puis transmet les données à un template. Le HTML rendu est retourné au navigateur.

Configurer un environnement virtuel

Isolez toujours les projets Django dans un environnement virtuel afin que les dépendances n'entrent pas en conflit entre les projets.

# Create and activate a virtual environment
python -m venv venv
source venv/bin/activate        # macOS / Linux
venv\Scripts\activate           # Windows

Après l'activation, votre invite affiche (venv). Chaque pip install à partir de ce moment n'affecte que cet environnement.

Installer Django

Avec l'environnement virtuel actif, installez Django en utilisant pip :

pip install django

Vérifiez l'installation :

python -m django --version

Django affiche une chaîne de version telle que 5.1.4.

Créer un projet Django

Un projet est le conteneur de niveau supérieur pour l'ensemble de votre site. Créez-en un avec :

django-admin startproject mysite
cd mysite

Cela génère la structure suivante :

mysite/
├── manage.py          # Command-line utility for this project
└── mysite/
    ├── __init__.py
    ├── settings.py    # Project configuration (database, installed apps, …)
    ├── urls.py        # Root URL dispatcher
    ├── asgi.py        # ASGI entry point
    └── wsgi.py        # WSGI entry point

manage.py est votre outil principal pour exécuter des commandes telles que démarrer le serveur de développement, créer des migrations et créer un superutilisateur. Le dossier interne mysite/ est le paquet Python du projet lui-même.

Créer une application Django

Un projet peut contenir plusieurs applications — des modules autonomes, chacun responsable d'un domaine fonctionnel. Créez une application de blog :

python manage.py startapp blog

Enregistrez-la pour que Django puisse trouver ses modèles, templates et fichiers statiques. Ouvrez mysite/settings.py et ajoutez 'blog' à INSTALLED_APPS :

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'blog',                   # <-- add this line
]

Le répertoire de l'application ressemble à ceci après sa création :

blog/
├── __init__.py
├── admin.py       # Register models with the admin interface
├── apps.py        # App configuration
├── migrations/    # Auto-generated migration files
│   └── __init__.py
├── models.py      # Database models
├── tests.py
└── views.py       # View functions

Définir des modèles

Un modèle est une classe Python qui hérite de django.db.models.Model. Chaque attribut de classe correspond à une colonne de base de données. L'ORM de Django traduit votre code Python en SQL et gère toutes les interactions avec la base de données.

Ouvrez blog/models.py et définissez un modèle Post :

from django.db import models
from django.contrib.auth.models import User

class Post(models.Model):
    title = models.CharField(max_length=200)
    content = models.TextField()
    author = models.ForeignKey(User, on_delete=models.CASCADE)
    date_posted = models.DateTimeField(auto_now_add=True)
    updated_at = models.DateTimeField(auto_now=True)

    def __str__(self):
        return self.title

    class Meta:
        ordering = ['-date_posted']   # Newest posts first

Types de champs clés utilisés ici :

La méthode __str__ contrôle la façon dont l'objet s'affiche dans le panneau d'administration et dans le shell Python.

Exécuter les migrations

Après avoir défini ou modifié des modèles, vous devez créer et appliquer des migrations — des instructions versionnées qui mettent à jour le schéma de la base de données.

# Generate a new migration file from your model changes
python manage.py makemigrations

# Apply all pending migrations to the database
python manage.py migrate

Vous verrez une sortie telle que :

Migrations for 'blog':
  blog/migrations/0001_initial.py
    - Create model Post

Operations to perform:
  Apply all migrations: admin, auth, blog, contenttypes, sessions
Running migrations:
  Applying blog.0001_initial... OK

Exécutez migrate chaque fois que vous ajoutez, supprimez ou modifiez des champs de modèle. Ne modifiez jamais les fichiers de migration à la main, sauf si vous comprenez parfaitement leur SQL.

Utiliser le panneau d'administration Django

L'interface d'administration intégrée vous permet de créer, lire, mettre à jour et supprimer des enregistrements via un navigateur — sans interface personnalisée requise. Enregistrez le modèle Post dans blog/admin.py :

from django.contrib import admin
from .models import Post

@admin.register(Post)
class PostAdmin(admin.ModelAdmin):
    list_display = ('title', 'author', 'date_posted')
    list_filter = ('date_posted', 'author')
    search_fields = ('title', 'content')

Créez un compte superutilisateur pour pouvoir vous connecter :

python manage.py createsuperuser

Django demande un nom d'utilisateur, un e-mail et un mot de passe. Démarrez ensuite le serveur de développement et visitez http://127.0.0.1:8000/admin/ :

python manage.py runserver

Connectez-vous avec les identifiants du superutilisateur et vous verrez le modèle Posts listé sous la section « Blog ».

Écrire des vues

Une vue est une fonction Python (ou une classe) qui reçoit une requête HTTP et retourne une réponse HTTP. Ouvrez blog/views.py :

from django.shortcuts import render, get_object_or_404
from .models import Post

def post_list(request):
    """Display all published posts, newest first."""
    posts = Post.objects.all()
    return render(request, 'blog/post_list.html', {'posts': posts})

def post_detail(request, pk):
    """Display a single post by primary key."""
    post = get_object_or_404(Post, pk=pk)
    return render(request, 'blog/post_detail.html', {'post': post})

get_object_or_404 est un raccourci pratique : il récupère l'objet depuis la base de données ou retourne automatiquement une réponse 404 s'il n'existe pas. Le troisième argument de render est un dictionnaire de contexte — ses clés deviennent des variables de template.

Créer des templates

Les templates sont des fichiers HTML contenant des balises du Django Template Language (DTL). Créez la structure de répertoires :

blog/
└── templates/
    └── blog/
        ├── base.html
        ├── post_list.html
        └── post_detail.html

blog/templates/blog/base.html — une mise en page partagée :

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>{% block title %}My Blog{% endblock %}</title>
</head>
<body>
    <header><h1>My Blog</h1></header>
    <main>
        {% block content %}{% endblock %}
    </main>
</body>
</html>

blog/templates/blog/post_list.html — la page de liste :

{% extends "blog/base.html" %}

{% block title %}All Posts{% endblock %}

{% block content %}
  {% for post in posts %}
    <article>
      <h2><a href="/blog/{{ post.pk }}/">{{ post.title }}</a></h2>
      <p>By {{ post.author }} on {{ post.date_posted|date:"N j, Y" }}</p>
      <p>{{ post.content|truncatewords:30 }}</p>
    </article>
  {% empty %}
    <p>No posts yet.</p>
  {% endfor %}
{% endblock %}

blog/templates/blog/post_detail.html — la page de détail :

{% extends "blog/base.html" %}

{% block title %}{{ post.title }}{% endblock %}

{% block content %}
  <h2>{{ post.title }}</h2>
  <p>By {{ post.author }} on {{ post.date_posted|date:"N j, Y" }}</p>
  <div>{{ post.content }}</div>
  <a href="/">Back to all posts</a>
{% endblock %}

Fonctionnalités DTL clés utilisées ci-dessus :

Configurer les URL

La configuration des URL associe les chemins de requêtes aux fonctions de vue.

blog/urls.py — créez ce fichier dans le répertoire blog :

from django.urls import path
from . import views

app_name = 'blog'   # Enables namespaced URL reversing

urlpatterns = [
    path('', views.post_list, name='post_list'),
    path('<int:pk>/', views.post_detail, name='post_detail'),
]

mysite/urls.py — incluez les URL de l'application dans la racine du projet :

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('blog/', include('blog.urls', namespace='blog')),
    path('', include('blog.urls', namespace='blog_root')),
]

Le convertisseur de chemin <int:pk> capture un entier depuis l'URL et le passe comme argument mot-clé pk à post_detail.

Vérifier le flux complet

Démarrez le serveur de développement :

python manage.py runserver

Ouvrez ensuite http://127.0.0.1:8000/ dans votre navigateur. Si aucun article n'existe encore, le template affiche « No posts yet. » Connectez-vous à http://127.0.0.1:8000/admin/ et ajoutez un article. Actualisez la page d'accueil — l'article apparaît immédiatement.

Le cycle de vie de la requête pour la page d'accueil est :

1. Le navigateur envoie GET /
2. Le distributeur d'URL de Django correspond à '' et appelle post_list
3. post_list interroge Post.objects.all() (se traduit par SELECT * FROM blog_post ORDER BY date_posted DESC)
4. Django rend post_list.html, en insérant les articles dans le template
5. Le HTML rendu est retourné au navigateur

Aide-mémoire des requêtes ORM Django

L'ORM vous permet de construire des requêtes SQL en utilisant des chaînes de méthodes Python. Comprendre les recherches les plus courantes permet de gagner un temps considérable :

# All posts
Post.objects.all()

# Posts by a specific author
Post.objects.filter(author__username='alice')

# Posts containing a word in the title (case-insensitive)
Post.objects.filter(title__icontains='django')

# The five most recent posts
Post.objects.order_by('-date_posted')[:5]

# Count posts
Post.objects.count()

# Get one object (raises DoesNotExist if not found)
Post.objects.get(pk=1)

# Exclude posts by a specific author
Post.objects.exclude(author__username='alice')

Chacun de ces éléments génère une requête SQL uniquement lorsque le queryset est évalué (itéré, découpé ou converti en liste). C'est ce qu'on appelle l'évaluation paresseuse et cela réduit au minimum les appels inutiles à la base de données.

Récapitulatif de la structure du projet

Après avoir terminé ce tutoriel, la structure du projet ressemble à ceci :

mysite/
├── manage.py
├── mysite/
│   ├── settings.py
│   ├── urls.py
│   └── wsgi.py
└── blog/
    ├── admin.py
    ├── migrations/
    │   └── 0001_initial.py
    ├── models.py
    ├── templates/
    │   └── blog/
    │       ├── base.html
    │       ├── post_list.html
    │       └── post_detail.html
    ├── urls.py
    └── views.py

Erreurs courantes à éviter

Oublier d'enregistrer l'application. Si 'blog' est absent de INSTALLED_APPS, Django ne trouvera pas ses modèles ni ses templates et makemigrations ne produira aucune sortie pour cette application.

Ignorer migrate après makemigrations. Exécuter uniquement makemigrations crée le fichier de migration mais ne touche pas à la base de données. Suivez toujours avec migrate.

Erreurs de template introuvable. Django cherche les templates dans le répertoire templates/ de chaque application. Le sous-dossier blog/ supplémentaire à l'intérieur de templates/ (templates/blog/post_list.html) est une convention qui évite les conflits de noms entre les applications — ne l'ignorez pas.

DEBUG = True en production. Le serveur de développement et DEBUG = True exposent les traces d'erreurs à n'importe qui. Définissez DEBUG = False et configurez ALLOWED_HOSTS avant de déployer.

Étapes suivantes

• Modules Python — comprenez comment le système de modules Python sous-tend la structure d'importation de Django.
• Python PIP — gérez Django et ses dépendances.
• Environnements virtuels Python — maintenez chaque projet Django isolé.
• MySQL avec Python — remplacez SQLite par une base de données adaptée à la production.
• MongoDB avec Python — utilisez un backend NoSQL avec Django.

La documentation officielle de Django sur docs.djangoproject.com couvre les vues basées sur des classes, les formulaires, l'authentification, les API REST avec Django REST Framework, et le déploiement en production — autant d'étapes naturelles une fois que vous êtes à l'aise avec les bases abordées ici.