A clean, elegant URL scheme is an important detail in a high-quality Web\napplication. Django lets you design URLs however you want, with no framework\nlimitations.
\nThere's no .php or .cgi required, and certainly none of that\n0,2097,1-1-1928,00 nonsense.
See Cool URIs don't change, by World Wide Web creator Tim Berners-Lee, for\nexcellent arguments on why URLs should be clean and usable.
\nTo design URLs for an app, you create a Python module informally called a\nURLconf (URL configuration). This module is pure Python code and is a\nsimple mapping between URL patterns (simple regular expressions) to Python\nfunctions (your views).
\nThis mapping can be as short or as long as needed. It can reference other\nmappings. And, because it's pure Python code, it can be constructed\ndynamically.
\nDjango also provides a way to translate URLs according to the active\nlanguage. See the internationalization documentation for more information.
\nWhen a user requests a page from your Django-powered site, this is the\nalgorithm the system follows to determine which Python code to execute:
\nDjango determines the root URLconf module to use. Ordinarily,\nthis is the value of the ROOT_URLCONF setting, but if the incoming\nHttpRequest object has a urlconf\nattribute (set by middleware), its value will be used in place of the\nROOT_URLCONF setting.
Django loads that Python module and looks for the variable\nurlpatterns. This should be a Python list of django.conf.urls.url()\ninstances.
Django runs through each URL pattern, in order, and stops at the first\none that matches the requested URL.
Once one of the regexes matches, Django imports and calls the given view,\nwhich is a simple Python function (or a class-based view). The view gets passed the following\narguments:
\nAn instance of HttpRequest.
If the matched regular expression returned no named groups, then the\nmatches from the regular expression are provided as positional arguments.
The keyword arguments are made up of any named groups matched by the\nregular expression, overridden by any arguments specified in the optional\nkwargs argument to django.conf.urls.url().
If no regex matches, or if an exception is raised during any\npoint in this process, Django invokes an appropriate\nerror-handling view. See Error handling below.
Here's a sample URLconf:
\nfrom django.conf.urls import url\n\nfrom . import views\n\nurlpatterns = [\n url(r'^articles/2003/$', views.special_case_2003),\n url(r'^articles/([0-9]{4})/$', views.year_archive),\n url(r'^articles/([0-9]{4})/([0-9]{2})/$', views.month_archive),\n url(r'^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail),\n]\nNotes:
\nTo capture a value from the URL, just put parenthesis around it.
There's no need to add a leading slash, because every URL has that. For\nexample, it's ^articles, not ^/articles.
The 'r' in front of each regular expression string is optional but\nrecommended. It tells Python that a string is "raw" -- that nothing in\nthe string should be escaped. See Dive Into Python's explanation.
Example requests:
\nA request to /articles/2005/03/ would match the third entry in the\nlist. Django would call the function\nviews.month_archive(request, '2005', '03').
/articles/2005/3/ would not match any URL patterns, because the\nthird entry in the list requires two digits for the month.
/articles/2003/ would match the first pattern in the list, not the\nsecond one, because the patterns are tested in order, and the first one\nis the first test to pass. Feel free to exploit the ordering to insert\nspecial cases like this. Here, Django would call the function\nviews.special_case_2003(request)
/articles/2003 would not match any of these patterns, because each\npattern requires that the URL end with a slash.
/articles/2003/03/03/ would match the final pattern. Django would call\nthe function views.article_detail(request, '2003', '03', '03').
The above example used simple, non-named regular-expression groups (via\nparenthesis) to capture bits of the URL and pass them as positional arguments\nto a view. In more advanced usage, it's possible to use named\nregular-expression groups to capture URL bits and pass them as keyword\narguments to a view.
\nIn Python regular expressions, the syntax for named regular-expression groups\nis (?P<name>pattern), where name is the name of the group and\npattern is some pattern to match.
Here's the above example URLconf, rewritten to use named groups:
\nfrom django.conf.urls import url\n\nfrom . import views\n\nurlpatterns = [\n url(r'^articles/2003/$', views.special_case_2003),\n url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),\n url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$', views.month_archive),\n url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/(?P<day>[0-9]{2})/$', views.article_detail),\n]\nThis accomplishes exactly the same thing as the previous example, with one\nsubtle difference: The captured values are passed to view functions as keyword\narguments rather than positional arguments. For example:
\nA request to /articles/2005/03/ would call the function\nviews.month_archive(request, year='2005', month='03'), instead\nof views.month_archive(request, '2005', '03').
A request to /articles/2003/03/03/ would call the function\nviews.article_detail(request, year='2003', month='03', day='03').
In practice, this means your URLconfs are slightly more explicit and less prone\nto argument-order bugs -- and you can reorder the arguments in your views'\nfunction definitions. Of course, these benefits come at the cost of brevity;\nsome developers find the named-group syntax ugly and too verbose.
\nHere's the algorithm the URLconf parser follows, with respect to named groups\nvs. non-named groups in a regular expression:
\nIf there are any named arguments, it will use those, ignoring non-named\narguments.
Otherwise, it will pass all non-named arguments as positional arguments.
In both cases, any extra keyword arguments that have been given as per Passing\nextra options to view functions (below) will also be passed to the view.
\nThe URLconf searches against the requested URL, as a normal Python string. This\ndoes not include GET or POST parameters, or the domain name.
\nFor example, in a request to https://www.example.com/myapp/, the URLconf\nwill look for myapp/.
In a request to https://www.example.com/myapp/?page=3, the URLconf will look\nfor myapp/.
The URLconf doesn't look at the request method. In other words, all request\nmethods -- POST, GET, HEAD, etc. -- will be routed to the same\nfunction for the same URL.
Each captured argument is sent to the view as a plain Python string, regardless\nof what sort of match the regular expression makes. For example, in this\nURLconf line:
\nurl(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),\nyear argument passed to views.year_archive() will be a string,not an integer, even though the [0-9]{4} will only match integer strings.
A convenient trick is to specify default parameters for your views' arguments.\nHere's an example URLconf and view:
\n# URLconf\nfrom django.conf.urls import url\n\nfrom . import views\n\nurlpatterns = [\n url(r'^blog/$', views.page),\n url(r'^blog/page(?P<num>[0-9]+)/$', views.page),\n]\n\n# View (in blog/views.py)\ndef page(request, num="1"):\n # Output the appropriate page of blog entries, according to num.\n ...\nIn the above example, both URL patterns point to the same view --\nviews.page -- but the first pattern doesn't capture anything from the\nURL. If the first pattern matches, the page() function will use its\ndefault argument for num, "1". If the second pattern matches,\npage() will use whatever num value was captured by the regex.
Each regular expression in a urlpatterns is compiled the first time it's\naccessed. This makes the system blazingly fast.
urlpatterns variableLink to this heading#urlpatterns should be a Python list of url()\ninstances.
When Django can't find a regex matching the requested URL, or when an\nexception is raised, Django will invoke an error-handling view.
\nThe views to use for these cases are specified by four variables. Their\ndefault values should suffice for most projects, but further customization is\npossible by overriding their default values.
\nSee the documentation on customizing error views for the full details.
\nSuch values can be set in your root URLconf. Setting these variables in any\nother URLconf will have no effect.
\nValues must be callables, or strings representing the full Python import path\nto the view that should be called to handle the error condition at hand.
\nThe variables are:
\nhandler400 -- See django.conf.urls.handler400.
handler403 -- See django.conf.urls.handler403.
handler404 -- See django.conf.urls.handler404.
handler500 -- See django.conf.urls.handler500.
いずれの時点でも、urlpatterns は他の URLconf モジュールを "含む (インクルードする)" ことができます。これは基本的に、他の URL パターンに定義されている URL のセットを探索します。
例えば、以下は Django website 自体に対する URLconf の引用です。これは複数の他の URLconfs をインクルードしています:
\nfrom django.conf.urls import include, url\n\nurlpatterns = [\n # ... snip ...\n url(r'^community/', include('django_website.aggregator.urls')),\n url(r'^contact/', include('django_website.contact.urls')),\n # ... snip ...\n]\nこの例の正規表現には $ (最終文字列一致の文字) はありませんが、末尾にスラッシュが含まれています。 Django は include() (django.conf.urls.include()) に出会うたびに、そのポイントまでに一致した URL の部分を切り捨て、残りの文字列をさらなる処理のためにインクルードされている URLconf に送信します。
他の方法として、url() インスタンスのリストを使うことによって追加的な URL をインクルードすることもできます。例えば、以下の URLconf を考えます:
from django.conf.urls import include, url\n\nfrom apps.main import views as main_views\nfrom credit import views as credit_views\n\nextra_patterns = [\n url(r'^reports/$', credit_views.report),\n url(r'^reports/(?P<id>[0-9]+)/$', credit_views.report),\n url(r'^charge/$', credit_views.charge),\n]\n\nurlpatterns = [\n url(r'^$', main_views.homepage),\n url(r'^help/', include('apps.help.urls')),\n url(r'^credit/', include(extra_patterns)),\n]\nこの例では、/credit/reports/ という URL は credit_views.report() というビューによって処理されます。
これを使うと、単一のパターンの接頭辞が繰り返し使われるような URLconfs の冗長さを回避できます。例えば、以下の URLconf を考えてみます:
\nfrom django.conf.urls import url\nfrom . import views\n\nurlpatterns = [\n url(r'^(?P<page_slug>[\\w-]+)-(?P<page_id>\\w+)/history/$', views.history),\n url(r'^(?P<page_slug>[\\w-]+)-(?P<page_id>\\w+)/edit/$', views.edit),\n url(r'^(?P<page_slug>[\\w-]+)-(?P<page_id>\\w+)/discuss/$', views.discuss),\n url(r'^(?P<page_slug>[\\w-]+)-(?P<page_id>\\w+)/permissions/$', views.permissions),\n]\nこれは、パスの共通部分である接頭辞を一度だけ記述し、異なる接尾辞を以下のようにグループ化することで改善できます:
\nfrom django.conf.urls import include, url\nfrom . import views\n\nurlpatterns = [\n url(r'^(?P<page_slug>[\\w-]+)-(?P<page_id>\\w+)/', include([\n url(r'^history/$', views.history),\n url(r'^edit/$', views.edit),\n url(r'^discuss/$', views.discuss),\n url(r'^permissions/$', views.permissions),\n ])),\n]\nインクルードされた URLconf は親 URLconfs から取り込まれた全てのパラメータを受け取るので、以下の例は有効となります:
\n# In settings/urls/main.py\nfrom django.conf.urls import include, url\n\nurlpatterns = [\n url(r'^(?P<username>\\w+)/blog/', include('foo.urls.blog')),\n]\n\n# In foo/urls/blog.py\nfrom django.conf.urls import url\nfrom . import views\n\nurlpatterns = [\n url(r'^$', views.blog.index),\n url(r'^archive/$', views.blog.archive),\n]\n上の例では、取り込まれた "username" 変数はインクルードされたURLconf に渡されます。
正規表現ではネストされた引数を使うことができ、Django はこれらを解決してビューに渡します。このとき、Django は全ての外側のキャプチャされた引数を埋めようとし、ネストされたキャプチャされた引数を無視します。任意でページ引数を取る以下の URL パターンを考えてみます:
\nfrom django.conf.urls import url\n\nurlpatterns = [\n url(r'blog/(page-(\\d+)/)?$', blog_articles), # bad\n url(r'comments/(?:page-(?P<page_number>\\d+)/)?$', comments), # good\n]\n両方のパターンでネストされた引数を使っており、解決します: 例えば、 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の部分を渡す必要があるため、解決するときにはさらに顕著になります。
経験則として、正規表現が引数を必要とする一方でビューがそれを無視するときには、ビューが必要とする値だけをキャプチャして、キャプチャしない引数を使ってください。
\nURLconfs は、Ptyhon のディクショナリとして、ビュー関数に追加の引数を引き渡せるようにするフックを持っています。
\ndjango.conf.urls.url() 関数は、省略可能な第3引数を取ることができます。この引数は、ビュー関数に引き渡す追加的なキーワード引数のディクショナリである必要があります。
For example:
\nfrom django.conf.urls import url\nfrom . import views\n\nurlpatterns = [\n url(r'^blog/(?P<year>[0-9]{4})/$', views.year_archive, {'foo': 'bar'}),\n]\nこの例では、/blog/2005/ へのリクエストに対して、Django は views.year_archive(request, year='2005', foo='bar') を呼び出します。
このテクニックは 配信フィードフレームワーク で使われ、メタデータとオプションをビューに引き渡します。
\n\ninclude() に追加のオプションを引き渡すLink to this heading#同じように、include() に対して追加のオプションを引き渡すこともできます。include() に追加のオプションを引き渡すとき、インクルードされた URLconf 内の それぞれの 行に追加のオプションが渡されます。
例えば、以下の 2 つの URLconf のセットはまったく同じように機能します:
\nセット 1:
\n# main.py\nfrom django.conf.urls import include, url\n\nurlpatterns = [\n url(r'^blog/', include('inner'), {'blogid': 3}),\n]\n\n# inner.py\nfrom django.conf.urls import url\nfrom mysite import views\n\nurlpatterns = [\n url(r'^archive/$', views.archive),\n url(r'^about/$', views.about),\n]\nセット 2:
\n# main.py\nfrom django.conf.urls import include, url\nfrom mysite import views\n\nurlpatterns = [\n url(r'^blog/', include('inner')),\n]\n\n# inner.py\nfrom django.conf.urls import url\n\nurlpatterns = [\n url(r'^archive/$', views.archive, {'blogid': 3}),\n url(r'^about/$', views.about, {'blogid': 3}),\n]\n行のビューが実際にそれらのオプションを有効として受け入れるかどうかに関わらず、追加のオプションが 常に インクルードされている URLconfの すべての 行に引き渡されることに注意してください。 このため、このテクニックは、インクルードされた URLconf のすべてのビューが、引き渡される追加のオプションを受け入れることが確実である場合にのみ役立ちます。
\nDjango プロジェクトで作業するときの一般的なニーズとして、生成されたコンテンツ (ビューとアセットのURL、ユーザーに表示されるURLなど) への埋め込み、またはサーバーサイドでのナビゲーションフローの処理 (リダイレクトなど) のどちらかに対して、最終的なフォーム内で URL を取得することが挙げられます。
\nこうした URL のハードコーディング (手間がかかり、スケールしにくく、誤りが起こりやすい戦略) は、避けることが強く望まれます。 同様に危険なのは、URLconf で記述された設計と並行して URL を生成するような一時的な仕組みを考え出してしまうことです。これは、時間の経過とともに古くて使えない URL が生成されてしまう原因となります。
\n言い換えると、必要なのはDRYな仕組みです。 数々の利点の中でも、これは URL 設計が進化していけるようにします。プロジェクトソースコードを全て検索して古い URL を置換する必要はありません。
\nThe primary piece of information we have available to get a URL is an\nidentification (e.g. the name) of the view in charge of handling it. Other\npieces of information that necessarily must participate in the lookup of the\nright URL are the types (positional, keyword) and values of the view arguments.
\nDjango provides a solution such that the URL mapper is the only repository of\nthe URL design. You feed it with your URLconf and then it can be used in both\ndirections:
\nStarting with a URL requested by the user/browser, it calls the right Django\nview providing any arguments it might need with their values as extracted from\nthe URL.
Starting with the identification of the corresponding Django view plus the\nvalues 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\nsecond one is what is known as reverse resolution of URLs, reverse URL\nmatching, reverse URL lookup, or simply URL reversing.
\nDjango provides tools for performing URL reversing that match the different\nlayers where URLs are needed:
\nIn 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:\nThe get_absolute_url() method.
Consider again this URLconf entry:
\nfrom django.conf.urls import url\n\nfrom . import views\n\nurlpatterns = [\n #...\n url(r'^articles/([0-9]{4})/$', views.year_archive, name='news-year-archive'),\n #...\n]\nAccording to this design, the URL for the archive corresponding to year nnnn\nis /articles/nnnn/.
You can obtain these in template code by using:
\n<a href="{% url 'news-year-archive' 2012 %}">2012 Archive</a>\n{# Or with the year in a template context variable: #}\n<ul>\n{% for yearvar in year_list %}\n<li><a href="{% url 'news-year-archive' yearvar %}">{{ yearvar }} Archive</a></li>\n{% endfor %}\n</ul>\nOr in Python code:
\nfrom django.urls import reverse\nfrom django.http import HttpResponseRedirect\n\ndef redirect_to_year(request):\n # ...\n year = 2006\n # ...\n return HttpResponseRedirect(reverse('news-year-archive', args=(year,)))\nIf, for some reason, it was decided that the URLs where content for yearly\narticle archives are published at should be changed then you would only need to\nchange the entry in the URLconf.
\nIn some scenarios where views are of a generic nature, a many-to-one\nrelationship might exist between URLs and views. For these cases the view name\nisn't a good enough identifier for it when comes the time of reversing\nURLs. Read the next section to know about the solution Django provides for this.
\nURL のリバースを処理するためには、上述の例で行ったように 名前をつけられた URL パターン を使う必要があります。URL 名として使う文字列には、どんな文字でも含めることができます。Python の有効な名前に制限を受けません。
\nURL パターンに名前をつけるときは、他のアプリケーションの名前の選択と競合しないようにしてください。例えばあなたが URL パターン comment を使い、別のアプリケーションが同じ名前を使った場合、この名前を使ったときにテンプレートにどの URL が使うかは保証されません。
URL名にプレフィックス (おそらくアプリケーション名から派生したもの) を付けると、競合の可能性が低くなります。 comment ではなく myapp-comment のようなものをお勧めします。
URL の名前空間は、別のアプリケーションが同じ URL 名を使っている場合でも <naming-url-patterns>` をユニークにリバースできるようにします。(私たちがチュートリアルで行ったように) サードパーティ製のアプリケーションが常に名前空間を使った URL を使っているのがいい例です。同じように、アプリケーションの複数のインスタンスがデプロイされているときでも、URL がリバースできるようになります。言い換えると、単一のアプリケーションの複数のインスタンスは名前のついた URL を共有するので、名前空間は名前のついた URL を区別する方法を提供します。
\nURL の名前空間を適切に使用する Django アプリケーションは、特定のサイトに対して何回でもデプロイできます。 たとえば django.contrib.admin には AdminSite クラスがあり、簡単に admin のインスタンスを複数回デプロイ することができます。後者の例では、2 つの異なるユーザー (著者と出版者) に同じ機能を提供できるよう、チュートリアルで扱った polls アプリケーションを例に、2 つの異なる場所にデプロイするという考え方について説明します。
URL の名前空間は 2 つの部分に分かれ、両方とも文字列で表されます:
\nデプロイされているアプリケーションの名前を示します。 単一のアプリケーションのすべてのインスタンスは、同一のアプリケーション名前空間を持ちます。 例えば、Django の admin アプリケーションには、'admin' という比較的分かりやすいアプリケーション名前空間を持っています。
アプリケーションの特定のインスタンスを識別します。 インスタンス名前空間は、プロジェクト全体で一意である必要があります。ただし、インスタンス名前空間は、アプリケーション名前空間と同じにすることができます。これは、アプリケーションのデフォルトインスタンスを指定するために使用されます。 例えば、デフォルトの Django admin インスタンスは 'admin' というインスタンス名前空間を持っています。
名前空間の URL は、 ':' 演算子を使って指定します。 たとえば、admin アプリケーションのメインインデックスページは 'admin:index' で参照されます。 これは 'admin' という名前空間と 'index' という名前の URL を示します。
名前空間はネストすることもできます。 名前付きの URL 'sports:polls:index' は、トップレベルの名前空間 'sports' 内で定義されている名前空間 'polls' 内で 'index' と名前がつけられたパターンを探します。
名前空間の URL (例: 'polls:index') が与えられると、Django 完全修飾名をパーツに分割し、以下のルックアップを試みます:
まず最初に、Django は アプリケーションの名前空間 (ここでは 'polls') との一致を検索します。これは、このアプリケーションのインスタンスのリストを生成します。
現在のアプリケーションが定義されている場合、Django はそのインスタンスに対して URL リゾルバを探し出し、返します。現在のアプリケーションは reverse() 関数への current_app 引数で指定できます。
url テンプレートタグは、RequestContext 内で現在のアプリケーションとされているビューの名前空間を使います。このデフォルト設定は、request.current_app 属性で現在のアプリケーションを設定することでオーバーライドできます。
現在のアプリケーションがない場合、Django はデフォルトのアプリケーションインスタンスを探します。デフォルトのアプリケーションインスタンスは、アプリケーション名前空間 と一致する インスタンス名前空間 を持つインスタンスです。 (ここでは 'polls' と呼ばれる polls のインスタンスです).
デフォルトのアプリケーションインスタンスがない場合、Django は、そのインスタンス名が何であれ、アプリケーションの最後にデプロイされたインスタンスを利用します。
提供された名前空間がステップ 1 の application namespace と一致しない場合、Django は名前空間のルックアップを instance namespace として直接試みます。
ネストされた名前空間がある場合、これらのステップはビューの名前のみが未解決になるまで名前空間の各パートに対して繰り返されます。その後に、このビュー名は見つかった名前空間内の URL として解決されます。
\n実際の名前解決戦略を示すため、チュートリアルで扱った polls アプリケーションの 2 つのインスタンスの例を考えてみましょう: 1 つは 'author-polls'、もう 1 つは 'publisher-polls' と名付けられています。polls を作成して表示するときにインスタンス名前空間を考慮するように、そのアプリケーションを拡張したとします。
urls.pyfrom django.conf.urls import include, url\n\nurlpatterns = [\n url(r'^author-polls/', include('polls.urls', namespace='author-polls')),\n url(r'^publisher-polls/', include('polls.urls', namespace='publisher-polls')),\n]\npolls/urls.pyfrom django.conf.urls import url\n\nfrom . import views\n\napp_name = 'polls'\nurlpatterns = [\n url(r'^$', views.IndexView.as_view(), name='index'),\n url(r'^(?P<pk>\\d+)/$', views.DetailView.as_view(), name='detail'),\n ...\n]\nこの設定を使うことで、以下のルックアップが可能となります:
\nインスタンスの 1 つが現在参照されている場合 - インスタンス 'author-polls' 内の詳細ページをレンダリングしているとしましょう - 'polls:index' は 'author-polls' インスタンスのインデックスページを解決します; 例えば 以下の両方とも``"/author-polls/"`` となります。
クラスベースビューのメソッド内:
\nreverse('polls:index', current_app=self.request.resolver_match.namespace)\nテンプレート内:
\n{% url 'polls:index' %}\n現在のインスタンスがない場合 - サイト上のどこか他のページをレンダリングしているとしましょう - 'polls:index' は polls の最後に登録されたインスタンスとして名前解決します。デフォルトのインスタンス ('polls' のインスタンス名前空間) が存在しないため、登録された polls の最後のインスタンスが使われます。urlpatterns 内で最後に明言されているので、'publisher-polls' となります。
'author-polls:index' は、常に 'author-polls' のインスタンスのインデックスページに名前解決します (そして 'publisher-polls' に対しても同じです) .
デフォルトのインスタンスもある場合 - 例えば 'polls' と名前がつけられたインスタンス - 上記とのいい角違いは現在のインスタンスがない場合です (上記のリストの 2 番目の項目)。ここでは、'polls:index' は urlpatterns 内で最後に明言されたインスタンスの代わりにデフォルトのインスタンスのインデックスページに名前解決します。
インクルードされた URLconfs のアプリケーション名前空間は、2 つの方法で指定することができます。
\n1 つめは、インクルードされた URLconf で app_name 属性をセットする方法で、これは urlpatterns 属性と同じレベルに記述します。urlpatterns のリスト自体ではなく、実際のモジュールないし include() への文字列参照に対して引き渡す必要があります。
polls/urls.pyfrom django.conf.urls import url\n\nfrom . import views\n\napp_name = 'polls'\nurlpatterns = [\n url(r'^$', views.IndexView.as_view(), name='index'),\n url(r'^(?P<pk>\\d+)/$', views.DetailView.as_view(), name='detail'),\n ...\n]\nurls.pyfrom django.conf.urls import include, url\n\nurlpatterns = [\n url(r'^polls/', include('polls.urls')),\n]\npolls.urls 内で定義された URL は、アプリケーション名前空間 polls を持ちます。
2つめは、埋め込みの名前空間データを含むオブジェクトをインクルードする方法です。url() インスタンスのリストを include() する場合、このオブジェクトに含まれる URL はグローバルの名前空間に含まれるようになります。ただし、以下を含む 2- タプルを include() することもできます:
(<list of url() instances>, <application namespace>)\nFor example:
\nfrom django.conf.urls import include, url\n\nfrom . import views\n\npolls_patterns = ([\n url(r'^$', views.IndexView.as_view(), name='index'),\n url(r'^(?P<pk>\\d+)/$', views.DetailView.as_view(), name='detail'),\n], 'polls')\n\nurlpatterns = [\n url(r'^polls/', include(polls_patterns)),\n]\nこれは、与えられたアプリケーション名前空間に、ノミネートされた URL パターンをインクルードします。
\nインスタンスの名前空間は、func:~django.conf.urls.include に namespace 引数を使うことで指定できます。 インスタンス名前空間が指定されていない場合、インクルードされた URLconf のアプリケーション名前空間がデフォルトとなります。これは、この名前空間に対するデフォルトのインスタンスにもなることを意味します。