Démarrage
Installer et créer un projet
Installez Django via pip. Un projet contient les réglages et les URLs ; une app est un module réutilisable avec ses models et ses views.
pip install django
django-admin startproject myproject
cd myproject
python manage.py startapp myappLancer le serveur de développement
Démarre le serveur de développement intégré avec rechargement automatique. À ne jamais utiliser en production.
python manage.py runserver
# Default: http://127.0.0.1:8000
python manage.py runserver 8080
python manage.py runserver 0.0.0.0:8000Migrations et superutilisateur
makemigrations génère les fichiers de migration à partir des changements de modèles. migrate les applique à la base. createsuperuser crée un compte administrateur.
python manage.py makemigrations
python manage.py migrate
python manage.py createsuperuserStructure du projet
manage.py est l'outil en ligne de commande. Le package interne contient la configuration du projet ; le répertoire de l'app contient le code propre à l'app.
myproject/
manage.py # CLI utility
myproject/
settings.py # Configuration
urls.py # Root URL dispatcher
wsgi.py # WSGI entry point
asgi.py # ASGI entry point
myapp/
models.py # Database models
views.py # View functions
admin.py # Admin registrationBases des settings
INSTALLED_APPS liste les apps actives. Passez DEBUG=False et configurez ALLOWED_HOSTS en production.
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'myapp',
]
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': BASE_DIR / 'db.sqlite3',
}
}
DEBUG = True
ALLOWED_HOSTS = []Champs de modèle
Définir un modèle
Chaque classe de modèle correspond à une table de la base. Chaque champ correspond à une colonne. __str__ définit le nom d'affichage.
from django.db import models
class Article(models.Model):
title = models.CharField(max_length=200)
body = models.TextField()
published = models.DateTimeField(auto_now_add=True)
def __str__(self):
return self.titleTypes de champs courants
CharField exige max_length. auto_now_add s'applique à la création ; auto_now se met à jour à chaque enregistrement. EmailField/URLField ajoutent une validation.
name = models.CharField(max_length=100)
description = models.TextField(blank=True)
price = models.DecimalField(max_digits=10, decimal_places=2)
quantity = models.IntegerField(default=0)
is_active = models.BooleanField(default=True)
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=True)
email = models.EmailField(unique=True)
url = models.URLField(blank=True)Options de champ
null agit au niveau de la base ; blank au niveau de la validation. choices crée une liste déroulante dans les formulaires et l'admin.
title = models.CharField(
max_length=200,
null=True, # DB allows NULL
blank=True, # Form allows empty
default='',
choices=[('draft', 'Draft'), ('pub', 'Published')],
help_text='Article title',
verbose_name='Article Title',
)Options Meta
ordering définit l'ordre de tri par défaut. db_table remplace le nom de table généré automatiquement. constraints impose des règles au niveau de la base.
class Meta:
ordering = ['-created_at']
db_table = 'articles'
verbose_name_plural = 'Articles'
constraints = [
models.UniqueConstraint(
fields=['title', 'author'],
name='unique_title_per_author',
)
]Méthodes et propriétés de modèle
Surchargez save() pour la logique avant enregistrement. @property ajoute des attributs calculés. Appelez toujours super().save().
class Article(models.Model):
title = models.CharField(max_length=200)
views = models.IntegerField(default=0)
def __str__(self):
return self.title
def save(self, *args, **kwargs):
self.title = self.title.strip()
super().save(*args, **kwargs)
@property
def is_popular(self):
return self.views > 1000Relations entre modèles
ForeignKey (plusieurs-à-un)
ForeignKey crée une relation plusieurs-à-un. related_name permet les requêtes inverses : author.books.all().
class Author(models.Model):
name = models.CharField(max_length=100)
class Book(models.Model):
author = models.ForeignKey(
Author,
on_delete=models.CASCADE,
related_name='books',
)
title = models.CharField(max_length=200)OneToOneField
OneToOneField crée un lien un-à-un. Accès via user.profile ou profile.user.
class Profile(models.Model):
user = models.OneToOneField(
User,
on_delete=models.CASCADE,
)
bio = models.TextField()ManyToManyField
ManyToManyField crée automatiquement une table de jonction. Ajout/retrait : course.students.add(student).
class Student(models.Model):
name = models.CharField(max_length=100)
class Course(models.Model):
students = models.ManyToManyField(Student, blank=True)
title = models.CharField(max_length=200)Options on_delete
CASCADE supprime les enfants quand le parent est supprimé. SET_NULL exige null=True. PROTECT lève une ProtectedError.
# CASCADE - delete related objects
author = models.ForeignKey(Author, on_delete=models.CASCADE)
# SET_NULL - set to NULL (field must be nullable)
author = models.ForeignKey(Author, on_delete=models.SET_NULL, null=True)
# PROTECT - prevent deletion
author = models.ForeignKey(Author, on_delete=models.PROTECT)
# SET_DEFAULT - set to default value
author = models.ForeignKey(Author, on_delete=models.SET_DEFAULT, default=1)Requêtes sur les objets liés
L'accès direct (forward) utilise le nom du champ. L'accès inverse utilise related_name (ou modelname_set par défaut).
# Forward query
book.author.name
# Reverse query (uses related_name)
author.books.all()
author.books.filter(title__contains='Django')
# Add/remove in M2M
course.students.add(student1, student2)
course.students.remove(student1)
course.students.clear()
# Check membership
student in course.students.all()QuerySet de l'ORM
Créer et enregistrer des objets
create() enregistre immédiatement. get_or_create renvoie (objet, booléen_créé) — récupère ou crée de façon atomique.
# Method 1: Create and save separately
article = Article(title='Hello', body='World')
article.save()
# Method 2: Create in one step
article = Article.objects.create(title='Hello', body='World')
# Method 3: get_or_create
obj, created = Article.objects.get_or_create(
title='Hello', defaults={'body': 'World'}
)Récupérer un seul objet
get() lève DoesNotExist si rien n'est trouvé, MultipleObjectsReturned si plusieurs. Utilisez first() pour récupérer un objet sans risque.
# Get by primary key
article = Article.objects.get(pk=1)
# Get by field
article = Article.objects.get(title='Hello')
# First/last (returns None if empty)
first = Article.objects.first()
last = Article.objects.last()
# Latest/earliest by field
latest = Article.objects.latest('created_at')Filtrer et exclure
filter() renvoie un QuerySet (paresseux). L'enchaînement applique une logique AND. Les QuerySets ne sont évalués qu'à l'itération.
# Filter
Article.objects.filter(title__contains='Django')
Article.objects.filter(published=True)
# Exclude
Article.objects.exclude(views__lt=100)
# Chain filters (AND)
Article.objects.filter(author=1).exclude(draft=True)Lookups de champs
Les lookups utilisent la syntaxe à double tiret bas. Courants : exact, contains, icontains, gt, gte, lt, lte, in, startswith, range.
Article.objects.filter(title__icontains='django') # case-insensitive
Article.objects.filter(views__gte=100) # >=
Article.objects.filter(views__in=[100, 200, 300]) # IN
Article.objects.filter(created_at__year=2024) # date lookup
Article.objects.filter(title__startswith='Hello') # LIKE 'Hello%'
Article.objects.filter(title__isnull=True) # IS NULLTri et découpage
Le slicing applique un LIMIT au niveau de la base. L'indexation négative n'est pas prise en charge sur les QuerySets.
# Order by
Article.objects.order_by('-created_at') # descending
Article.objects.order_by('author', '-views')
# Slice (LIMIT/OFFSET)
Article.objects.all()[:5] # first 5
Article.objects.all()[5:10] # offset 5, limit 5
Article.objects.order_by('-views')[:3] # top 3
# Distinct
Article.objects.values('author').distinct()Mise à jour et suppression
update() est efficace pour les modifications en masse. save(update_fields=[...]) évite les conditions de course. delete() supprime en cascade par défaut.
# Bulk update
Article.objects.filter(draft=True).update(draft=False)
# Single update (only save this field)
article.title = 'New Title'
article.save(update_fields=['title'])
# Delete
article.delete() # returns (count, {model: count})
Article.objects.filter(views=0).delete() # bulk deleteORM avancé
Expressions F
F() référence la valeur d'une colonne en base, ce qui permet des mises à jour atomiques sans charger l'objet en Python.
from django.db.models import F
# Atomic increment (no race condition)
Article.objects.filter(pk=1).update(views=F('views') + 1)
# Compare two fields
Article.objects.filter(views__gt=F('min_views'))
# Arithmetic on fields
Article.objects.annotate(ratio=F('views') / F('likes'))Objets Q pour requêtes complexes
Les objets Q permettent la logique OR (|), AND (&) et NOT (~). Sans Q, plusieurs appels à filter() ne combinent que des AND.
from django.db.models import Q
# OR
Article.objects.filter(Q(title__contains='Django') | Q(title__contains='Flask'))
# AND with NOT
Article.objects.filter(Q(published=True) & ~Q(views=0))
# OR + AND
Article.objects.filter(
(Q(author=1) | Q(author=2)) & Q(published=True)
)Agrégation
aggregate() renvoie un dict de totaux. annotate() ajoute des valeurs calculées par objet.
from django.db.models import Count, Sum, Avg, Max, Min
# Single aggregate
total = Article.objects.aggregate(total=Count('id'))
avg_views = Article.objects.aggregate(Avg('views'))
# Per-group aggregate
Author.objects.annotate(
article_count=Count('article'),
total_views=Sum('article__views'),
)Annotate
annotate() ajoute des champs calculés par objet. Vous pouvez filter() et order_by() sur les champs annotés.
from django.db.models import Count, Avg
# Add computed field to each object
authors = Author.objects.annotate(article_count=Count('book'))
# Filter on annotated field
Author.objects.annotate(
avg_rating=Avg('book__rating')
).filter(avg_rating__gte=4.0)select_related et prefetch_related
select_related utilise un JOIN SQL (FK directe). prefetch_related utilise une seconde requête (inverse/M2M). Les deux évitent les requêtes N+1.
# select_related (FK/OneToOne - single query with JOIN)
books = Book.objects.select_related('author').all()
# book.author.name -> no extra query
# prefetch_related (M2M/reverse - second query)
authors = Author.objects.prefetch_related('books').all()
# author.books.all() -> no extra query
# Deep prefetch
Author.objects.prefetch_related('books', 'books__reviews').all()Vues par fonctions
Vue fonction de base
Une view reçoit un HttpRequest et renvoie une HttpResponse. render() charge un template et le remplit avec le contexte.
from django.shortcuts import render
from django.http import HttpResponse
def hello(request):
return HttpResponse("Hello, World!")
def home(request):
context = {'title': 'Home', 'items': [1, 2, 3]}
return render(request, 'home.html', context)Objet HttpRequest
request.GET/POST sont des QueryDict (utilisez .get() par sécurité). request.user est l'utilisateur authentifié ou AnonymousUser.
def my_view(request):
method = request.method # 'GET' or 'POST'
get_data = request.GET.get('q') # query param
post_data = request.POST.get('name')
path = request.path # '/articles/1/'
user = request.user # current user
files = request.FILES # uploaded files
meta = request.META.get('HTTP_HOST')Types de HttpResponse
JsonResponse sérialise en JSON. redirect() accepte un chemin d'URL ou une URL nommée avec ses arguments.
from django.http import HttpResponse, JsonResponse
from django.shortcuts import redirect
def json_view(request):
return JsonResponse({'status': 'ok', 'count': 42})
def redirect_view(request):
return redirect('/home/')
return redirect('article_detail', pk=1)
def csv_view(request):
response = HttpResponse(content_type='text/csv')
response['Content-Disposition'] = 'attachment; filename="data.csv"'
return responseDécorateurs de vue
login_required redirige les utilisateurs non authentifiés vers LOGIN_URL. require_POST/GET restreignent les méthodes HTTP.
from django.contrib.auth.decorators import login_required
from django.views.decorators.http import require_POST, require_GET
@login_required
def dashboard(request):
return render(request, 'dashboard.html')
@require_POST
def submit(request):
pass # Only accepts POST
@require_GET
def search(request):
pass # Only accepts GETVue d'upload de fichiers
request.FILES contient les fichiers envoyés. Utilisez .chunks() pour les gros fichiers afin d'éviter de tout charger en mémoire.
def upload_file(request):
if request.method == 'POST':
uploaded = request.FILES['file']
Document.objects.create(file=uploaded)
# Or save manually
with open(f'media/{uploaded.name}', 'wb') as f:
for chunk in uploaded.chunks():
f.write(chunk)
return redirect('success')
return render(request, 'upload.html')Vues par classes
TemplateView
TemplateView affiche un template statique. Surchargez get_context_data() pour ajouter du contexte supplémentaire.
from django.views.generic import TemplateView
class AboutView(TemplateView):
template_name = 'about.html'
def get_context_data(self, **kwargs):
context = super().get_context_data(**kwargs)
context['title'] = 'About Us'
return contextListView
ListView pagine automatiquement et fournit object_list et page_obj dans le contexte. Surchargez get_queryset() pour filtrer.
from django.views.generic import ListView
class ArticleListView(ListView):
model = Article
template_name = 'article_list.html'
context_object_name = 'articles'
paginate_by = 10
def get_queryset(self):
return Article.objects.filter(published=True)DetailView
DetailView récupère un objet unique par pk ou slug depuis l'URL. Surchargez get_object() pour une récupération personnalisée.
from django.views.generic import DetailView
class ArticleDetailView(DetailView):
model = Article
template_name = 'article_detail.html'
context_object_name = 'article'
def get_object(self):
return Article.objects.get(
slug=self.kwargs['slug'], published=True
)CreateView et UpdateView
CreateView/UpdateView gèrent l'affichage du formulaire, la validation et l'enregistrement. Surchargez form_valid() pour ajouter une logique avant l'enregistrement.
from django.views.generic.edit import CreateView, UpdateView
class ArticleCreateView(CreateView):
model = Article
fields = ['title', 'body', 'author']
template_name = 'article_form.html'
success_url = '/articles/'
class ArticleUpdateView(UpdateView):
model = Article
fields = ['title', 'body']
template_name = 'article_form.html'Mixins
Les mixins ajoutent un comportement réutilisable aux vues par classes. Django fournit LoginRequiredMixin et PermissionRequiredMixin.
from django.contrib.auth.mixins import LoginRequiredMixin
class OwnerRequiredMixin:
def get_queryset(self):
return super().get_queryset().filter(owner=self.request.user)
class ArticleListView(LoginRequiredMixin, OwnerRequiredMixin, ListView):
model = Article
paginate_by = 10Routage des URLs
Configuration d'URL de base
path() associe un motif d'URL à une vue. name= permet la recherche d'URL inverse. <int:pk> capture un entier.
from django.urls import path
from myapp import views
urlpatterns = [
path('', views.home, name='home'),
path('about/', views.about, name='about'),
path('article/<int:pk>/', views.article_detail, name='article_detail'),
]Inclure les URLs d'une app
include() délègue la correspondance d'URL au urls.py d'une app. app_name crée un namespace pour la génération inverse d'URL.
# myproject/urls.py
from django.urls import path, include
urlpatterns = [
path('admin/', admin.site.urls),
path('blog/', include('blog.urls')),
path('api/', include('api.urls')),
]
# blog/urls.py
app_name = 'blog'
urlpatterns = [
path('', views.list, name='list'),
path('<int:pk>/', views.detail, name='detail'),
]Convertisseurs de chemin
Les convertisseurs de chemin convertissent automatiquement les segments d'URL. Utilisez re_path pour les motifs regex complexes.
path('article/<int:pk>/') # integer
path('article/<slug:slug>/') # slug string
path('article/<str:title>/') # non-slash string
path('user/<uuid:user_id>/') # UUID
path('file/<path:filepath>/') # any string including /
# Regex path (re_path)
from django.urls import re_path
re_path(r'^article/(?P<year>[0-9]{4})/$', views.year_archive)URLs nommées et reverse()
Les URLs nommées permettent de référencer les routes par leur nom au lieu de coder les chemins en dur. reverse() génère les URLs en Python.
# urls.py
path('article/<int:pk>/', views.detail, name='article_detail')
# In views.py
from django.urls import reverse
url = reverse('article_detail', kwargs={'pk': 42})
# Returns '/article/42/'
# In templates
<a href="{% url 'article_detail' pk=article.pk %}">Read</a>Namespaces d'URL
Les namespaces évitent les collisions de noms entre apps. Le namespace doit correspondre au app_name de l'app.
# myproject/urls.py
path('blog/', include(('blog.urls', 'blog'), namespace='blog'))
# blog/urls.py
app_name = 'blog'
urlpatterns = [
path('<int:pk>/', views.detail, name='detail'),
]
# Usage
reverse('blog:detail', kwargs={'pk': 1})
# Template: {% url 'blog:detail' pk=1 %}Templates (DTL)
Héritage de templates
extends hérite d'un template de base. Les blocks définissent des zones remplaçables. Un template ne peut hériter que d'un seul parent.
{# base.html #}
<html>
<body>
{% block content %}{% endblock %}
{% block sidebar %}{% endblock %}
</body>
</html>
{# article.html #}
{% extends 'base.html' %}
{% block content %}
<h1>{{ article.title }}</h1>
{% endblock %}Variables et tags
{{ }} affiche les variables. {% %} exécute les tags. forloop.counter commence à 1 ; forloop.counter0 à 0.
{# Variables #}
{{ article.title }}
{{ user.get_full_name }}
{{ article.tags.0 }}
{# Tags #}
{% if article.published %}
Published
{% elif article.draft %}
Draft
{% else %}
Archived
{% endif %}
{% for item in items %}
{{ forloop.counter }}: {{ item }}
{% empty %}
No items
{% endfor %}Filtres de template
Les filtres modifient la sortie des variables via la syntaxe pipe |. Certains acceptent des arguments après deux points. Les filtres peuvent s'enchaîner.
{{ name|lower }}
{{ text|truncatewords:30 }}
{{ date|date:"Y-m-d" }}
{{ value|default:"N/A" }}
{{ list|length }}
{{ text|striptags }}
{{ price|floatformat:2 }}
{{ value|add:5 }}Tags de template intégrés
csrf_token est obligatoire dans tous les formulaires POST. include affiche un sous-template. load importe des bibliothèques de tags personnalisées.
{% url 'article_detail' pk=1 %}
{% csrf_token %}
{% load static %}
{% include 'header.html' %}
{% with total=items|length %}
{{ total }}
{% endwith %}
{% now "Y-m-d" %}
{% blocktrans %}Hello{% endblocktrans %}Tags de template personnalisés
Les tags vivent dans le répertoire app/templatetags/. @register.simple_tag pour les fonctions ; @register.filter pour les modificateurs de valeur.
# templatetags/my_tags.py
from django import template
register = template.Library()
@register.simple_tag
def multiply(a, b):
return a * b
@register.filter
def cut(value, arg):
return value.replace(arg, '')
# In template:
{% load my_tags %}
{% multiply 3 4 %}
{{ "hello world"|cut:" " }}Formulaires
Définir un formulaire
forms.Form crée un formulaire autonome. Chaque champ génère automatiquement les widgets HTML. Les types de champs assurent la validation.
from django import forms
class ContactForm(forms.Form):
name = forms.CharField(max_length=100)
email = forms.EmailField()
message = forms.CharField(widget=forms.Textarea)
subject = forms.ChoiceField(
choices=[('general', 'General'), ('bug', 'Bug Report')],
)ModelForm
ModelForm construit automatiquement un formulaire à partir d'un modèle. fields/exclude contrôlent les champs affichés. widgets personnalise le HTML.
class ArticleForm(forms.ModelForm):
class Meta:
model = Article
fields = ['title', 'body', 'author']
# Or: fields = '__all__'
# Or: exclude = ['created_at']
widgets = {
'body': forms.Textarea(attrs={'rows': 10}),
}
labels = {'title': 'Article Title'}Validation de formulaire
clean_<field>() valide un champ unique. clean() valide le formulaire entier. Levez ValidationError en cas d'échec.
class SignupForm(forms.Form):
username = forms.CharField(max_length=50)
password = forms.CharField(widget=forms.PasswordInput)
def clean_username(self):
username = self.cleaned_data['username']
if User.objects.filter(username=username).exists():
raise forms.ValidationError("Username taken.")
return username
def clean(self):
cleaned = super().clean()
# Cross-field validation
return cleanedAfficher le formulaire dans un template
as_p/as_table/as_ul affichent tous les champs automatiquement. Pour une mise en page personnalisée, affichez les champs un par un. csrf_token est obligatoire en POST.
<form method="post">
{% csrf_token %}
{{ form.as_p }}
{{ form.as_table }}
{{ form.as_ul }}
{# Manual rendering #}
{{ form.title.label_tag }}
{{ form.title }}
{{ form.title.errors }}
<button type="submit">Submit</button>
</form>Traiter le formulaire dans une vue
Passez request.POST pour lier le formulaire. is_valid() lance la validation. save(commit=False) renvoie un objet non enregistré.
def article_create(request):
if request.method == 'POST':
form = ArticleForm(request.POST)
if form.is_valid():
article = form.save(commit=False)
article.author = request.user
article.save()
form.save_m2m()
return redirect('article_detail', pk=article.pk)
else:
form = ArticleForm()
return render(request, 'form.html', {'form': form})Widgets de formulaire
widgets contrôle le rendu HTML. Passez un dict attrs pour les classes CSS, les placeholders ou les types d'input HTML5.
class UploadForm(forms.Form):
title = forms.CharField(
widget=forms.TextInput(attrs={'class': 'form-control'})
)
file = forms.FileField(widget=forms.ClearableFileInput)
date = forms.DateField(widget=forms.DateInput(attrs={'type': 'date'}))
tags = forms.MultipleChoiceField(
choices=TAG_CHOICES,
widget=forms.CheckboxSelectMultiple,
)Site d'administration
Enregistrer un modèle dans l'admin
@admin.register est préférable à admin.site.register. Les modèles doivent être enregistrés pour apparaître dans l'interface d'admin.
from django.contrib import admin
from .models import Article
# Simple registration
admin.site.register(Article)
# With custom ModelAdmin
@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
list_display = ('title', 'author', 'published')Personnalisation de ModelAdmin
list_display affiche les colonnes de la vue liste. list_filter ajoute des filtres latéraux. search_fields active une zone de recherche.
@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
list_display = ('title', 'author', 'status')
list_filter = ('status', 'author', 'created_at')
search_fields = ('title', 'body')
ordering = ('-created_at',)
list_editable = ('status',)
list_per_page = 25
date_hierarchy = 'created_at'
readonly_fields = ('views', 'created_at')Admin avec inlines
Les inlines permettent de modifier les modèles liés sur la même page que le parent. extra=1 affiche une ligne vide par défaut.
class ReviewInline(admin.TabularInline):
model = Review
extra = 1
@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
inlines = [ReviewInline]
# TabularInline: compact table format
# StackedInline: full form fields stackedActions d'admin personnalisées
Les actions apparaissent dans le menu déroulant de la page liste. Elles reçoivent request et queryset. message_user affiche un message flash.
@admin.register(Article)
class ArticleAdmin(admin.ModelAdmin):
actions = ['publish_selected']
@admin.action(description='Publish selected')
def publish_selected(self, request, queryset):
updated = queryset.update(published=True)
self.message_user(request, f'{updated} articles published.')Configuration du site d'admin
Surchargez site_header/site_title pour la personnalisation. Pour plusieurs sites d'admin, créez des instances d'AdminSite personnalisées.
admin.site.site_header = 'My Site Admin'
admin.site.site_title = 'Admin Portal'
admin.site.index_title = 'Dashboard'
# Custom admin site
from django.contrib.admin import AdminSite
my_site = AdminSite(name='myadmin')
my_site.register(Article, ArticleAdmin)
# urls.py
path('myadmin/', my_site.urls)Authentification
Modèle User intégré
Le modèle User de Django comporte username, password (haché), email, first_name, last_name et des indicateurs de permissions.
from django.contrib.auth.models import User
user = User.objects.get(username='admin')
user.is_staff # can access admin
user.is_superuser # has all permissions
user.is_active # account enabled
user.set_password('newpass') # hash password
user.save()
user.check_password('secret') # returns True/FalseConnexion et déconnexion
authenticate() vérifie les identifiants (renvoie un User ou None). login() crée la session. logout() la supprime.
from django.contrib.auth import authenticate, login, logout
def login_view(request):
user = authenticate(request, username='admin', password='pass')
if user is not None:
login(request, user)
return redirect('dashboard')
return render(request, 'login.html')
def logout_view(request):
logout(request)
return redirect('home')Inscription des utilisateurs
UserCreationForm gère username, password et la confirmation du mot de passe avec une validation intégrée.
from django.contrib.auth.forms import UserCreationForm
def register(request):
if request.method == 'POST':
form = UserCreationForm(request.POST)
if form.is_valid():
user = form.save()
login(request, user) # auto-login after register
return redirect('home')
else:
form = UserCreationForm()
return render(request, 'register.html', {'form': form})Décorateur login_required
login_required redirige vers LOGIN_URL (/accounts/login/ par défaut). Pour les CBV, utilisez LoginRequiredMixin.
from django.contrib.auth.decorators import login_required
@login_required
def profile(request):
return render(request, 'profile.html')
@login_required(login_url='/custom-login/')
def settings(request):
return render(request, 'settings.html')
# Class-based view mixin
from django.contrib.auth.mixins import LoginRequiredMixin
class DashboardView(LoginRequiredMixin, ListView):
login_url = '/login/'
model = ArticleGestion des mots de passe
update_session_auth_hash évite la déconnexion après un changement de mot de passe. Les validateurs de mot de passe imposent des règles sur tout le site.
from django.contrib.auth import update_session_auth_hash
# Change password
user.set_password('newpass123')
user.save()
update_session_auth_hash(request, user) # keep user logged in
# Using form
from django.contrib.auth.forms import PasswordChangeForm
form = PasswordChangeForm(user, request.POST)
if form.is_valid():
form.save()Modèle User personnalisé
Héritez d'AbstractUser pour ajouter des champs. Définissez AUTH_USER_MODEL tôt — le changer plus tard est difficile.
from django.contrib.auth.models import AbstractUser
class CustomUser(AbstractUser):
bio = models.TextField(blank=True)
avatar = models.ImageField(upload_to='avatars/', blank=True)
phone = models.CharField(max_length=20, blank=True)
# settings.py
AUTH_USER_MODEL = 'myapp.CustomUser'
# Admin
from django.contrib.auth.admin import UserAdmin
@admin.register(CustomUser)
class CustomUserAdmin(UserAdmin):
passMiddleware
Middleware intégrés
L'ordre compte ! SecurityMiddleware en premier, puis les sessions, puis l'auth. Les vérifications CSRF s'exécutent avant le traitement de la vue.
MIDDLEWARE = [
'django.middleware.security.SecurityMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.common.CommonMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
'django.middleware.clickjacking.XFrameOptionsMiddleware',
]Middleware fonction personnalisé
Le middleware fonctionnel suit le nouveau pattern de factory. get_response appelle le middleware suivant ou la vue.
def simple_middleware(get_response):
def middleware(request):
# Code before view (request phase)
response = get_response(request)
# Code after view (response phase)
return response
return middleware
# Example: timing middleware
import time
def timing_middleware(get_response):
def middleware(request):
start = time.time()
response = get_response(request)
response['X-Duration'] = str(time.time() - start)
return response
return middlewareMiddleware par classes
__init__ s'exécute une fois au démarrage. __call__ s'exécute à chaque requête. process_view peut renvoyer une réponse pour court-circuiter la vue.
class MyMiddleware:
def __init__(self, get_response):
self.get_response = get_response
def __call__(self, request):
# Request phase (before view)
response = self.get_response(request)
# Response phase (after view)
return response
def process_view(self, request, view_func, args, kwargs):
return None # or HttpResponse to short-circuitOrdre et flux des middleware
Les requêtes traversent les middleware de haut en bas ; les remontées de réponses vont de bas en haut. Placez le middleware de sécurité en premier.
# Request phase: top to bottom
# Response phase: bottom to top
MIDDLEWARE = [
'A', # req: 1st -> resp: last
'B', # req: 2nd -> resp: 2nd
'C', # req: 3rd -> resp: 1st
]
# Request flows: A -> B -> C -> view
# Response flows: view -> C -> B -> ACas d'usage des middleware
Un middleware peut court-circuiter (renvoyer une HttpResponse tôt) ou attacher des données à request pour les vues.
# IP restriction
class IPBlockMiddleware:
BLOCKED_IPS = ['192.168.1.100']
def __call__(self, request):
if request.META['REMOTE_ADDR'] in self.BLOCKED_IPS:
return HttpResponseForbidden('Blocked')
return self.get_response(request)
# Add context to request
class UserPrefMiddleware:
def __call__(self, request):
request.is_mobile = 'Mobile' in request.META.get('HTTP_USER_AGENT', '')
return self.get_response(request)Fichiers statiques et médias
Configuration des fichiers statiques
STATIC_URL est le préfixe d'URL. STATICFILES_DIRS sont les emplacements sources (dev). STATIC_ROOT est la destination de collecte en production.
# settings.py
STATIC_URL = '/static/'
STATICFILES_DIRS = [BASE_DIR / 'static'] # dev location
STATIC_ROOT = BASE_DIR / 'staticfiles' # collectstatic output
# Project structure:
# static/
# css/style.css
# js/app.js
# img/logo.pngServir les statiques en développement
Django ne sert les fichiers statiques automatiquement que si DEBUG=True. En production, utilisez un serveur web (nginx) ou WhiteNoise.
# urls.py (dev only)
from django.conf import settings
from django.conf.urls.static import static
urlpatterns = [
path('admin/', admin.site.urls),
] + static(settings.STATIC_URL, document_root=settings.STATIC_ROOT)
# Only active when DEBUG=TrueUtiliser les statiques dans les templates
{% load static %} est obligatoire. {% static %} résout vers le nom de fichier haché en production avec ManifestStaticFilesStorage.
{% load static %}
<link rel="stylesheet" href="{% static 'css/style.css' %}">
<img src="{% static 'img/logo.png' %}" alt="Logo">
<script src="{% static 'js/app.js' %}"></script>
{# Dynamic static path #}
{% get_static_prefix as STATIC_URL %}
<img src="{{ STATIC_URL }}img/{{ theme }}.png">Configuration des fichiers médias
MEDIA_ROOT est le chemin système ; MEDIA_URL est le préfixe d'URL. upload_to peut être une chaîne de chemin ou un callable.
# settings.py
MEDIA_URL = '/media/'
MEDIA_ROOT = BASE_DIR / 'media'
# urls.py (dev)
urlpatterns += static(settings.MEDIA_URL, document_root=settings.MEDIA_ROOT)
# Model with file upload
class Document(models.Model):
file = models.FileField(upload_to='documents/')
image = models.ImageField(upload_to='images/')
# Access
doc.file.url # '/media/documents/file.pdf'
doc.file.path # '/full/path/to/file.pdf'Commande collectstatic
Lancez collectstatic avant le déploiement. WhiteNoise permet à Django de servir les fichiers statiques en production sans nginx.
# Collect all static files into STATIC_ROOT
python manage.py collectstatic
# With clearing
python manage.py collectstatic --clear
# Production with WhiteNoise
# pip install whitenoise
MIDDLEWARE = [..., 'whitenoise.middleware.WhiteNoiseMiddleware', ...]
STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'Signals
Signals intégrés
Les signals permettent à des apps découplées de réagir à des actions. post_save se déclenche après la fin de save() ; pre_save avant.
from django.db.models.signals import (
post_save, pre_save, post_delete, pre_delete,
m2m_changed,
)
from django.contrib.auth.signals import (
user_logged_in, user_logged_out,
)
# Common signals:
# pre_save / post_save - before/after model save
# pre_delete / post_delete - before/after model delete
# m2m_changed - M2M relationship changes
# user_logged_in / user_logged_outConnecter des récepteurs de signal
@receiver relie la fonction au signal. sender limite au modèle indiqué. created vaut True uniquement pour les nouveaux objets.
from django.db.models.signals import post_save
from django.dispatch import receiver
@receiver(post_save, sender=User)
def create_profile(sender, instance, created, **kwargs):
if created:
Profile.objects.create(user=instance)
@receiver(post_save, sender=User)
def save_profile(sender, instance, **kwargs):
instance.profile.save()Déconnecter des signals
disconnect() est utile en tests ou pour empêcher des actions en cascade. Fournissez toujours à la fois le receiver et le sender.
from django.db.models.signals import post_save
# Disconnect
post_save.disconnect(
receiver=create_profile,
sender=User,
)
# Temporarily disconnect in tests
post_save.disconnect(handler, sender=Article)
# ... do stuff without signal ...
post_save.connect(handler, sender=Article)Signals personnalisés
Définissez les signals au niveau du module. send() notifie tous les récepteurs. Les kwargs sont transmis à tous les récepteurs connectés.
from django.dispatch import Signal, receiver
# Define a custom signal
order_created = Signal()
# Send the signal
order_created.send(
sender=Order,
order=order_instance,
user=request.user,
)
# Receive
@receiver(order_created, sender=Order)
def send_notification(sender, order, user, **kwargs):
pass # Send email notificationCas d'usage et pièges des signals
Importez les gestionnaires de signals dans AppConfig.ready() pour qu'ils se connectent au démarrage. Évitez les opérations lentes — utilisez Celery pour l'asynchrone.
# Good: Profile auto-creation
@receiver(post_save, sender=User)
def ensure_profile(sender, instance, created, **kwargs):
if created:
Profile.objects.get_or_create(user=instance)
# Register in AppConfig.ready()
# apps.py
class MyAppConfig(AppConfig):
name = 'myapp'
def ready(self):
from . import signals # noqaCache
Configuration du cache
Redis est recommandé en production. LocMemCache est propre au processus (pas de partage entre workers).
# settings.py - Memcached
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.memcached.PyMemcacheCache',
'LOCATION': '127.0.0.1:11211',
}
}
# Redis
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.redis.RedisCache',
'LOCATION': 'redis://127.0.0.1:6379',
}
}
# Local memory (dev)
CACHES = {
'default': {'BACKEND': 'django.core.cache.backends.locmem.LocMemCache'}
}API de cache bas niveau
cache.get() renvoie None pour les clés absentes. Utilisez get_or_set pour créer la clé si absente, de façon atomique.
from django.core.cache import cache
# Set
cache.set('key', 'value', timeout=300) # 5 minutes
cache.set_many({'a': 1, 'b': 2}, timeout=60)
# Get
value = cache.get('key') # None if missing
value = cache.get('key', 'default') # with default
data = cache.get_many(['a', 'b']) # dict
# Delete
cache.delete('key')
cache.clear() # delete all
# get_or_set (atomic)
value = cache.get_or_set('key', 'value', 300)Cache de template
{% cache %} stocke des fragments HTML rendus. Ajoutez des arguments variables (ID utilisateur, page) pour éviter un contenu en cache erroné.
{% load cache %}
{# Cache block for 500 seconds #}
{% cache 500 sidebar %}
<div class="sidebar">
{{ expensive_data }}
</div>
{% endcache %}
{# Cache with varying key #}
{% cache 500 user_sidebar request.user.id %}
Welcome, {{ request.user.username }}
{% endcache %}Cache par vue
cache_page met en cache l'intégralité de la HttpResponse. La clé de cache inclut l'URL, donc chaque URL a sa propre entrée.
from django.views.decorators.cache import cache_page
@cache_page(60 * 15)
def article_list(request):
return render(request, 'list.html', {'articles': Article.objects.all()})
# With cache key prefix
@cache_page(60 * 15, key_prefix='articles')
def article_detail(request, pk):
...
# Class-based view
from django.utils.decorators import method_decorator
class ArticleListView(ListView):
@method_decorator(cache_page(60 * 15))
def dispatch(self, *args, **kwargs):
return super().dispatch(*args, **kwargs)Stratégies de cache
vary_on_headers crée des entrées de cache distinctes par valeur d'en-tête. Pour les API, variez selon Accept-Language ou Authorization.
# Per-view cache with Vary headers
from django.views.decorators.vary import vary_on_headers
@cache_page(60 * 15)
@vary_on_headers('User-Agent')
def api_data(request):
...
# Model-level caching
def get_articles():
articles = cache.get('all_articles')
if articles is None:
articles = list(Article.objects.all())
cache.set('all_articles', articles, 300)
return articlesTests
Écrire des tests
TestCase enveloppe chaque test dans une transaction de base (annulée ensuite). SimpleTestCase sert aux tests sans accès à la base (plus rapide).
from django.test import TestCase, SimpleTestCase
from .models import Article
class ArticleModelTest(TestCase):
def setUp(self):
self.article = Article.objects.create(
title='Test', body='Content'
)
def test_str(self):
self.assertEqual(str(self.article), 'Test')
def test_field_default(self):
self.assertEqual(self.article.views, 0)
# SimpleTestCase: no DB access
class MathTest(SimpleTestCase):
def test_addition(self):
self.assertEqual(1 + 1, 2)Tester avec le client de test
self.client simule des requêtes HTTP sans démarrer de serveur. .login() authentifie pour les requêtes suivantes.
class ViewTest(TestCase):
def setUp(self):
self.user = User.objects.create_user('test', '[email protected]', 'pass')
def test_login(self):
response = self.client.post('/login/', {
'username': 'test', 'password': 'pass'
})
self.assertEqual(response.status_code, 302)
def test_protected_view(self):
self.client.login(username='test', password='pass')
response = self.client.get('/dashboard/')
self.assertEqual(response.status_code, 200)Tests de modèles et de QuerySets
Les données de test sont créées dans setUp() et annulées après chaque test. Utilisez .count() et l'indexation pour vérifier les résultats.
class ArticleQuerySetTest(TestCase):
def setUp(self):
Article.objects.create(title='A', views=100, published=True)
Article.objects.create(title='B', views=50, published=False)
def test_published_filter(self):
published = Article.objects.filter(published=True)
self.assertEqual(published.count(), 1)
def test_ordering(self):
articles = Article.objects.order_by('-views')
self.assertEqual(articles[0].title, 'A')Tests d'URL et de formulaires
reverse() construit les URLs à partir des noms. resolve() vérifie quelle vue correspond à une URL. Testez les formulaires en passant un dict data=.
from django.urls import reverse, resolve
class URLTest(TestCase):
def test_article_list_url(self):
url = reverse('article_list')
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
def test_resolve(self):
url = reverse('article_detail', kwargs={'pk': 1})
self.assertEqual(resolve(url).func, views.article_detail)
class FormTest(TestCase):
def test_valid_form(self):
form = ArticleForm(data={'title': 'Hi', 'body': '...'})
self.assertTrue(form.is_valid())Fixtures et commandes de test
Les fixtures chargent des données de test depuis des fichiers JSON. Lancez des tests précis par chemin d'app, de classe ou de méthode.
# Create fixture
python manage.py dumpdata myapp.Article --indent=2 > fixtures/articles.json
# Use in test
class FixtureTest(TestCase):
fixtures = ['articles.json']
def test_data_loaded(self):
self.assertEqual(Article.objects.count(), 10)
# Run tests
python manage.py test
python manage.py test myapp
python manage.py test myapp.tests.ArticleModelTestDjango REST Framework
Installer et configurer DRF
Ajoutez rest_framework à INSTALLED_APPS. Configurez l'authentification et les permissions par défaut dans le dict de settings REST_FRAMEWORK.
pip install djangorestframework
# settings.py
INSTALLED_APPS = [..., 'rest_framework', 'rest_framework.authtoken']
REST_FRAMEWORK = {
'DEFAULT_AUTHENTICATION_CLASSES': [
'rest_framework.authentication.TokenAuthentication',
'rest_framework.authentication.SessionAuthentication',
],
'DEFAULT_PERMISSION_CLASSES': [
'rest_framework.permissions.IsAuthenticated',
],
}Serializers
ModelSerializer génère les champs à partir du modèle. source= lit depuis des objets liés. validate_<field>() ajoute une validation.
from rest_framework import serializers
class ArticleSerializer(serializers.ModelSerializer):
author_name = serializers.CharField(source='author.username', read_only=True)
class Meta:
model = Article
fields = ['id', 'title', 'body', 'author', 'author_name']
read_only_fields = ['id', 'author_name']
def validate_title(self, value):
if len(value) < 5:
raise serializers.ValidationError("Title too short.")
return valueViewSets
ModelViewSet fournit le CRUD (list, create, retrieve, update, destroy). Surchargez get_queryset() pour filtrer.
from rest_framework import viewsets, permissions
class ArticleViewSet(viewsets.ModelViewSet):
queryset = Article.objects.all()
serializer_class = ArticleSerializer
permission_classes = [permissions.IsAuthenticatedOrReadOnly]
def get_queryset(self):
qs = super().get_queryset()
author = self.request.query_params.get('author')
if author:
qs = qs.filter(author__username=author)
return qs
def perform_create(self, serializer):
serializer.save(author=self.request.user)Routers
DefaultRouter génère automatiquement les motifs d'URL et une vue racine d'API. basename sert au nommage des URLs si le queryset est dynamique.
from rest_framework.routers import DefaultRouter
from .views import ArticleViewSet
router = DefaultRouter()
router.register(r'articles', ArticleViewSet, basename='article')
# router.register(r'users', UserViewSet)
# urls.py
urlpatterns = [
path('api/', include(router.urls)),
]
# Generates: /api/articles/, /api/articles/{id}/Authentification
L'auth par token utilise un token statique unique. JWT émet des tokens access + refresh. SimpleJWT est la bibliothèque JWT la plus répandue.
# Token Authentication
from rest_framework.authtoken.views import obtain_auth_token
urlpatterns = [
path('api/token/', obtain_auth_token),
]
# JWT Authentication (pip install djangorestframework-simplejwt)
from rest_framework_simplejwt.views import (
TokenObtainPairView, TokenRefreshView,
)
urlpatterns = [
path('api/token/', TokenObtainPairView.as_view()),
path('api/token/refresh/', TokenRefreshView.as_view()),
]Permissions
SAFE_METHODS correspond à GET/HEAD/OPTIONS. has_object_permission vérifie l'accès par objet. get_permissions() permet des règles par action.
from rest_framework import permissions
class IsOwnerOrReadOnly(permissions.BasePermission):
def has_object_permission(self, request, view, obj):
if request.method in permissions.SAFE_METHODS:
return True # GET, HEAD, OPTIONS
return obj.author == request.user
# Built-in: IsAuthenticated, IsAdminUser,
# IsAuthenticatedOrReadOnly, AllowAny
# Per-action
class ArticleViewSet(viewsets.ModelViewSet):
permission_classes = [IsOwnerOrReadOnly]
def get_permissions(self):
if self.action == 'create':
return [permissions.IsAuthenticated()]
return super().get_permissions()Déploiement et sécurité
Réglages de production
Ne commitez jamais SECRET_KEY dans le gestionnaire de versions. Utilisez des variables d'environnement. DEBUG=False évite les fuites d'informations dans les pages d'erreur.
# settings.py
DEBUG = False
ALLOWED_HOSTS = ['example.com', 'www.example.com']
SECRET_KEY = os.environ['SECRET_KEY']
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.postgresql',
'NAME': 'mydb',
'USER': os.environ['DB_USER'],
'PASSWORD': os.environ['DB_PASS'],
'HOST': 'localhost',
'PORT': '5432',
}
}Fichiers statiques en production
collectstatic rassemble tous les fichiers statiques dans STATIC_ROOT. WhiteNoise sert des fichiers compressés et hachés depuis Django lui-même.
# Collect static files
python manage.py collectstatic --noinput
# WhiteNoise for serving static
MIDDLEWARE = [..., 'whitenoise.middleware.WhiteNoiseMiddleware', ...]
STATICFILES_STORAGE = 'whitenoise.storage.CompressedManifestStaticFilesStorage'
# Or with nginx:
# location /static/ { alias /path/to/staticfiles/; }Réglages de sécurité
SSL_REDIRECT force le HTTPS. HSTS demande aux navigateurs de toujours utiliser HTTPS. X_FRAME_OPTIONS prévient le clickjacking.
# settings.py
SECURE_SSL_REDIRECT = True
SESSION_COOKIE_SECURE = True
CSRF_COOKIE_SECURE = True
SECURE_HSTS_SECONDS = 31536000
SECURE_HSTS_INCLUDE_SUBDOMAINS = True
SECURE_HSTS_PRELOAD = True
SECURE_CONTENT_TYPE_NOSNIFF = True
X_FRAME_OPTIONS = 'DENY'
CSRF_TRUSTED_ORIGINS = ['https://example.com']Déploiement WSGI/ASGI
Gunicorn est synchrone (Django traditionnel). Uvicorn prend en charge ASGI (vues async, websockets). Utilisez un gestionnaire de processus.
# Gunicorn (WSGI)
# pip install gunicorn
gunicorn myproject.wsgi:application --bind 0.0.0.0:8000 --workers 3
# Uvicorn (ASGI, for async/websockets)
# pip install uvicorn
uvicorn myproject.asgi:application --host 0.0.0.0 --port 8000 --workers 4
# Supervisor config
[program:django]
command=gunicorn myproject.wsgi:application
directory=/app
autostart=true
autorestart=trueChecklist de production
check --deploy exécute la checklist de déploiement de Django. Il signale les réglages de sécurité manquants et les problèmes de mise en production.
# Run security check
python manage.py check --deploy
# Key items:
# - DEBUG = False
# - ALLOWED_HOSTS set
# - SECRET_KEY from env
# - HTTPS enabled (SECURE_SSL_REDIRECT)
# - HSTS configured
# - collectstatic run
# - Database (PostgreSQL/MySQL)
# - Caching (Redis/Memcached)
# - Error monitoring (Sentry)Snippets Django associés
Copy-paste ready code for common tasks.
Model Definition
Define a Django model with field types and meta options.
ORM QuerySet
Filter, exclude, annotate and chain QuerySets.
Class-Based Views
Use generic class-based views for common CRUD flows.
URL Routing
Wire URLs to views with path converters and includes.
ModelForms
Build forms from models with validation and widgets.
Template Tags
Use built-in tags and filters in Django templates.
Admin Customization
Customize the Django admin with list_display and actions.
Authentication
Login, logout, and protect views with auth decorators.
Was this helpful?