# Django 4.1.8.dev20230308103347 ドキュメント

# URL ディスパッチャ

A clean, elegant URL scheme is an important detail in a high-quality web application. Django lets you design URLs however you want, with no framework limitations.

URL はすっきりした扱いやすいものにすべきであるという主張については、ワール ドワイドウェブの産みの親である Tim Berners-Lee の優れた解説、 Cool URIs don’t change を参照してください。

## 概要

アプリケーションのURLを設計するには、俗に URLconf (URL configuration) と呼ばれる Python モジュールを作る必要があります。このモジュールは pure Python コードであり、URLパス表記とあなたの書いたビューの Python 関数とのマッピングです。

このマッピングは短くもできますし、必要なだけ長くもできます。他のマッピングも参照できます。また、pure Python コードなので、動的に生成できます。

Django は有効にされている言語にしたがって URL を翻訳するための手段も提供しています。詳しくは internationalization documentation を参照してください。

## Django のリクエスト処理

ユーザが Django で作られたサイト上のページをリクエストした時に、どの Python コードが実行されるかは以下のアルゴリズムで決定されます。

1. まず、Django は、どのモジュールをルート URLconf として使うか決定します。通常は、この値は `ROOT_URLCONF` に設定されています。ただし、 HttpRequest オブジェクトに `urlconf` という属性が設定されていた場合 ( middleware で設定されます) 、その値を `ROOT_URLCONF` の代わりに使います。
2. Django はその Python モジュールをロードして、`urlpatterns` という名前の変数を探します。この変数の値は `django.urls.path()` または `django.urls.re_path()` インスタンスの sequence でなければなりません。
3. Django runs through each URL pattern, in order, and stops at the first one that matches the requested URL, matching against `path_info`.
4. Once one of the URL patterns matches, Django imports and calls the given view, which is a Python function (or a class-based view). The view gets passed the following arguments:
   - `HttpRequest` のインスタンス。
   - If the matched URL pattern contained no named groups, then the matches from the regular expression are provided as positional arguments.
   - The keyword arguments are made up of any named parts matched by the path expression that are provided, overridden by any arguments specified in the optional `kwargs` argument to `django.urls.path()` or `django.urls.re_path()`.
5. もし、 URL 正規表現が何にもマッチしなかったり、パターンマッチングプロセスの途中のどこかで例外が発生した場合、Django は適切なエラーハンドリングビューを呼び出します。下の Error handling を見てください。

## カスタマイズ例

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),
    ]

メモ:

- To capture a value from the URL, use angle brackets.
- Captured values can optionally include a converter type. For example, use `<int:name>` to capture an integer parameter. If a converter isn't included, any string, excluding a `/` character, is matched.
- There's no need to add a leading slash, because every URL has that. For example, it's `articles`, not `/articles`.

Example requests:

- A request to `/articles/2005/03/` would match the third entry in the list. Django would call the function `views.month_archive(request, year=2005, month=3)`.
- `/articles/2003/` would match the first pattern in the list, not the second one, because the patterns are tested in order, and the first one is the first test to pass. Feel free to exploit the ordering to insert special cases like this. Here, Django would call the function `views.special_case_2003(request)`
- `/articles/2003` would not match any of these patterns, because each pattern requires that the URL end with a slash.
- `/articles/2003/03/building-a-django-site/` would match the final pattern. Django would call the function `views.article_detail(request, year=2003, month=3, slug="building-a-django-site")`.

## Path converters

The following path converters are available by default:

- `str` - Matches any non-empty string, excluding the path separator, `'/'`. This is the default if a converter isn't included in the expression.
- `int` - Matches zero or any positive integer. Returns an `int`.
- `slug` - Matches any slug string consisting of ASCII letters or numbers, plus the hyphen and underscore characters. For example, `building-your-1st-django-site`.
- `uuid` - Matches a formatted UUID. To prevent multiple URLs from mapping to the same page, dashes must be included and letters must be lowercase. For example, `075194d3-6885-417e-a8a8-6c931e272f00`. Returns a `UUID` instance.
- `path` - Matches any non-empty string, including the path separator, `'/'`. This allows you to match against a complete URL path rather than a segment of a URL path as with `str`.

## Registering custom path converters

For more complex matching requirements, you can define your own path converters.

A converter is a class that includes the following:

- A `regex` class attribute, as a string.
- A `to_python(self, value)` method, which handles converting the matched string into the type that should be passed to the view function. It should raise `ValueError` if it can't convert the given value. A `ValueError` is interpreted as no match and as a consequence a 404 response is sent to the user unless another URL pattern matches.
- A `to_url(self, value)` method, which handles converting the Python type into a string to be used in the URL. It should raise `ValueError` if it can't convert the given value. A `ValueError` is interpreted as no match and as a consequence `reverse()` will raise `NoReverseMatch` unless another URL pattern matches.

例:

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

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

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

Register custom converter classes in your URLconf using `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),
        ...
    ]

## Using regular expressions

If the paths and converters syntax isn't sufficient for defining your URL patterns, you can also use regular expressions. To do so, use `re_path()` instead of `path()`.

In Python regular expressions, the syntax for named regular expression groups is `(?P<name>pattern)`, where `name` is the name of the group and `pattern` is some pattern to match.

Here's the example URLconf from earlier, rewritten using regular expressions:

    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),
    ]

This accomplishes roughly the same thing as the previous example, except:

- The exact URLs that will match are slightly more constrained. For example, the year 10000 will no longer match since the year integers are constrained to be exactly four digits long.
- Each captured argument is sent to the view as a string, regardless of what sort of match the regular expression makes.

When switching from using `path()` to `re_path()` or vice versa, it's particularly important to be aware that the type of the view arguments may change, and so you may need to adapt your views.

### Using unnamed regular expression groups

As well as the named group syntax, e.g. `(?P<year>[0-9]{4})`, you can also use the shorter unnamed group, e.g. `([0-9]{4})`.

This usage isn't particularly recommended as it makes it easier to accidentally introduce errors between the intended meaning of a match and the arguments of the view.

In either case, using only one style within a given regex is recommended. When both styles are mixed, any unnamed groups are ignored and only named groups are passed to the view function.

### ネストされた引数

正規表現ではネストされた引数を使うことができ、Django はこれらを解決してビューに渡します。このとき、Django は全ての外側のキャプチャされた引数を埋めようとし、ネストされたキャプチャされた引数を無視します。任意でページ引数を取る以下の URL パターンを考えてみます:

    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
    ]

両方のパターンでネストされた引数を使っており、解決します: 例えば、 `blog/page-2/` は 2 つの潜在的な引数 (`page-2/` と `2`) で `blog_articles` と一致する結果となります。`comments` の 2 番目のパターンは、2 にセットされたキーワード引数 `page_number` で `comments/page-2/` と一致します。 この例での外部の引数は、キャプチャされない引数 `(?:...)` です。

`blog_articles` ビューは一番外側のキャプチャされた引数が解決されるのを必要としますが (この例では `page-2/` か引数なし)、`comments` は引数なしか `page_number` に対する値のどちらかで解決できます。

ネストされたキャプチャされた引数は、`blog_articles` (ビューが興味を持つ値だけでなく URL `page-2/` の部分を受け取るビュー) によって示されるように、ビュー引数と URL の間に強力な結合を作ります: この結合は、ビューを解決する際にページ番号ではなくURLの部分を渡す必要があるため、解決するときにはさらに顕著になります。

経験則として、正規表現が引数を必要とする一方でビューがそれを無視するときには、ビューが必要とする値だけをキャプチャして、キャプチャしない引数を使ってください。

## What the URLconf searches against

The URLconf searches against the requested URL, as a normal Python string. This does not include GET or POST parameters, or the domain name.

For example, in a request to `https://www.example.com/myapp/`, the URLconf will look for `myapp/`.

In a request to `https://www.example.com/myapp/?page=3`, the URLconf will look for `myapp/`.

The URLconf doesn't look at the request method. In other words, all request methods -- `POST`, `GET`, `HEAD`, etc. -- will be routed to the same function for the same URL.

## Specifying defaults for view arguments

A convenient trick is to specify default parameters for your views' arguments. Here's an example URLconf and view:

    # 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.
        ...

In the above example, both URL patterns point to the same view -- `views.page` -- but the first pattern doesn't capture anything from the URL. If the first pattern matches, the `page()` function will use its default argument for `num`, `1`. If the second pattern matches, `page()` will use whatever `num` value was captured.

## パフォーマンス

Django processes regular expressions in the `urlpatterns` list which is compiled the first time it's accessed. Subsequent requests use the cached configuration via the URL resolver.

## Syntax of the `urlpatterns` variable

`urlpatterns` は `django.urls.path()` または `django.urls.re_path()` インスタンスの sequence でなければなりません。

## Error handling

When Django can't find a match for the requested URL, or when an exception is raised, Django invokes an error-handling view.

The views to use for these cases are specified by four variables. Their default values should suffice for most projects, but further customization is possible by overriding their default values.

See the documentation on customizing error views for the full details.

Such values can be set in your root URLconf. Setting these variables in any other URLconf will have no effect.

Values must be callables, or strings representing the full Python import path to the view that should be called to handle the error condition at hand.

The variables are:

- `handler400` -- See `django.conf.urls.handler400`.
- `handler403` -- See `django.conf.urls.handler403`.
- `handler404` -- See `django.conf.urls.handler404`.
- `handler500` -- See `django.conf.urls.handler500`.

## 他の URLconfs をインクルードする

いずれの時点でも、`urlpatterns` は他の URLconf モジュールを "含む (インクルードする)" ことができます。これは基本的に、他の URL パターンに定義されている URL のセットを探索します。

例えば、以下は Django website 自体に対する URLconf の引用です。これは複数の他の URLconfs をインクルードしています:

    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.

Another possibility is to include additional URL patterns by using a list of `path()` instances. For example, consider this URLconf:

    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)),
    ]

この例では、`/credit/reports/` という URL は `credit_views.report()` というビューによって処理されます。

これを使うと、単一のパターンの接頭辞が繰り返し使われるような URLconfs の冗長さを回避できます。例えば、以下の URLconf を考えてみます:

    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),
    ]

これは、パスの共通部分である接頭辞を一度だけ記述し、異なる接尾辞を以下のようにグループ化することで改善できます:

    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),
        ])),
    ]

### 取り込まれたパラメータ

インクルードされた URLconf は親 URLconfs から取り込まれた全てのパラメータを受け取るので、以下の例は有効となります:

    # 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),
    ]

上の例では、取り込まれた `"username"` 変数はインクルードされたURLconf に渡されます。

## 追加的なオプションをビュー関数に渡す

URLconfs は、Ptyhon のディクショナリとして、ビュー関数に追加の引数を引き渡せるようにするフックを持っています。

The `path()` function can take an optional third argument which should be a dictionary of extra keyword arguments to pass to the view function.

例:

    from django.urls import path
    from . import views

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

In this example, for a request to `/blog/2005/`, Django will call `views.year_archive(request, year=2005, foo='bar')`.

このテクニックは 配信フィードフレームワーク で使われ、メタデータとオプションをビューに引き渡します。

競合を解決する

名付けられたキーワード引数をキャプチャする URL パターンを使うこともできます。これは、追加の引数のディクショナリ内と同じ名前の引数を引き渡します。このとき、URL 内でキャプチャされた引数ではなく、ディクショナリ内の引数が使われます。

### `include()` に追加のオプションを引き渡す

Similarly, you can pass extra options to `include()` and each line in the included URLconf will be passed the extra options.

例えば、以下の 2 つの URLconf のセットはまったく同じように機能します:

セット 1:

    # 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),
    ]

セット 2:

    # 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}),
    ]

行のビューが実際にそれらのオプションを有効として受け入れるかどうかに関わらず、追加のオプションが 常に インクルードされている URLconfの すべての 行に引き渡されることに注意してください。 このため、このテクニックは、インクルードされた URLconf のすべてのビューが、引き渡される追加のオプションを受け入れることが確実である場合にのみ役立ちます。

## Reverse resolution of URLs

Django プロジェクトで作業するときの一般的なニーズとして、生成されたコンテンツ (ビューとアセットのURL、ユーザーに表示されるURLなど) への埋め込み、またはサーバーサイドでのナビゲーションフローの処理 (リダイレクトなど) のどちらかに対して、最終的なフォーム内で URL を取得することが挙げられます。

こうした URL のハードコーディング (手間がかかり、スケールしにくく、誤りが起こりやすい戦略) は、避けることが強く望まれます。 同様に危険なのは、URLconf で記述された設計と並行して URL を生成するような一時的な仕組みを考え出してしまうことです。これは、時間の経過とともに古くて使えない URL が生成されてしまう原因となります。

言い換えると、必要なのはDRYな仕組みです。 数々の利点の中でも、これは URL 設計が進化していけるようにします。プロジェクトソースコードを全て検索して古い URL を置換する必要はありません。

The primary piece of information we have available to get a URL is an identification (e.g. the name) of the view in charge of handling it. Other pieces of information that necessarily must participate in the lookup of the right URL are the types (positional, keyword) and values of the view arguments.

Django provides a solution such that the URL mapper is the only repository of the URL design. You feed it with your URLconf and then it can be used in both directions:

- Starting with a URL requested by the user/browser, it calls the right Django view providing any arguments it might need with their values as extracted from the URL.
- Starting with the identification of the corresponding Django view plus the values of arguments that would be passed to it, obtain the associated URL.

The first one is the usage we've been discussing in the previous sections. The second one is what is known as reverse resolution of URLs, reverse URL matching, reverse URL lookup, or simply URL reversing.

Django provides tools for performing URL reversing that match the different layers where URLs are needed:

- In templates: Using the `url` template tag.
- In Python code: Using the `reverse()` function.
- In higher level code related to handling of URLs of Django model instances: The `get_absolute_url()` method.

### 例

Consider again this URLconf entry:

    from django.urls import path

    from . import views

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

According to this design, the URL for the archive corresponding to year nnnn is `/articles/<nnnn>/`.

You can obtain these in template code by using:

    <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>

Or in Python code:

    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,)))

If, for some reason, it was decided that the URLs where content for yearly article archives are published at should be changed then you would only need to change the entry in the URLconf.

In some scenarios where views are of a generic nature, a many-to-one relationship might exist between URLs and views. For these cases the view name isn't a good enough identifier for it when comes the time of reversing URLs. Read the next section to know about the solution Django provides for this.

## URL パターンに名前をつける

URL のリバースを処理するためには、上述の例で行ったように 名前をつけられた URL パターン を使う必要があります。URL 名として使う文字列には、どんな文字でも含めることができます。Python の有効な名前に制限を受けません。

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.

Putting a prefix on your URL names, perhaps derived from the application name (such as `myapp-comment` instead of `comment`), decreases the chance of 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 Registering custom path converters for details.

## URL の名前空間

### はじめに

URL の名前空間は、別のアプリケーションが同じ URL 名を使っている場合でも <naming-url-patterns>` をユニークにリバースできるようにします。(私たちがチュートリアルで行ったように) サードパーティ製のアプリケーションが常に名前空間を使った URL を使っているのがいい例です。同じように、アプリケーションの複数のインスタンスがデプロイされているときでも、URL がリバースできるようになります。言い換えると、単一のアプリケーションの複数のインスタンスは名前のついた URL を共有するので、名前空間は名前のついた URL を区別する方法を提供します。

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).

URL の名前空間は 2 つの部分に分かれ、両方とも文字列で表されます:

アプリケーションの名前空間
  デプロイされているアプリケーションの名前を示します。 単一のアプリケーションのすべてのインスタンスは、同一のアプリケーション名前空間を持ちます。 例えば、Django の admin アプリケーションには、`'admin'` という比較的分かりやすいアプリケーション名前空間を持っています。
インスタンスの名前空間
  アプリケーションの特定のインスタンスを識別します。 インスタンス名前空間は、プロジェクト全体で一意である必要があります。ただし、インスタンス名前空間は、アプリケーション名前空間と同じにすることができます。これは、アプリケーションのデフォルトインスタンスを指定するために使用されます。 例えば、デフォルトの Django admin インスタンスは `'admin'` というインスタンス名前空間を持っています。

名前空間の URL は、 `':'` 演算子を使って指定します。 たとえば、admin アプリケーションのメインインデックスページは `'admin:index'` で参照されます。 これは `'admin'` という名前空間と `'index'` という名前の URL を示します。

名前空間はネストすることもできます。 名前付きの URL `'sports:polls:index'` は、トップレベルの名前空間 `'sports'` 内で定義されている名前空間 `'polls'` 内で `'index'` と名前がつけられたパターンを探します。

### 名前空間の URL をリバースする

名前空間の URL (例: `'polls:index'`) が与えられると、Django 完全修飾名をパーツに分割し、以下のルックアップを試みます:

1. まず最初に、Django は アプリケーションの名前空間 (ここでは `'polls'`) との一致を検索します。これは、このアプリケーションのインスタンスのリストを生成します。

2. 現在のアプリケーションが定義されている場合、Django はそのインスタンスに対して URL リゾルバを探し出し、返します。現在のアプリケーションは `reverse()` 関数への `current_app` 引数で指定できます。

   `url` テンプレートタグは、`RequestContext` 内で現在のアプリケーションとされているビューの名前空間を使います。このデフォルト設定は、`request.current_app` 属性で現在のアプリケーションを設定することでオーバーライドできます。

3. If there is no current application, Django looks for a default application instance. The default application instance is the instance that has an instance namespace matching the application namespace (in this example, an instance of `polls` called `'polls'`).

4. デフォルトのアプリケーションインスタンスがない場合、Django は、そのインスタンス名が何であれ、アプリケーションの最後にデプロイされたインスタンスを利用します。

5. 提供された名前空間がステップ 1 の application namespace と一致しない場合、Django は名前空間のルックアップを instance namespace として直接試みます。

ネストされた名前空間がある場合、これらのステップはビューの名前のみが未解決になるまで名前空間の各パートに対して繰り返されます。その後に、このビュー名は見つかった名前空間内の URL として解決されます。

#### カスタマイズ例

実際の名前解決戦略を示すため、チュートリアルで扱った `polls` アプリケーションの 2 つのインスタンスの例を考えてみましょう: 1 つは `'author-polls'`、もう 1 つは `'publisher-polls'` と名付けられています。polls を作成して表示するときにインスタンス名前空間を考慮するように、そのアプリケーションを拡張したとします。

`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'),
        ...
    ]

この設定を使うことで、以下のルックアップが可能となります:

- インスタンスの 1 つが現在参照されている場合 - インスタンス `'author-polls'` 内の詳細ページをレンダリングしているとしましょう - `'polls:index'` は `'author-polls'` インスタンスのインデックスページを解決します; 例えば 以下の両方とも``"/author-polls/"`` となります。

  クラスベースビューのメソッド内:

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

  テンプレート内:

      {% url 'polls:index' %}

- 現在のインスタンスがない場合 - サイト上のどこか他のページをレンダリングしているとしましょう - `'polls:index'` は `polls` の最後に登録されたインスタンスとして名前解決します。デフォルトのインスタンス (`'polls'` のインスタンス名前空間) が存在しないため、登録された `polls` の最後のインスタンスが使われます。`urlpatterns` 内で最後に明言されているので、`'publisher-polls'` となります。

- `'author-polls:index'` は、常に `'author-polls'` のインスタンスのインデックスページに名前解決します (そして `'publisher-polls'` に対しても同じです) .

デフォルトのインスタンスもある場合 - 例えば `'polls'` と名前がつけられたインスタンス - 上記とのいい角違いは現在のインスタンスがない場合です (上記のリストの 2 番目の項目)。ここでは、`'polls:index'` は `urlpatterns` 内で最後に明言されたインスタンスの代わりにデフォルトのインスタンスのインデックスページに名前解決します。

### URLの名前空間とインクルードされた URLconfs

インクルードされた URLconfs のアプリケーション名前空間は、2 つの方法で指定することができます。

Firstly, you can set an `app_name` attribute in the included URLconf module, at the same level as the `urlpatterns` attribute. You have to pass the actual module, or a string reference to the module, to `include()`, not the list of `urlpatterns` itself.

`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')),
    ]

`polls.urls` 内で定義された URL は、アプリケーション名前空間 `polls` を持ちます。

Secondly, you can include an object that contains embedded namespace data. If you `include()` a list of `path()` or `re_path()` instances, the URLs contained in that object will be added to the global namespace. However, you can also `include()` a 2-tuple containing:

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

例:

    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)),
    ]

これは、与えられたアプリケーション名前空間に、ノミネートされた URL パターンをインクルードします。

The instance namespace can be specified using the `namespace` argument to `include()`. If the instance namespace is not specified, it will default to the included URLconf's application namespace. This means it will also be the default instance for that namespace.