# Documentation Django 5.2.8

# Distribution des URL

Une organisation propre et élégante des URL est un aspect important dans une application web de qualité. Django vous laisse organiser vos URL comme bon vous semble, sans restriction imposée par le système.

Lisez Cool URIs don’t change, par le père du World Wide Web Tim Berners-Lee, pour savoir pourquoi les URL devraient être claires et conviviales.

## Aperçu

Pour organiser les URL d’une application, il s’agit de créer un module Python appelé communément URLconf (configuration d’URL). Le code de ce module est en Python pur et est une correspondance entre expressions de chemins d’URL et fonctions Python (vos vues).

Cette correspondance peut être autant courte que longue. Elle peut faire référence à d’autres correspondances. Et étant donné qu’il s’agit de code Python pur, elle peut être construite dynamiquement.

Django fournit également une façon de traduire les URL en fonction de la langue active. Voir la documentation sur l’internationalisation pour plus d’informations.

## Processus de traitement des requêtes par Django

Quand un utilisateur accède à une page de votre site Django, voici l’algorithme que le système suit pour déterminer quel code Python doit être exécuté :

1. Django identifie le module URLconf racine à utiliser. Par défaut, c’est la valeur attribuée au réglage `ROOT_URLCONF`, mais si la requête `HttpRequest` entrante possède un attribut `urlconf` (défini par intergiciel), sa valeur sera utilisée en lieu et place du réglage `ROOT_URLCONF`.

2. Django charge ce module Python et cherche la variable `urlpatterns`. Ce devrait être une séquence d’instances `django.urls.path()` ou `django.urls.re_path()`.

3. Django parcourt chaque motif d’URL dans l’ordre et s’arrête dès la première correspondance de `path_info` avec l’URL demandée.

4. Une fois qu’un des motifs d’URL correspond, Django importe et appelle la vue correspondante, qui est une fonction Python (ou une vue reposant sur une classe). La vue se voit passer les paramètres suivants :

   - Une instance `HttpRequest`.

   - Si le motif d’URL correspondant ne contient pas de groupes nommés, les correspondances de l’expression régulière sont transmises comme paramètres positionnels.

   - Les paramètres nommés sont formés des parties nommées résultant de la correspondance avec l’expression de chemin indiquée, surchargés par tout paramètre ajouté dans le paramètre facultatif `kwargs` de `django.urls.path()` ou `django.urls.re_path()`.

5. Si aucun motif d’URL ne correspond, ou si une exception est levée durant ce processus, Django appelle une vue d’erreur appropriée. Voir Gestion d’erreur plus bas.

## Exemple

Voici un exemple d’URLconf :

    from django.urls import path

    from . import views

    urlpatterns = [
        path("articles/2003/", views.special_case_2003),
        path("articles/<int:year>/", views.year_archive),
        path("articles/<int:year>/<int:month>/", views.month_archive),
        path("articles/<int:year>/<int:month>/<slug:slug>/", views.article_detail),
    ]

Notes :

- Pour capturer une valeur contenue dans l’URL, utilisez des chevrons.

- Les valeurs capturées peuvent inclure un convertisseur de type. Par exemple, `<int:name>` va capturer un paramètre nombre entier. Si aucun convertisseur n’est donné, l’expression capture n’importe quelle chaîne de caractères, à l’exception du caractère `/`.

- Inutile de préfixer vos URL d’une barre oblique, elles en ont toutes une. Par exemple, écrivez `articles` et non `/articles`.

Exemples de requêtes :

- Une requête vers `/articles/2005/03/` correspondrait à la troisième entrée dans la liste. Django appellerait la fonction `views.month_archive(request, year=2005, month=3)`.

- `/articles/2003/` correspondrait au premier motif de la liste, et non le deuxième, car les motifs sont évalués dans l’ordre, et le premier est le premier à correspondre. Libre à vous d’utiliser l’ordre de définition pour traiter des cas spéciaux comme ici. Ici, Django appellerait la fonction `views.special_case_2003(request)`.

- `/articles/2003` ne correspondrait à aucun motif, car chaque motif nécessite que l’URL se termine par une barre oblique.

- `/articles/2003/03/03/construire-un-site-django/` correspondrait au dernier motif. Django appellerait la fonction `views.article_detail(request, year=2003, month=3, slug="construire-un-site-django")`.

## Convertisseurs de chemin

Les convertisseurs de chemin suivants sont disponibles par défaut :

- `str` - correspond à n’importe quelle chaîne non vide, à l’exception du séparateur de chemin, `'/'`. C’est ce qui est utilisé par défaut si aucun convertisseur n’est indiqué dans l’expression.

- `int` - correspond à zéro ou un autre nombre entier positif. Renvoie le type `int`.

- `slug` - correspond à toute chaîne composée de lettres ou chiffres ASCII, du trait d’union ou du caractère soulignement. Par exemple, `construire-votre-1er-site-django`.

- `uuid` - correspond à un identifiant UUID. Pour empêcher plusieurs URL de correspondre à une même page, les tirets doivent être inclus et les lettres doivent être en minuscules. Par exemple, `075194d3-6885-417e-a8a8-6c931e272f00`. Renvoie une instance `UUID`.

- `path` - correspond à n’importe quelle chaîne non vide, y compris le séparateur de chemin, `'/'`. Cela permet de correspondre à un chemin d’URL complet au lieu d’un segment de chemin d’URL comme avec `str`.

## Inscription de convertisseurs de chemin personnalisés

Pour des scénarios de correspondance plus complexes, vous pouvez définir vos propres convertisseurs de chemin.

Un convertisseur est une classe comprenant ce qui suit :

- Un attribut de classe `regex`, sous forme de chaîne.

- Une méthode `to_python(self, value)` qui gère la conversion de la chaîne interceptée dans le type voulu qui sera transmis à la fonction de vue. Elle doit générer `ValueError` si la valeur reçue ne peut pas être convertie. Une erreur `ValueError` est interprétée comme absence de correspondance et va donc renvoyer une réponse 404 à l’utilisateur, sauf si une correspondance est trouvée avec un autre motif d’URL.

- Une méthode `to_url(self, value)` qui gère la conversion du type Python vers une chaîne à utiliser dans l’URL. Elle doit générer `ValueError` si la valeur reçue ne peut pas être convertie. Une erreur `ValueError` est interprétée comme absence de correspondance, ce qui fait que `reverse()` va produire une exception `NoReverseMatch` sauf si une correspondance est trouvée avec un autre motif d’URL.

Par exemple :

    class FourDigitYearConverter:
        regex = "[0-9]{4}"

        def to_python(self, value):
            return int(value)

        def to_url(self, value):
            return "%04d" % value

Inscrivez des classes de conversion personnalisées dans la configuration d’URL avec `register_converter()`:

    from django.urls import path, register_converter

    from . import converters, views

    register_converter(converters.FourDigitYearConverter, "yyyy")

    urlpatterns = [
        path("articles/2003/", views.special_case_2003),
        path("articles/<yyyy:year>/", views.year_archive),
        ...,
    ]

## Utilisation d’expressions régulières

Si la syntaxe des chemins et convertisseurs n’est pas suffisante pour définir vos motifs d’URL, vous pouvez également utiliser des expressions régulières. Pour ce faire, utilisez `re_path()` à la place de `path()`.

La syntaxe des expressions régulières en Python pour les groupes de captures nommés est `(?P<nom>motif)`, où `nom` est le nom du groupe et `motif` est le motif à faire correspondre.

Voici de nouveau l’exemple de configuration d’URL précédent, réécrit en utilisant des expressions régulières :

    from django.urls import path, re_path

    from . import views

    urlpatterns = [
        path("articles/2003/", views.special_case_2003),
        re_path(r"^articles/(?P<year>[0-9]{4})/$", views.year_archive),
        re_path(r"^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$", views.month_archive),
        re_path(
            r"^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/(?P<slug>[\w-]+)/$",
            views.article_detail,
        ),
    ]

Cela fait plus ou moins la même chose que l’exemple précédent, sauf que :

- L’URL précis qui va correspondre sera légèrement plus contraint. Par exemple, l’année 10000 ne correspondra plus puisque les nombres entiers des années sont limités à exactement quatre chiffres.

- Chaque paramètre capturé est envoyé à la vue en tant que chaîne de caractères, peu importe la correspondance qu’effectue l’expression régulière.

Lors du changement de `path()` vers `re_path()` ou vice versa, il est particulièrement important de réaliser que le type des paramètres de vue peut changer, ce qui peut impliquer des modifications dans le code des vues.

### Utilisation de groupes d’expressions régulières non nommés

En plus de la syntaxe des groupes nommés, par ex. `(?P<year>[0-9]{4})`, il est aussi possible d’utiliser des groupes non nommés plus courts, par ex. `([0-9]{4})`.

Cette utilisation n’est pas particulièrement recommandée car le risque est plus grand d’introduire accidentellement des erreurs entre la signification espérée d’une correspondance et les paramètres de la vue.

Dans les deux cas, il est recommandé d’employer un seul style dans une expression donnée. Lorsque les styles sont mélangés, tout groupe non nommé est ignoré et seuls les groupes nommés sont transmis à la fonction de vue.

### Paramètres imbriqués

Les expressions régulières autorisent les paramètres imbriqués et Django les résout et les transmet à la vue. Lors de l’inversion d’URL, Django essaie de remplir tous les paramètres capturés externes, en ignorant les paramètres capturés imbriqués. Considérez les motifs d’URL suivants qui acceptent de manière facultative un paramètre `page`:

    from django.urls import re_path

    urlpatterns = [
        re_path(r"^blog/(page-([0-9]+)/)?$", blog_articles),  # bad
        re_path(r"^comments/(?:page-(?P<page_number>[0-9]+)/)?$", comments),  # good
    ]

Les deux motifs emploient des paramètres imbriqués et seront résolus : par exemple, `blog/page-2/` va correspondre à `blog_articles` avec deux paramètres positionnels : `page-2/` et `2`. Le second motif pour `comments` va correspondre à `comments/page-2/` avec le paramètre nommé `page_number` défini à 2. Le paramètre extérieur dans ce cas est un paramètre non capturant `(?:...)`.

La vue `blog_articles` a besoin du paramètre capturé extérieur afin d’être résolue, `page-2/` ou aucun paramètre, dans ce cas, alors que `comments` peut être résolue avec soit aucun paramètre, soit une valeur pour `page_number`.

Les paramètres capturés imbriqués créent un couplage fort entre les paramètres de la vue et l’URL, comme le démontre `blog_articles`: la vue reçoit une partie de l’URL (`page-2/`) au lieu de ne recevoir que la valeur qui l’intéresse réellement. Ce couplage est encore plus prononcé lors de la résolution, car pour résoudre la vue, il est nécessaire de transmettre un bout d’URL au lieu d’un simple numéro de page.

En règle générale, capturez uniquement les valeurs que la vue doit gérer et employez des paramètres sans capture lorsque l’expression régulière a besoin d’un paramètre mais que la vue l’ignore.

## Configurations d’URL et contenu des comparaisons

L”`URLconf` utilise l’URL demandée, en tant que simple chaîne Python. Ni les paramètres GET ou POST, ni le nom de domaine ne sont inclus.

Par exemple, pour une requête sur `https://www.example.com/myapp/`, l”`URLconf` cherchera `myapp/`.

Pour une requête sur `https://www.example.com/myapp/?page=3`, l”`URLconf` cherchera `myapp/`.

L”`URLconf` ignore la méthode de la requête. En d’autres termes, toutes les méthodes de requêtes – `POST`, `GET`, `HEAD`, etc. – seront acheminées vers la même fonction de la même URL.

## Valeurs par défaut des paramètres de vue

Une astuce pratique est de définir des valeurs par défaut pour les paramètres de vos vues. Voici un exemple de configuration d’URL et de vue :

    # URLconf
    from django.urls import path

    from . import views

    urlpatterns = [
        path("blog/", views.page),
        path("blog/page<int:num>/", views.page),
    ]

    # View (in blog/views.py)
    def page(request, num=1):
        # Output the appropriate page of blog entries, according to num.
        ...

Dans l’exemple ci-dessus, les deux motifs d’URL pointent vers la même vue – `views.page` – mais le premier motif ne capture aucun élément de l’URL. Si le premier motif correspond, la fonction `page()` utilisera la valeur par défaut de son paramètre `num`, `1`. Si le second motif correspond, `page()` utilisera la valeur capturée.

## Performance

Django traite les expressions régulières de la liste `urlpatterns` en les compilant lors du premier accès. Les requêtes suivantes utilisent la configuration en cache au travers du résolveur d’URL.

## Syntaxe de la variable `urlpatterns`

`urlpatterns` devrait être une séquence d’instances `path()` ou `re_path()`.

## Gestion d’erreur

Quand Django ne trouve pas de correspondance pour l’URL demandée, ou quand une exception est générée, Django appelle une vue de gestion d’erreur.

Les vues à utiliser pour ces situations sont définies par quatre variables. Leur valeur par défaut devraient convenir à la plupart des projets, mais il reste possible de les personnaliser en surchargeant leurs valeurs par défaut.

Voir la documentation sur la personnalisation des vues d’erreur pour plus de détails.

Ces valeurs doivent être définies dans l”`URLconf` racine. La définition de ces variables dans n’importe quel autre `URLconf` n’aura aucun effet.

Les valeurs doivent pouvoir être appelées, ou être des chaînes de caractères représentant le chemin d’importation Python complet vers une vue qui doit être appelée pour traiter l’erreur actuelle.

Les variables sont :

- `handler400` – Voir `django.conf.urls.handler400`.

- `handler403` – Voir `django.conf.urls.handler403`.

- `handler404` – Voir `django.conf.urls.handler404`.

- `handler500` – Voir `django.conf.urls.handler500`.

## Inclusion d’autres URLconfs

À tout moment, votre `urlpatterns` peut « inclure » d’autres modules `URLconf`. Fondamentalement, cela permet de rassembler un ensemble d’URL les unes sous les autres.

Par exemple, voici un extrait de la configuration d’URL du site Web Django lui-même. Il inclut un certain nombre d’autres configurations d’URL :

    from django.urls import include, path

    urlpatterns = [
        # ... snip ...
        path("community/", include("aggregator.urls")),
        path("contact/", include("contact.urls")),
        # ... snip ...
    ]

Whenever Django encounters `include()`, it chops off whatever part of the URL matched up to that point and sends the remaining string to the included URLconf for further processing.

Une autre possibilité est d’inclure des motifs d’URL supplémentaires en utilisant une liste d’instances `path()`. Par exemple, dans cette configuration d’URL :

    from django.urls import include, path

    from apps.main import views as main_views
    from credit import views as credit_views

    extra_patterns = [
        path("reports/", credit_views.report),
        path("reports/<int:id>/", credit_views.report),
        path("charge/", credit_views.charge),
    ]

    urlpatterns = [
        path("", main_views.homepage),
        path("help/", include("apps.help.urls")),
        path("credit/", include(extra_patterns)),
    ]

Dans cet exemple, l’URL `/credit/reports/` sera traitée par la vue Django `credit_views.report()`.

Cela peut être utilisé pour supprimer de la redondance dans des configurations d’URL où un préfixe de motif est employé de manière répétitive. Par exemple, considérez cette configuration d’URL :

    from django.urls import path
    from . import views

    urlpatterns = [
        path("<page_slug>-<page_id>/history/", views.history),
        path("<page_slug>-<page_id>/edit/", views.edit),
        path("<page_slug>-<page_id>/discuss/", views.discuss),
        path("<page_slug>-<page_id>/permissions/", views.permissions),
    ]

Nous pouvons l’améliorer en indiquant une seule fois le préfixe de chemin commun et en regroupant les suffixes qui diffèrent :

    from django.urls import include, path
    from . import views

    urlpatterns = [
        path(
            "<page_slug>-<page_id>/",
            include(
                [
                    path("history/", views.history),
                    path("edit/", views.edit),
                    path("discuss/", views.discuss),
                    path("permissions/", views.permissions),
                ]
            ),
        ),
    ]

### Les paramètres capturés

Un `URLconf` inclus reçoit tous les paramètres capturés par ses `URLconf` parents, ainsi l’exemple suivant est valide :

    # In settings/urls/main.py
    from django.urls import include, path

    urlpatterns = [
        path("<username>/blog/", include("foo.urls.blog")),
    ]

    # In foo/urls/blog.py
    from django.urls import path
    from . import views

    urlpatterns = [
        path("", views.blog.index),
        path("archive/", views.blog.archive),
    ]

Dans l’exemple ci-dessus, la variable capturée `"username"` est passée à l”`URLconf` inclus, comme on peut s’y attendre.

## Transmission de paramètres supplémentaires à une vue

Les configurations d’URL ont un point d’entrée qui permet de passer des paramètres supplémentaires à vos vues, via un dictionnaire Python.

La fonction `django.urls.path()` accepte un troisième paramètre facultatif qui doit correspondre à un dictionnaire de paramètres nommés supplémentaires à transmettre à la fonction de vue.

Par exemple :

    from django.urls import path
    from . import views

    urlpatterns = [
        path("blog/<int:year>/", views.year_archive, {"foo": "bar"}),
    ]

Dans cet exemple, si une requête demande `/blog/2005/`, Django appelle `views.year_archive(request, year=2005, foo='bar')`.

Cette technique est utilisée dans le système de syndication pour passer des métadonnées et des options aux vues.

Gestion des confilts

Il est possible d’avoir un motif d’URL qui capture des paramètres nommés, et qui passe aussi des paramètres ayant les mêmes noms dans son dictionnaire de paramètres supplémentaires. Quand c’est le cas, les paramètres du dictionnaire seront utilisés à la place des paramètres capturés dans l’URL.

### Transmission de paramètres supplémentaires à `include()`

De la même façon, vous pouvez passer des paramètres supplémentaires à la fonction `include()` et chacune des lignes de la configuration d’URL incluse recevra les paramètres supplémentaires.

Par exemple, ces deux ensembles de configurations d’URL sont fonctionnellement identiques :

Premier ensemble :

    # main.py
    from django.urls import include, path

    urlpatterns = [
        path("blog/", include("inner"), {"blog_id": 3}),
    ]

    # inner.py
    from django.urls import path
    from mysite import views

    urlpatterns = [
        path("archive/", views.archive),
        path("about/", views.about),
    ]

Second ensemble :

    # main.py
    from django.urls import include, path
    from mysite import views

    urlpatterns = [
        path("blog/", include("inner")),
    ]

    # inner.py
    from django.urls import path

    urlpatterns = [
        path("archive/", views.archive, {"blog_id": 3}),
        path("about/", views.about, {"blog_id": 3}),
    ]

Remarquez que les paramètres supplémentaires seront toujours passés à chaque élément de la configuration d’URL incluse, peu importe si la vue associée à l’élément accepte ces paramètres comme étant valides. C’est pour cette raison que cette technique est utile seulement lorsque vous êtes certain que toutes les vues de la configuration d’URL incluse acceptent les paramètres supplémentaires que vous passez.

## Résolution inversée des URL

Un besoin courant quand on travaille sur un projet Django est d’avoir la possibilité d’obtenir des URL dans leur forme finale soit pour les incorporer dans du contenu généré (des URL vers des vues et des ressources, des URL montrées à l’utilisateur, etc.) ou pour gérer le flux de navigation côté serveur (redirections, etc.).

It is strongly desirable to avoid hardcoding these URLs (a laborious, non-scalable and error-prone strategy). Equally dangerous is devising ad-hoc mechanisms to generate URLs that are parallel to the design described by the URLconf, which can result in the production of URLs that become stale over time.

En d’autres termes, ce dont nous avons besoin est un mécanisme DRY (« ne pas se répéter »). L’un de ses avantages est de permettre l’évolution de l’organisation des URL sans avoir à parcourir le code source du projet pour remplacer les URL obsolètes.

L’information principale dont nous disposons pour récupérer une URL est une identification de la vue qui est chargée de la traiter (par exemple, son nom). Les autres informations nécessaires à la recherche de la bonne URL sont les types (positionnel, nommé) et les valeurs des paramètres de la vue.

Django met à disposition une solution qui fait en sorte que le système d’abstraction d’URL est le seul à connaître l’organisation des URL. Vous lui donnez votre configuration d’URL et vous pouvez ensuite l’utiliser dans les deux sens :

- À partir d’une URL demandée par un utilisateur/navigateur, il appelle la vue Django concernée en lui passant tous les paramètres dont elle a besoin en extrayant les valeurs telles quelles de l’URL.

- À partir de l’identification de la vue Django concernée ainsi que les valeurs des paramètres qui lui seraient passés, il renvoie l’URL associée.

Le premier correspond à l’utilisation dont nous avons parlé dans les sections précédentes. Le second correspond à ce qu’on appelle la résolution inversée des URL, la correspondance inverse d’URL, la recherche inverse d’URL, ou plus simplement l’inversion d’URL.

Django met à disposition des outils pour réaliser une inversion d’URL dans les différentes couches où les URL sont nécessaires :

- Dans les gabarits : en utilisant la balise de gabarit `url`.

- Dans le code Python : en utilisant la fonction `reverse()`.

- Dans le code plus abstrait amené à manipuler les URL des instances de modèle Django : la méthode `get_absolute_url()`.

### Exemples

Reprenons comme exemple cette ligne de configuration d’URL :

    from django.urls import path

    from . import views

    urlpatterns = [
        # ...
        path("articles/<int:year>/", views.year_archive, name="news-year-archive"),
        # ...
    ]

D’après ce schéma, l’URL de l’archive correspondant à l’année nnnn est `/articles/<nnnn>/`.

Vous pouvez obtenir ces URL dans les gabarits en utilisant :

    <a href="{% url 'news-year-archive' 2012 %}">2012 Archive</a>
    {# Or with the year in a template context variable: #}
    <ul>
    {% for yearvar in year_list %}
    <li><a href="{% url 'news-year-archive' yearvar %}">{{ yearvar }} Archive</a></li>
    {% endfor %}
    </ul>

Ou en Python :

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

    def redirect_to_year(request):
        # ...
        year = 2006
        # ...
        return HttpResponseRedirect(reverse("news-year-archive", args=(year,)))

Si, pour quelque raison que ce soit, vous décidez de changer l’URL à laquelle les archives annuelles d’articles sont sauvegardées, vous aurez seulement besoin de changer la ligne concernée dans la configuration d’URL.

Dans le cas où les vues ont un comportement générique, une relation N:1 peut exister entre les URL et les vues. Dans ces cas-là, le nom de la vue n’est pas un identifiant suffisant au moment où il s’agit d’utiliser l’inversion d’URL. Lisez la section suivante pour découvrir la solution qu’apporte Django à ce problème.

## Nommage des motifs d’URL

Afin de pouvoir effectuer des inversions d’URL, il est nécessaire d’utiliser des motifs d’URL nommés comme vous pouvez le voir dans les exemples ci-dessus. La chaîne utilisée pour les noms des URL peut contenir tous les caractères que vous voulez. Vous n’êtes pas tenus d’utiliser des noms Python valables.

When naming URL patterns, choose names that are unlikely to clash with other applications” choice of names. If you call your URL pattern `comment` and another application does the same thing, the URL that `reverse()` finds depends on whichever pattern is last in your project’s `urlpatterns` list.

L’ajout d’un préfixe aux noms d’URL, peut-être dérivé du nom de l’application (comme `monapp-comment` au lieu de `comment`), permet de réduire les risques de collision.

You can deliberately choose the same URL name as another application if you want to override a view. For example, a common use case is to override the `LoginView`. Parts of Django and most third-party apps assume that this view has a URL pattern with the name `login`. If you have a custom login view and give its URL the name `login`, `reverse()` will find your custom view as long as it’s in `urlpatterns` after `django.contrib.auth.urls` is included (if that’s included at all).

You may also use the same name for multiple URL patterns if they differ in their arguments. In addition to the URL name, `reverse()` matches the number of arguments and the names of the keyword arguments. Path converters can also raise `ValueError` to indicate no match, see Inscription de convertisseurs de chemin personnalisés for details.

## Les espaces de noms d’URL

### Introduction

Les espaces de noms d’URL permettent la résolution inverse de motifs d’URL nommés de manière unique, même si différentes applications utilisent les mêmes noms d’URL. L’utilisation systématique d’URL avec espaces de noms est une bonne pratique que les applications tierces devraient adopter (comme cela a été fait dans le tutoriel). C’est aussi un moyen qui permet la résolution inverse quand plusieurs instances d’une application sont déployées. En d’autres termes, comme plusieurs instances d’une même application partagent les URL nommées, les espaces de noms fournissent un moyen de distinguer ces URL nommées.

Django applications that make proper use of URL namespacing can be deployed more than once for a particular site. For example `django.contrib.admin` has an `AdminSite` class which allows you to deploy more than one instance of the admin. In a later example, we’ll discuss the idea of deploying the polls application from the tutorial in two different locations so we can serve the same functionality to two different audiences (authors and publishers).

Un espace de noms d’URL se compose de deux parties, qui sont les deux des chaînes de caractères :

espace de noms d’application

  Ceci définit le nom de l’application déployée. Chaque instance d’une même application possède le même espace de noms d’application. Par exemple, l’application d’administration de Django possède l’espace de noms d’application `'admin'`, comme l’on peut s’y attendre.

espace de noms d’instance

  Ceci identifie une instance particulière d’une application. Les espaces de noms d’instance doivent être uniques dans tout un projet. Cependant, un espace de noms d’instance peut être identique à l’espace de noms d’application. C’est utilisé pour identifier l’instance par défaut d’une application. Par exemple, l’instance par défaut du site d’administration de Django possède l’espace de noms d’instance `'admin'`.

Les URL avec espace de noms sont identifiées par l’opérateur `':'`. Par exemple, la page d’accueil principale de l’application d’administration est référencée par `'admin:index'`. Cela indique une URL nommée `'index'` dans un espace de noms `'admin'`.

Les espaces de noms peuvent aussi être imbriqués. L’URL nommée `'sports:polls:index'` recherche un motif nommé `'index'` dans l’espace de noms `'polls'`, lui-même défini à l’intérieur de l’espace de noms de premier niveau `'sports'`.

### Résolution inverse des URL avec espaces de noms

Lorsqu’il reçoit une URL avec espace de noms à résoudre (par ex. `'polls:index'`), Django partage le nom complet en segments et effectue la recherche suivante :

1. Premièrement, Django cherche un espace de noms d’application correspondant (dans cet exemple, `'polls'`). Cela produira une liste d’instances de cette application.

2. If there is a current application defined, Django finds and returns the URL resolver for that instance. The current application can be specified with the `current_app` argument to the `reverse()` function.

   La balise de gabarit `url` utilise l’espace de noms de la vue actuellement résolue comme application courante dans un `RequestContext`. Vous pouvez outrepasser cette valeur par défaut en définissant l’application courante dans l’attribut `request.current_app`.

3. S’il n’existe pas d’application courante, Django cherche une instance d’application par défaut. Celle-ci correspond à l’instance dont l’espace de noms d’instance est identique à l’espace de noms d’application (dans cet exemple, une instance de `polls` appelée `'polls'`).

4. S’il n’existe pas d’instance d’application par défaut, Django sélectionne la dernière instance déployée de l’application, quel que soit son nom d’instance.

5. Si l’espace de noms indiqué ne correspond pas à un espace de noms d’application à l’étape 1, Django effectue une recherche directe d’espace de noms en tant qu’espace de noms d’instance.

S’il existe des espaces de noms imbriqués, ces étapes sont répétées pour chaque partie de l’espace de noms jusqu’à ce qu’il ne reste plus que le nom de la vue comme élément non résolu. Le nom de vue est ensuite résolu comme URL dans l’espace de noms qui a été trouvé.

#### Exemple

Pour voir en action cette stratégie de résolution, considérez l’exemple de deux instances de l’application `polls` du tutoriel : l’une appelée `'author-polls'` et l’autre `'publisher-polls'`. Supposons que l’on ait amélioré cette application afin qu’elle prenne en considération l’espace de noms de l’instance lors de la création et de l’affichage des sondages.

`urls.py`

    from django.urls import include, path

    urlpatterns = [
        path("author-polls/", include("polls.urls", namespace="author-polls")),
        path("publisher-polls/", include("polls.urls", namespace="publisher-polls")),
    ]

`polls/urls.py`

    from django.urls import path

    from . import views

    app_name = "polls"
    urlpatterns = [
        path("", views.IndexView.as_view(), name="index"),
        path("<int:pk>/", views.DetailView.as_view(), name="detail"),
        ...,
    ]

Avec cette configuration, les recherches suivantes sont possibles :

- Si l’une des instances est courante, c’est-à-dire que nous construisons la page de détail dans l’instance `'author-polls'`, `'polls:index'` est résolu à la page d’accueil de l’instance `'author-polls'`. C’est-à-dire que les deux expressions suivantes produiront `"/author-polls/"`.

  Dans la méthode d’une vue fondée sur les classes :

      reverse("polls:index", current_app=self.request.resolver_match.namespace)

  et dans le gabarit :

      {% url 'polls:index' %}

- S’il n’existe pas d’instance courante, par exemple si nous produisons une page quelque part ailleurs sur le site, `'polls:index'` est résolu en rapport avec l’instance `polls` inscrite en dernier. Comme il n’y a pas d’instance par défaut (espace de noms d’instance `'polls'`), c’est la dernière instance inscrite de `polls` qui est utilisée. Cela sera `'publisher-polls'` car c’est celle qui est déclarée en dernier dans les motifs d’URL `urlpatterns`.

- `'author-polls:index'` will always resolve to the index page of the instance `'author-polls'` (and likewise for `'publisher-polls'`).

S’il y avait aussi une instance par défaut, nommée `'polls'`, la seule chose qui change par rapport à ci-dessus est que quand il n’y a pas d’instance courante (le deuxième cas ci-dessus), `'polls:index'` est résolu à la page d’accueil de l’instance par défaut, et non pas de l’instance déclarée en dernier dans les motifs d’URL `urlpatterns`.

### Espaces de noms d’URL et configurations d’URL incluses

Les espaces de noms d’application des configurations d’URL incluses peuvent être définis de deux manières.

Premièrement, vous pouvez définir un attribut `app_name` dans le module de configuration d’URL inclus, au même niveau que l’attribut `urlpatterns`. Il est nécessaire d’indiquer à `include()` le module réel ou une référence textuelle au module, non pas la liste ou l’élément `urlpatterns` lui-même.

`polls/urls.py`

    from django.urls import path

    from . import views

    app_name = "polls"
    urlpatterns = [
        path("", views.IndexView.as_view(), name="index"),
        path("<int:pk>/", views.DetailView.as_view(), name="detail"),
        ...,
    ]

`urls.py`

    from django.urls import include, path

    urlpatterns = [
        path("polls/", include("polls.urls")),
    ]

Les URL définies dans `polls.urls` auront un espace de noms d’application `polls`.

Deuxièmement, vous pouvez inclure un objet contenant des données d’espace de noms intégrées. Si vous incluez par `include()` une liste d’instances `path()` ou `re_path()`, les URL contenues dans cet objet seront ajoutées à l’espace de noms global. Cependant, vous pouvez aussi inclure un tuple de 2 éléments contenant :

    (<list of path()/re_path() instances>, <application namespace>)

Par exemple :

    from django.urls import include, path

    from . import views

    polls_patterns = (
        [
            path("", views.IndexView.as_view(), name="index"),
            path("<int:pk>/", views.DetailView.as_view(), name="detail"),
        ],
        "polls",
    )

    urlpatterns = [
        path("polls/", include(polls_patterns)),
    ]

Cela va inclure les motifs d’URL nommés dans l’espace de noms d’application donné.

L’espace de noms d’instance peut être précisé en utilisant le paramètre `namespace` de `include()`. Si l’espace de noms d’instance n’est pas défini, il contiendra par défaut l’espace de noms d’application de la configuration d’URL incluse. Cela signifie qu’il s’agira aussi de l’instance par défaut pour cet espace de noms.