École Supérieure de Technologie de Casablanca

Département Génie Informatique

Framework Python-Django
Construction d’Applications Web Scalables

Support de cours

Pr. Moad Hicham Safhi

Département Génie Informatique
Email : [Link]@[Link]
Website : [Link]

Dernière mise à jour : 9 janvier 2026

 Framework Python-Django

Table des matières

1 CHAPITRE 1 : INTRODUCTION AU FRAMEWORK DJANGO 2
1.1 CONTEXTE ET DÉFINITIONS FONDAMENTALES . . . . . . . . . . . . . . 2
1.2 ARCHITECTURE MVT - LE CŒUR DE DJANGO . . . . . . . . . . . . . . . 2
1.3 INSTALLATION ET PREMIERS PAS . . . . . . . . . . . . . . . . . . . . . . . 3
1.4 LES COMPOSANTS CLÉS EXPLIQUÉS . . . . . . . . . . . . . . . . . . . . . 5
1.5 LE LANGAGE DE TEMPLATES DJANGO (DTL) . . . . . . . . . . . . . . . 8

2 CHAPITRE 2 : LES APPLICATIONS DJANGO, MODULARITÉ ET

RÉUTILISATION 11
2.1 POURQUOI DÉCOUPER EN APPLICATIONS ? . . . . . . . . . . . . . . . . . 11
2.2 PROJET vs APPLICATION : LA DIFFÉRENCE . . . . . . . . . . . . . . . . . 11
2.3 CRÉER UNE APPLICATION : LA COMMANDE STARAPP . . . . . . . . . . 12
2.4 ENREGISTRER L’APPLICATION DANS LE PROJET . . . . . . . . . . . . . 12
2.5 EXEMPLE COMPLET : CRÉATION D’UNE APPLICATION BLOG . . . . . 13
2.6 BONNES PRATIQUES POUR LES APPLICATIONS . . . . . . . . . . . . . . 17
2.7 LES APPLICATIONS FOURNIES PAR DJANGO . . . . . . . . . . . . . . . . 17
2.8 L’ORM DJANGO : LA BASE DE DONNÉES SANS SQL . . . . . . . . . . . . 17
2.9 L’INTERFACE D’ADMINISTRATION . . . . . . . . . . . . . . . . . . . . . . . 19
2.10 AUTHENTIFICATION ET SÉCURITÉ . . . . . . . . . . . . . . . . . . . . . . 20
2.11 PAGINATION - GÉRER LES LONGUES LISTES . . . . . . . . . . . . . . . . 21
2.12 MIDDLEWARE ; LE SYSTÈME DE FILTRES . . . . . . . . . . . . . . . . . . 22

3 CHAPITRE 3 : DJANGO REST FRAMEWORK, CRÉER DES APIS RES-

TFUL 24
3.1 POURQUOI CRÉER UNE API ? . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.2 QU’EST-CE QUE REST ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.3 POURQUOI DJANGO REST FRAMEWORK (DRF) ? . . . . . . . . . . . . . 25
3.4 LES COMPOSANTS PRINCIPAUX DE DRF . . . . . . . . . . . . . . . . . . . 26

4 CHAPITRE 4 : TESTS AVANCÉS ; TESTS D’INTÉGRATION ET TESTS

DE PERFORMANCE 29
4.1 POURQUOI TESTER SON CODE ? . . . . . . . . . . . . . . . . . . . . . . . . 29
4.2 LES DIFFÉRENTS TYPES DE TESTS . . . . . . . . . . . . . . . . . . . . . . 29
4.3 EXÉCUTER LES TESTS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.4 CONCLUSION ET PERSPECTIVES . . . . . . . . . . . . . . . . . . . . . . . 31

1
Framework Python-Django Pr. Safhi - ESTC

1 CHAPITRE 1 : INTRODUCTION AU FRAME-

WORK DJANGO
1.1 CONTEXTE ET DÉFINITIONS FONDAMENTALES
1.1.1 Qu’est-ce qu’un framework web ?

Imaginez que vous devez construire une maison. Vous pourriez fabriquer chaque brique, chaque
fenêtre, chaque porte vous-même. Ou vous pourriez utiliser des éléments préfabriqués et des
outils spécialisés qui accélèrent la construction. Un framework web, c’est comme cette boîte à
outils complète pour construire des applications web.

Sans framework, vous devriez réécrire les mêmes fonctionnalités à chaque projet : gérer les
connexions à la base de données, traiter les formulaires, assurer la sécurité. Avec un framework,
ces fonctionnalités sont déjà construites et testées.

1.1.2 Pourquoi Django spécifiquement ?

Django est un framework “batteries included” - toutes les piles sont incluses. Quand vous
installez Django, vous obtenez immédiatement :

— Un système de gestion de base de données (ORM).

— Une interface d’administration automatique.
— Un système d’authentification des utilisateurs.
— Une protection contre les attaques courantes.
— Un système de templates pour générer du HTML.

Des entreprises comme Instagram, Pinterest et Spotify utilisent Django pour gérer des millions
d’utilisateurs. Si c’est assez bon pour eux, c’est probablement assez bon pour vos projets !

Django est :

— Demandé : Beaucoup d’entreprises recherchent des développeurs Django. -Stable :

Existe depuis 2005, avec un support à long terme.
— Bien documenté : Une des meilleures documentations dans le monde open source.
— Communautaire : Une communauté active et accueillante.

1.2 ARCHITECTURE MVT - LE CŒUR DE DJANGO

1.2.1 Comprendre MVT (Modèle-Vue-Template)

Django utilise une architecture appelée MVT, qui ressemble beaucoup au MVC mais avec des
noms différents :

Modèle : C’est la représentation de vos données. Si vous construisez un blog, vos modèles
seraient “Article”, “Auteur”, “Commentaire”. Le modèle dit à Django comment stocker et
récupérer les données dans la base de données.

2
Framework Python-Django Pr. Safhi - ESTC

Vue : C’est le cerveau de votre application. La vue reçoit une requête web, décide quoi faire
avec, et renvoie une réponse. Par exemple, quand un utilisateur demande la page d’accueil, la
vue récupère les derniers articles et les prépare pour l’affichage.

Template : C’est l’apparence de votre site. Les templates sont des fichiers HTML avec des
espaces réservés pour les données dynamiques. Ils se chargent de l’affichage, pas de la logique.

1.2.2 Comment ces trois parties collaborent ?

1. Un utilisateur demande une URL (par exemple : /articles/)

2. Django trouve la vue associée à cette URL
3. La vue interroge la base de données via les modèles
4. La vue prend les données et les envoie à un template
5. Le template génère du HTML qui est renvoyé au navigateur

Cette séparation rend votre code plus organisé et plus facile à maintenir.

1.3 INSTALLATION ET PREMIERS PAS

1.3.1 Préparer son environnement

Avant d’installer Django, créez un environnement virtuel. C’est comme une bulle isolée où vous
installez Django sans affecter les autres projets Python sur votre ordinateur.

Pour créer et activer un environnement virtuel :

3
Framework Python-Django Pr. Safhi - ESTC

1.3.2 Installer Django

Une fois l’environnement activé :

pip install django

Pour vérifier que Django est bien installé :

django-admin --version

1.3.3 Créer votre premier projet

Un projet Django est comme un conteneur pour votre application web complète :

Cela crée une structure de dossiers :

monprojet/
��� [Link] # Outil de commande
��� monprojet/

4
Framework Python-Django Pr. Safhi - ESTC

��� __init__.py
��� [Link] # Configuration
��� [Link] # Routes URLs
��� [Link] # Pour serveurs modernes
��� [Link] # Pour serveurs web

1.3.4 Lancer le serveur de développement

python [Link] runserver

Ouvrez votre navigateur à l’adresse [Link]

Vous devriez voir la page de bienvenue de Django ! Ce serveur est uniquement pour le dévelop-
pement, pas pour la production.

1.4 LES COMPOSANTS CLÉS EXPLIQUÉS

5
Framework Python-Django Pr. Safhi - ESTC

1.4.1 Le fichier [Link] : Le centre de contrôle

Ce fichier contient toute la configuration de votre projet :

— La base de données à utiliser (SQLite pour le développement, PostgreSQL pour la

production).

— La liste des applications installées.

— Les paramètres de sécurité.

— La langue et le fuseau horaire.

— Les chemins vers les templates et fichiers statiques.

1.4.2 Les URLs : Le système de routage

Le fichier [Link] fait le lien entre les adresses web et votre code. C’est comme un réceptionniste
qui dirige les visiteurs vers le bon bureau.

Exemple simple :

6
Framework Python-Django Pr. Safhi - ESTC

from [Link] import path

from . import views

urlpatterns = [
path('', [Link]), # La page d'accueil
path('articles/', views.liste_articles), # Liste des articles
path('article/<int:id>/', views.detail_article), # Détail d'un article
]

1.4.3 Les vues : La logique métier

Une vue est une fonction Python qui reçoit une requête web et retourne une réponse. C’est là
que vous écrivez la logique de votre application.

Exemple d’une vue simple :

from [Link] import HttpResponse

from [Link] import render
from .models import Article

def accueil(request):
"""Affiche la page d'accueil"""
return HttpResponse("Bienvenue sur mon site!")

def liste_articles(request):
"""Affiche la liste des articles"""
articles = [Link]() # Récupère tous les articles
return render(request, 'articles/[Link]', {'articles': articles})

1.4.4 Les templates : L’apparence du site

Les templates séparent la présentation de la logique. Au lieu de mélanger HTML et Python,

vous gardez le HTML dans des fichiers templates.

Un template simple :

<!DOCTYPE html>
<html>
<head>
<title>Mon Blog</title>
</head>
<body>
<h1>Articles récents</h1>

7
Framework Python-Django Pr. Safhi - ESTC

{% for article in articles %}

<article>
<h2>{{ [Link] }}</h2>
<p>Publié le {{ article.date_publication|date:"d/m/Y" }}</p>
<p>{{ [Link]|truncatechars:200 }}</p>
</article>
{% empty %}
<p>Aucun article pour le moment.</p>
{% endfor %}
</body>
</html>

1.4.5 Les modèles : La structure des données

Les modèles définissent la structure de votre base de données en Python pur. Django traduit
ensuite ces modèles en instructions SQL.

Exemple de modèle :

from [Link] import models

class Article([Link]):
"""Modèle représentant un article de blog"""
titre = [Link](max_length=200)
contenu = [Link]()
date_publication = [Link](auto_now_add=True)
auteur = [Link]('Auteur', on_delete=[Link])
publie = [Link](default=False)

def __str__(self):
return [Link]

Django crée automatiquement une table en base de données pour ce modèle, avec toutes les
colonnes nécessaires.

1.5 LE LANGAGE DE TEMPLATES DJANGO (DTL)

1.5.1 Pourquoi un langage de templates spécial ?

Le Django Template Language (DTL) est conçu pour être suffisamment puissant pour créer
des pages dynamiques, mais suffisamment limité pour éviter de mettre trop de logique dans les
templates. C’est une question de séparation des responsabilités.

1.5.2 Les fonctionnalités principales du DTL

8
Framework Python-Django Pr. Safhi - ESTC

[Link] Les variables

Afficher une variable : { variable }

<h1>{{ titre_article }}</h1>

<p>Par {{ [Link] }}</p>

[Link] Les filtres

Transformer les variables :

<!-- Mettre en majuscules -->

<p>{{ texte|upper }}</p>

<!-- Formater une date -->

<p>{{ date|date:"d F Y" }}</p>

<!-- Tronquer un texte -->

<p>{{ long_texte|truncatechars:100 }}</p>

[Link] Les balises

Les balises ajoutent de la logique aux templates :

<!-- Conditions -->

{% if user.is_authenticated %}
<p>Bienvenue, {{ [Link] }}!</p>
{% else %}
<p>Veuillez vous connecter.</p>
{% endif %}

<!-- Boucles -->

<ul>
{% for article in articles %}
<li>{{ [Link] }}</li>
{% empty %}
<li>Aucun article disponible.</li>
{% endfor %}
</ul>

[Link] L’héritage de templates

C’est l’une des fonctionnalités les plus puissantes. Vous créez un template de base avec une
structure commune, et les autres templates héritent de cette base.

[Link] (template de base) :

9
Framework Python-Django Pr. Safhi - ESTC

<!DOCTYPE html>
<html>
<head>
<title>{% block titre %}Mon Site{% endblock %}</title>
</head>
<body>
<header>Mon en-tête commun</header>
<main>
{% block contenu %}
{% endblock %}
</main>
<footer>Mon pied de page commun</footer>
</body>
</html>

page_accueil.html (template enfant) :

{% extends "[Link]" %}

{% block titre %}Accueil - Mon Site{% endblock %}

{% block contenu %}
<h1>Bienvenue sur notre site</h1>
<p>Contenu spécifique à la page d'accueil...</p>
{% endblock %}

[Link] L’inclusion de templates

Pour réutiliser des morceaux de HTML à plusieurs endroits :

{% include "includes/[Link]" %}

1.5.3 Sécurité dans les templates

Django échappe automatiquement les caractères dangereux dans les variables pour éviter les
attaques XSS (Cross-Site Scripting). Si vous avez besoin d’afficher du HTML sûr, vous pouvez
utiliser le filtre |safe :

<p>{{ html_securise|safe }}</p>

Mais utilisez-le avec prudence, seulement quand vous êtes sûr que le contenu est sûr !

10
Framework Python-Django Pr. Safhi - ESTC

2 CHAPITRE 2 : LES APPLICATIONS DJANGO, MO-

DULARITÉ ET RÉUTILISATION
2.1 POURQUOI DÉCOUPER EN APPLICATIONS ?
Imaginez que vous construisez une maison. Vous ne mettez pas toute la plomberie, l’électricité,
les murs et le toit dans un seul grand tas. Vous organisez par pièces : cuisine, salle de bain,
chambre. Chaque pièce a une fonction spécifique.

Dans Django, c’est pareil. Une application est une pièce fonctionnelle de votre projet. Par
exemple :

— Une application blog pour les articles et commentaires.

— Une application utilisateurs pour l’inscription et la connexion.
— Une application boutique pour les produits et commandes.

Cette organisation permet de :

1. Réutiliser des applications dans d’autres projets.

2. Maintenir le code plus facilement.
3. Travailler en équipe (chaque développeur sur une app différente).
4. Tester chaque fonctionnalité séparément.

2.2 PROJET vs APPLICATION : LA DIFFÉRENCE

2.2.1 Le Projet : La maison complète

Le projet est le conteneur global. Il contient :

— La configuration ([Link]).
— Les URLs principales ([Link]).
— Le serveur ([Link], [Link]).

Quand vous créez un projet avec startproject, Django crée ce conteneur.

2.2.2 L’Application : Une pièce de la maison

Une application est un module autonome qui gère une fonctionnalité spécifique.

Analogie concrète :

MonSite/ Le projet (la maison)

��� blog/ Application blog (la cuisine)
��� utilisateurs/ Application utilisateurs (la salle de bain)
��� boutique/ Application boutique (le salon)
��� config/ Configuration (les fondations)

11
Framework Python-Django Pr. Safhi - ESTC

2.3 CRÉER UNE APPLICATION : LA COMMANDE STARAPP

2.3.1 Où et comment lancer la commande ?

1. Assurez-vous d’être dans le bon dossier :

cd monprojet # Le dossier qui contient [Link]

2. Créez l’application :

python [Link] startapp blog

2.3.2 Ce que la commande crée

Après startapp blog, vous obtenez cette structure :

2.4 ENREGISTRER L’APPLICATION DANS LE PROJET

2.4.1 Étape cruciale souvent oubliée !

Après avoir créé une application, vous devez l’annoncer à Django. C’est comme dire à la mairie
que vous avez ajouté une nouvelle pièce à votre maison.

Ouvrez [Link] dans votre projet et ajoutez le nom de l’application à INSTALLED_APPS :

12
Framework Python-Django Pr. Safhi - ESTC

Pourquoi c’est important ? Sans cette étape :

— Django ne connaît pas votre application.

— Les modèles ne sont pas créés en base de données.
— L’admin ne fonctionne pas.
— Les templates ne sont pas trouvés.

2.5 EXEMPLE COMPLET : CRÉATION D’UNE APPLICATION

BLOG
2.5.1 Étape par étape

1. Créer le projet (si pas encore fait) :

django-admin startproject monprojet

cd monprojet

2. Créer l’application blog :

python [Link] startapp blog

3. Enregistrer l’application dans [Link] :

# monprojet/[Link]
INSTALLED_APPS = [
# ... applications par défaut ...
'blog', # AJOUT
]

4. Créer un modèle dans blog/[Link] :

13
Framework Python-Django Pr. Safhi - ESTC

5. Créer une migration (traduire le modèle en SQL) :

python [Link] makemigrations blog

6. Appliquer la migration (créer la table en base de données) :

python [Link] migrate

14
Framework Python-Django Pr. Safhi - ESTC

5. Créer une vue dans blog/[Link] :

5. Créer un template dans blog/templates/blog/[Link] :

5. Créer un fichier d’URLs pour l’application (blog/[Link]) :

15
Framework Python-Django Pr. Safhi - ESTC

5. Inclure les URLs de l’application dans le projet (monprojet/[Link]) :

5. Tester : python [Link] runserver puis allez sur [Link]

16
Framework Python-Django Pr. Safhi - ESTC

2.6 BONNES PRATIQUES POUR LES APPLICATIONS

2.6.1 Nommage des applications

— Singulier : blog pas blogs.

— Court et descriptif : utilisateurs pas gestion_des_utilisateurs_connectes.
— Pas de caractères spéciaux : blog pas blog-app.

2.6.2 Quand créer une nouvelle application ?

Créez une nouvelle application quand : - La fonctionnalité peut être nommée clairement (blog,
utilisateurs, boutique). - Elle a ses propres modèles (tables en base de données). - Elle pourrait
être réutilisée dans un autre projet . - L’application actuelle dépasse 500 lignes de code.

2.7 LES APPLICATIONS FOURNIES PAR DJANGO

Django inclut déjà plusieurs applications prêtes à l’emploi. Dans INSTALLED_APPS par défaut :

INSTALLED_APPS = [
'[Link]', # Interface d'administration
'[Link]', # Système d'authentification
'[Link]', # Gestion des types de contenu
'[Link]', # Gestion des sessions
'[Link]', # Système de messages
'[Link]', # Gestion des fichiers statiques
]

Ces applications sont déjà migrées (tables créées en base de données) quand vous lancez python
[Link] migrate.

2.8 L’ORM DJANGO : LA BASE DE DONNÉES SANS SQL

2.8.1 Qu’est-ce qu’un ORM ?

ORM signifie Object-Relational Mapping. C’est une couche qui vous permet d’utiliser des objets
Python pour interagir avec votre base de données, au lieu d’écrire du SQL manuellement.

17
Framework Python-Django Pr. Safhi - ESTC

2.8.2 Avantages de l’ORM

1. Écriture en Python pur : Pas besoin d’apprendre un langage différent pour chaque
base de données.
2. Sécurité : Protection intégrée contre les injections SQL.
3. Portabilité : Le même code fonctionne avec SQLite, PostgreSQL, MySQL, etc.
4. Productivité : Moins de code à écrire et à maintenir.

2.8.3 Exemples d’opérations avec l’ORM

[Link] Créer un objet

# Au lieu de: INSERT INTO article (titre, contenu) VALUES ('Django', 'cours')
article = Article(titre="Django", contenu="cours")
[Link]()

Ou en une ligne :

[Link](titre="Mon titre", contenu="Mon contenu")

[Link] Lire des données

# Récupérer tous les articles
tous_les_articles = [Link]()

# Récupérer un article spécifique

article = [Link](id=1)

# Filtrer les articles

articles_publies = [Link](publie=True)
articles_recentes = [Link](date_publication_year=2023)

# Articles triés par date

articles_ordonnes = [Link]().order_by('-date_publication')

[Link] Mettre à jour

article = [Link](id=1)
[Link] = "Nouveau titre"
[Link]()

[Link] Supprimer

article = [Link](id=1)
[Link]()

18
Framework Python-Django Pr. Safhi - ESTC

2.8.4 Relations entre modèles

Django gère trois types de relations :

1. ForeignKey : Une relation plusieurs-à-un (plusieurs articles pour un auteur).

2. ManyToManyField : Une relation plusieurs-à-plusieurs (un article peut avoir plusieurs
tags, un tag peut être sur plusieurs articles).
3. OneToOneField : Une relation un-à-un (un utilisateur a un profil).

2.9 L’INTERFACE D’ADMINISTRATION

2.9.1 Une fonctionnalité révolutionnaire

L’interface d’admin de Django est générée automatiquement à partir de vos modèles. En quelques
lignes de code, vous obtenez une interface complète pour gérer vos données.

2.9.2 Activer l’admin pour un modèle

Dans [Link] de votre application :

Et voilà ! Vous pouvez maintenant créer, lire, mettre à jour et supprimer des articles via l’interface
d’admin à l’adresse /admin.

2.9.3 Créer un superutilisateur

Pour accéder à l’admin, vous avez besoin d’un compte administrateur :

python [Link] createsuperuser

Suivez les instructions pour créer votre compte, puis allez sur /admin pour vous connecter.

19
Framework Python-Django Pr. Safhi - ESTC

2.10 AUTHENTIFICATION ET SÉCURITÉ

2.10.1 Le système d’authentification intégré

Django inclut un système d’authentification complet :

— Inscription et connexion des utilisateurs.

— Gestion des mots de passe (hachés de manière sécurisée).
— Permissions et groupes.
— Sessions utilisateur.

2.10.2 Utiliser l’authentification dans les vues

Vérifier si un utilisateur est connecté :

def ma_vue(request):
if [Link].is_authenticated:
# Utilisateur connecté
return HttpResponse(f"Bonjour {[Link]}!")
else:
# Utilisateur non connecté
return HttpResponse("Veuillez vous connecter.")

2.10.3 Les permissions

Django crée automatiquement des permissions pour chaque modèle :

— app.add_modele : permission d’ajouter.

— app.change_modele : permission de modifier.
— app.delete_modele : permission de supprimer.
— app.view_modele : permission de voir.

20
Framework Python-Django Pr. Safhi - ESTC

Vérifier une permission :

if [Link].has_perm('blog.add_article'):
# L'utilisateur peut ajouter des articles

2.10.4 La protection CSRF

CSRF (Cross-Site Request Forgery) est une attaque où un site malveillant essaie de faire exécuter
des actions à un utilisateur connecté sans son consentement.

Django protège contre cela avec un jeton CSRF. Dans vos templates, incluez toujours {%
csrf_token %} dans les formulaires POST :

<form method="post">
{% csrf_token %}
<!-- Vos champs de formulaire ici -->
<input type="submit" value="Envoyer">
</form>

2.11 PAGINATION - GÉRER LES LONGUES LISTES

2.11.1 Pourquoi paginer ?

Imaginez un site avec 10000 articles. Si vous affichez tous les articles sur une même page :

— La page mettra très longtemps à charger.

— L’expérience utilisateur sera mauvaise.
— Le référencement (SEO) en souffrira.

La solution : diviser les résultats en plusieurs pages.

2.11.2 Mise en œuvre de la pagination

Dans votre vue :

from [Link] import Paginator

def liste_articles(request):
articles = [Link](publie=True)
paginator = Paginator(articles, 10) # 10 articles par page

page_number = [Link]('page')
page_obj = paginator.get_page(page_number)

return render(request, 'articles/[Link]', {'page_obj': page_obj})

21
Framework Python-Django Pr. Safhi - ESTC

Dans votre template :

{% for article in page_obj %}

<!-- Afficher chaque article -->
{% endfor %}

<!-- Liens de pagination -->

<div class="pagination">
{% if page_obj.has_previous %}
<a href="?page=1">Première</a>
<a href="?page={{ page_obj.previous_page_number }}">Précédente</a>
{% endif %}

<span>Page {{ page_obj.number }} sur {{ page_obj.paginator.num_pages }}</span>

{% if page_obj.has_next %}
<a href="?page={{ page_obj.next_page_number }}">Suivante</a>
<a href="?page={{ page_obj.paginator.num_pages }}">Dernière</a>
{% endif %}
</div>

2.12 MIDDLEWARE ; LE SYSTÈME DE FILTRES

2.12.1 Qu’est-ce qu’un middleware ?

Le middleware est une couche intermédiaire qui traite les requêtes et les réponses. C’est comme
une série de filtres que traverse chaque requête.

2.12.2 Exemples de middleware intégrés

— AuthenticationMiddleware : Ajoute l’objet user à chaque requête.

— SecurityMiddleware : Ajoute des en-têtes de sécurité.
— CsrfViewMiddleware : Vérifie les tokens CSRF.
— SessionMiddleware : Gère les sessions utilisateur.

2.12.3 Comment ça fonctionne ?

Quand une requête arrive :

1. Elle passe par tous les middleware (dans l’ordre).

2. Elle arrive à la vue.
3. La réponse repasse par tous les middleware (dans l’ordre inverse).

22
Framework Python-Django Pr. Safhi - ESTC

2.12.4 Créer son propre middleware

Un middleware simple pour logger les requêtes :

class LoggingMiddleware:
def __init__(self, get_response):
self.get_response = get_response

def __call__(self, request):

# Code exécuté avant la vue
print(f"Requête reçue: {[Link]}")

response = self.get_response(request)

# Code exécuté après la vue

print(f"Réponse envoyée avec statut: {response.status_code}")

return response

Ajoutez-le ensuite dans [Link] :

MIDDLEWARE = [
# ...
'[Link]',

23
Framework Python-Django Pr. Safhi - ESTC

# ...
]

3 CHAPITRE 3 : DJANGO REST FRAMEWORK,

CRÉER DES APIS RESTFUL
3.1 POURQUOI CRÉER UNE API ?
Imaginez que vous développez une application mobile pour votre site web. L’application mobile
ne peut pas exécuter le code Python de Django directement. Elle a besoin d’un moyen pour :

— Récupérer des données depuis votre base de données.

— Envoyer de nouvelles données (comme un nouvel article ou un commentaire).
— Mettre à jour ou supprimer des données existantes.

Une API (Application Programming Interface) est comme un serveur dans un restaurant. Vous
(l’application mobile) donnez une commande, et le serveur (l’API) va chercher ce que vous avez
demandé dans la cuisine (la base de données) et vous le rapporte.

3.2 QU’EST-CE QUE REST ?

REST (Representational State Transfer) est un style d’architecture pour les APIs. C’est une
série de règles que suivent beaucoup d’APIs modernes :

1. Utilise HTTP proprement : Chaque type d’action correspond à une méthode HTTP :

— GET : Récupérer des données

— POST : Créer de nouvelles données
— PUT : Mettre à jour des données existantes
— DELETE : Supprimer des données
2. Sans état (stateless) : Chaque requête contient toute l’information nécessaire. Le serveur
ne garde pas de mémoire de l’état du client entre les requêtes.
3. Ressources identifiables par URL : Chaque élément (utilisateur, article, commentaire) a
sa propre URL.

24
Framework Python-Django Pr. Safhi - ESTC

3.3 POURQUOI DJANGO REST FRAMEWORK (DRF) ?

DRF est à l’API ce que Django est au site web traditionnel. C’est une boîte à outils complète
pour créer des APIs RESTful avec Django.

Sans DRF, créer une API simple pour gérer des articles ressemblerait à :

from [Link] import JsonResponse

from .models import Article
import json

def api_articles(request):
if [Link] == 'GET':
articles = [Link]()
data = []
for article in articles:
[Link]({
'id': [Link],
'titre': [Link],
'contenu': [Link]
})
return JsonResponse(data, safe=False)

elif [Link] == 'POST':

data = [Link]([Link])
article = [Link](
titre=data['titre'],

25
Framework Python-Django Pr. Safhi - ESTC

contenu=data['contenu']
)
return JsonResponse({'id': [Link]}, status=201)

Avec DRF, le même code devient :

from rest_framework import serializers, viewsets

from .models import Article

class ArticleSerializer([Link]):
class Meta:
model = Article
fields = '__all__'

class ArticleViewSet([Link]):
queryset = [Link]()
serializer_class = ArticleSerializer

Et DRF génère automatiquement toutes les URLs nécessaires !

3.4 LES COMPOSANTS PRINCIPAUX DE DRF

3.4.1 Les Serializers

Les serializers sont comme les formulaires de Django, mais pour les données JSON. Ils font deux
choses :

— Sérialisation : Convertir un objet Python (comme un modèle Article) en JSON.

— Désérialisation : Convertir du JSON en objet Python.

Exemple de serializer :

from rest_framework import serializers

from .models import Article, Commentaire

class CommentaireSerializer([Link]):
auteur = [Link](source='[Link]')

class Meta:
model = Commentaire
fields = ['id', 'contenu', 'auteur', 'date_creation']

class ArticleSerializer([Link]):
# Relation avec les commentaires

26
Framework Python-Django Pr. Safhi - ESTC

commentaires = CommentaireSerializer(many=True, read_only=True)

# Champ calculé
nombre_commentaires = [Link]()

class Meta:
model = Article
fields = ['id', 'titre', 'contenu', 'date_publication',
'auteur', 'commentaires', 'nombre_commentaires']

def get_nombre_commentaires(self, obj):

return [Link]()

def validate_titre(self, value):

"""Validation personnalisée"""
if len(value) < 10:
raise [Link](
"Le titre doit faire au moins 10 caractères"
)
return value

3.4.2 Les Views (vues) de l’API

DRF offre plusieurs types de vues, du plus simple au plus complexe :

[Link] APIView (la plus basique)

from rest_framework.views import APIView

from rest_framework.response import Response
from rest_framework import status
from .models import Article
from .serializers import ArticleSerializer

class ListeArticles(APIView):
def get(self, request):
articles = [Link]()
serializer = ArticleSerializer(articles, many=True)
return Response([Link])

def post(self, request):

serializer = ArticleSerializer(data=[Link])
if serializer.is_valid():
[Link]()

27
Framework Python-Django Pr. Safhi - ESTC

return Response([Link], status=status.HTTP_201_CREATED)

return Response([Link], status=status.HTTP_400_BAD_REQUEST)

[Link] ViewSets (le plus puissant)

Les ViewSets combinent plusieurs actions dans une seule classe :

from rest_framework import viewsets, permissions, filters

from rest_framework.decorators import action
from rest_framework.response import Response
from .models import Article
from .serializers import ArticleSerializer

class ArticleViewSet([Link]):
queryset = [Link]()
serializer_class = ArticleSerializer
permission_classes = [[Link]]
filter_backends = [[Link], [Link]]
search_fields = ['titre', 'contenu']
ordering_fields = ['date_publication', 'titre']

# Action personnalisée: /api/articles/{id}/publier/

@action(detail=True, methods=['post'])
def publier(self, request, pk=None):
article = self.get_object()
[Link] = True
[Link]()
return Response({'status': 'article publié'})

# Action sur la collection: /api/articles/articles_recents/

@action(detail=False)
def articles_recents(self, request):
articles = [Link](
date_publication__gte='2023-01-01'
)[:10]
serializer = self.get_serializer(articles, many=True)
return Response([Link])

3.4.3 Les Routers

Les routers génèrent automatiquement les URLs pour vos ViewSets :

28
Framework Python-Django Pr. Safhi - ESTC

from rest_framework.routers import DefaultRouter

from .views import ArticleViewSet, AuteurViewSet

router = DefaultRouter()
[Link](r'articles', ArticleViewSet)
[Link](r'auteurs', AuteurViewSet)

urlpatterns = [Link]

Cela crée automatiquement :

— GET /api/articles/ : Liste tous les articles.

— POST /api/articles/ : Crée un nouvel article.
— GET /api/articles/{id}/ : Détail d’un article.
— PUT /api/articles/{id}/ : Met à jour un article.
— DELETE /api/articles/{id}/ : Supprime un article.
— POST /api/articles/{id}/publier/ : Notre action personnalisée.

4 CHAPITRE 4 : TESTS AVANCÉS ; TESTS D’INTÉ-

GRATION ET TESTS DE PERFORMANCE
4.1 POURQUOI TESTER SON CODE ?
Imaginez que vous construisez une chaise. Vous pourriez la construire sans la tester, et espérer
qu’elle supporte le poids ; ou bien la construire, puis demander à quelqu’un de s’asseoir dessus
pour voir si elle tient.

Les tests automatisés, c’est comme avoir une machine qui teste automatiquement chaque chaise
que vous fabriquez. Si vous changez quelque chose (un nouveau type de vis, un autre bois), la
machine reteste immédiatement pour s’assurer que la chaise tient toujours.

4.2 LES DIFFÉRENTS TYPES DE TESTS

4.2.1 Tests unitaires

Testent une petite unité de code en isolation (une fonction, une méthode).

Exemple : Tester une fonction qui calcule le total d’une commande.

def calculer_total(articles):
return sum([Link] for article in articles)

# Test unitaire
def test_calculer_total():

29
Framework Python-Django Pr. Safhi - ESTC

articles = [Article(prix=10), Article(prix=20)]

assert calculer_total(articles) == 30

4.2.2 Tests d’intégration

Testent comment différentes parties du système fonctionnent ensemble.

Exemple : Tester qu’un utilisateur peut se connecter, créer un article, et le voir apparaître sur
le site.

4.2.3 Tests de performance

Testent si l’application est assez rapide sous charge.

Exemple : Vérifier que la page d’accueil se charge en moins de 2 secondes même avec 10 000
utilisateurs connectés.

4.3 EXÉCUTER LES TESTS

# Tous les tests
python [Link] test

# Tests d'une application spécifique

python [Link] test monapp

# Tests d'une classe spécifique

python [Link] test [Link]

# Tests d'une méthode spécifique

python [Link] test [Link].test_flux_complet_visiteur

# Avec verbosité
python [Link] test -v 2

# Garder la base de données de test entre les runs (plus rapide)

python [Link] test --keepdb

Les tests ne sont pas un luxe, mais une nécessité. Ils vous permettent de :

1. Dormir tranquille : Savoir que vos modifications ne cassent rien.

2. Refactoriser en confiance : Changer le code sans peur.
3. Documenter le comportement : Les tests montrent comment le code est censé fonctionner.
4. Détecter les régressions : Quand un bug revient, vos tests le détectent.
5. Améliorer la qualité : Écrire des tests vous force à écrire du code plus modulaire et
testable.

30
Framework Python-Django Pr. Safhi - ESTC

Commencez par tester les fonctionnalités critiques, puis étendez progressivement votre couverture
de tests. Un bon objectif est d’atteindre 80% de couverture de code.

Une application bien testée est une application qui dure dans le temps. Les tests sont votre
filet de sécurité quand vous modifiez du code, et votre assurance qualité avant de déployer en
production.

4.4 CONCLUSION ET PERSPECTIVES

Django est plus qu’un outil technique. C’est une philosophie de développement qui vous apprend
à structurer vos pensées, à prioriser la sécurité et à écrire du code maintenable. Ces compétences
sont transférables à n’importe quel autre framework ou langage.

4.4.1 Ressources pour continuer

Documentation officielle : [Link]

31