Les URL patterns dans Django

Comment Django route une requête

Quand un navigateur envoie une requête à votre application, Django consulte le fichier urls.py du projet pour trouver quelle vue doit répondre. Il parcourt la liste urlpatterns de haut en bas et s'arrête à la première correspondance. Si aucune URL ne correspond, Django renvoie une erreur 404.

Le fichier urls.py principal se trouve dans le dossier du projet (monprojet/urls.py). Chaque application peut avoir son propre urls.py — le projet principal lui délègue alors un préfixe via include().

La fonction path() — syntaxe de base

path() est la fonction principale pour déclarer une URL. Elle prend au minimum deux arguments : le chemin URL et la vue à appeler.

from django.contrib import admin
from django.urls import path
from monapp import views

urlpatterns = [
    path('admin/', admin.site.urls),        # Interface d'administration
    path('', views.accueil, name='accueil'), # Page d'accueil → http://localhost:8000/
    path('contact/', views.contact, name='contact'), # → http://localhost:8000/contact/
    path('membres/', views.membres, name='membres'), # → http://localhost:8000/membres/
]

Le troisième argument name= est optionnel mais fortement recommandé. Il donne un nom à l'URL pour pouvoir la référencer ailleurs dans le code sans écrire le chemin en dur — on verra pourquoi c'est utile avec reverse().

Capturer des paramètres dynamiques

Beaucoup d'URLs contiennent des valeurs variables : l'ID d'un article, le slug d'une catégorie, le numéro d'une page. Django capture ces valeurs directement dans le chemin avec des convertisseurs de type entre chevrons.

urlpatterns = [
    # Capture un entier → /membres/3/ appelle detail(request, id=3)
    path('membres/<int:id>/', views.detail, name='detail'),

    # Capture une chaîne (sans slash) → /categorie/python/
    path('categorie/<str:nom>/', views.categorie, name='categorie'),

    # Capture un slug (lettres, chiffres, tirets) → /articles/mon-premier-article/
    path('articles/<slug:titre>/', views.article, name='article'),
]

Les convertisseurs disponibles dans Django :

<int:nom> — capture un entier positif. C'est le plus courant pour les IDs.

<str:nom> — capture n'importe quelle chaîne sans slash. Valeur par défaut si aucun type n'est spécifié.

<slug:nom> — capture une chaîne composée de lettres ASCII, chiffres et tirets. Idéal pour les URLs SEO-friendly.

<uuid:nom> — capture un UUID au format standard (ex. 550e8400-e29b-41d4-a716-446655440000).

<path:nom> — capture une chaîne qui peut contenir des slashes. Utile pour les chemins de fichiers.

La valeur capturée est passée automatiquement à la vue en argument nommé :

from django.http import HttpResponse
from .models import Membres

def detail(request, id):
    # id est passé automatiquement depuis l'URL /membres/3/
    membre = Membres.objects.get(id=id)
    return HttpResponse(f"{membre.prenom} {membre.nom}")

Organiser les URLs avec include()

Dans un projet avec plusieurs applications, regrouper toutes les URLs dans un seul fichier devient vite ingérable. La solution standard : chaque application gère ses propres URLs dans son fichier urls.py, et le projet principal lui délègue un préfixe via include().

# monprojet/urls.py — routeur principal
from django.contrib import admin
from django.urls import include, path

urlpatterns = [
    path('admin/', admin.site.urls),
    # Toute URL commençant par "membres/" → déléguée à membres/urls.py
    path('membres/', include('membres.urls')),
    # Toute URL commençant par "blog/" → déléguée à blog/urls.py
    path('blog/', include('blog.urls')),
]

# membres/urls.py — routeur de l'application
from django.urls import path
from . import views

urlpatterns = [
    path('', views.index, name='index'),            # /membres/
    path('<int:id>/', views.detail, name='detail'), # /membres/3/
    path('ajout/', views.ajout, name='ajout'),       # /membres/ajout/
]

Django concatène le préfixe du projet avec le chemin de l'application. path('membres/', include('membres.urls')) + path('<int:id>/', ...) donne l'URL finale /membres/3/.

Nommer les URLs et utiliser reverse()

Écrire des chemins en dur dans le code est risqué : si vous renommez une URL, tous les liens et redirections qui la mentionnent cassent. Django résout ce problème avec la résolution inverse : vous référencez une URL par son name, Django calcule le chemin réel.

from django.urls import reverse
from django.http import HttpResponseRedirect

def ajouterrecord(request):
    # ... traitement du formulaire ...
    # Redirige vers la vue nommée 'index' sans écrire l'URL en dur
    return HttpResponseRedirect(reverse('index'))

Dans les templates, la balise {% url %} fait la même chose côté HTML :

<!-- Génère /membres/ -->
<a href="{% url 'index' %}">Liste des membres</a>

<!-- Génère /membres/3/ -->
<a href="{% url 'detail' id=membre.id %}">Voir le profil</a>

Si deux applications ont des vues portant le même nom (ex. deux index), Django peut confondre. La solution : les espaces de noms. Déclarez app_name dans le fichier urls.py de l'application et préfixez le nom avec deux-points dans les références :

# membres/urls.py
app_name = 'membres'  # Déclare l'espace de noms

urlpatterns = [
    path('', views.index, name='index'),
]

# Dans un template ou une vue :
# {% url 'membres:index' %}  ou  reverse('membres:index')

Par carabde | Mis à jour le 05 mai 2025