django-url调度器-初级篇

　　Django 遵从 MVC 模型，并将其特色化为 MTV 模型。模型的核心是通过用户访问的 url 来指向处理的函数，而函数处理后返回相应的结果。所以url决定了用户访问的入口，另外表单处理的提交地址也需要指定的url。url是所有功能的入口，所以url的编写就变得非常重要。

　　Django 的 url 编写涉及了 python 的 re 模块，也就是正则表达式，这部分内容需要提前掌握。

　　本篇的内容将结合官方的1.8.2的文档进行说明，如果有说明不清的地方可以相应参照官方的文档，我这里提供一个进行中文翻译后的：戳这里

　　在进行编写的说明前，我先介绍一下django是如何处理一个请求的：

　　1.用户发来一个请求。Django将用户的请求报文等信息封装成HttpRequest对象，然后经过各种中间件处理后，抵达 url 模块进行处理函数的选择。

　　2.Django要决定使用哪个模块用作匹配，这个通常由 settings.py 中的 ROOT_URLCONF 的值决定，例如：ROOT_URLCONF = 'test_web.urls' 。就表示将使用 test_web（项目同名app）这个 app 下的 urls 这个模块文件( 这个模块也称为url的根模块，可修改 )。但如果进来的HttpRequest对象具有一个 urlconf 属性（通过中间件 request processing 设置），则使用这个值来替换 ROOT_URLCONF 设置。（可能会存在版本差异）

　　3.Django 加载该 Python 模块并寻找可用的 urlpatterns 变量。它是一个 Python 列表，里面的元素是 django.conf.urls.url() 的实例。

　　4.Django 按照正则匹配的方式，依次匹配每个URL 模式，在第一个与请求的URL 匹配的地方停下来(下面也符合的会被忽视)。

　　5.一旦其中的一个正则表达式匹配上，Django 将导入并调用给出的视图，它是一个简单的Python 函数（或者一个基于类的视图）。视图将获得如下参数:

　　　　a) 一个HttpRequest 实例（这也是为什么 view 函数的第一个参数要是 request，该实例封装了所有的 http 请求报文的信息）

　　　　b) 如果正则匹配的 url 中使用了括号分组，但却没有为分组进行命名，则使用位置参数的模式为view函数传参。

　　　　c) 如果是命名的分组，则使用关键字传参的方式。但是可以被django.conf.urls.url()的可选参数kwargs覆盖。

　　6.如果没有匹配到正则表达式，或者如果过程中抛出一个异常，Django 将调用一个适当的错误处理视图。

　　7.函数处理完毕，返回处理后的结果。

官方手册的例子：

from django.conf.urls import url

from . import views

urlpatterns = [

    url(r'^articles/2003/$', views.special_case_2003),

    url(r'^articles/([0-9]{4})/$', views.year_archive),

    url(r'^articles/([0-9]{4})/([0-9]{2})/$', views.month_archive),

    url(r'^articles/([0-9]{4})/([0-9]{2})/([0-9]+)/$', views.article_detail),

]

分析：

　　1.若要从 URL 中捕获一个值，只需要在它周围放置一对圆括号。（即正则中的分组匹配）

　　2.不需要添加一个前导的反斜杠，因为每个URL 都有。例如，应该是^articles 而不是 ^/articles。(django自动在域名后添加了/,这个默认行为可以进行改写)

　　3.每个正则表达式前面的'r' 是可选的但是建议加上。它告诉Python 这个字符串是“原始的” —— 字符串中任何字符都不应该转义。参见Dive Into Python 中的解释。

一些请求的例子：

　　/articles/2005/03/ 请求将匹配列表中的第三个模式。Django 将调用函数views.month_archive(request, '2005', '03')。

/articles/2005/3/ 不匹配任何URL 模式，因为列表中的第三个模式要求月份应该是两个数字。

/articles/2003/ 将匹配列表中的第一个模式不是第二个，因为模式按顺序匹配，第一个会首先测试是否匹配。请像这样自由插入一些特殊的情况来探测匹配的次序。

/articles/2003 不匹配任何一个模式，因为每个模式要求URL 以一个斜线结尾。

　 /articles/2003/03/03/ 将匹配最后一个模式。Django 将调用函数views.article_detail(request, '2003', '03', '03')。

命名组

　　上面的例子中，虽然实现了参数的传递，但是并没有我们熟知的关键字传参。要使用关键字传参，只有为分组命名就行了。例如：(?P<name>\d+),这个分组表示匹配一个或多个任意的数字，并以 name = 匹配到的数字，如 name = '123' 的方式传给view 函数。

　　但是，要注意一点，url 捕获的所以参数都是字符串类型，虽然 \d 在正则中表示匹配数字，但传参的时候，传的是字符串。例如，正则捕获的 123 ，但传参是 '123'。

官方例子

from django.conf.urls import url

from . import views

urlpatterns = [

    url(r'^articles/2003/$', views.special_case_2003),

    url(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),

    url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$', views.month_archive),

    url(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/(?P<day>[0-9]{2})/$', views.article_detail),
]

分析：

　　/articles/2005/03/ 请求将调用views.month_archive(request, year='2005', month='03')函数，而不是views.month_archive(request, '2005', '03')。

　　/articles/2003/03/03/ 请求将调用函数views.article_detail(request, year='2003', month='03', day='03')。

匹配/分组算法

下面是URLconf 解析器使用的算法，针对正则表达式中的命名组和非命名组：

　　1.如果有命名参数，则使用这些命名参数，忽略非命名参数。

　　2.否则，它将以位置参数传递所有的非命名参数。

　　根据传递额外的选项给视图函数（下文），这两种情况下，多余的关键字参数也将传递给视图。

注意：

　　1.一条 url 中，分组不能同名，否则报错。（初步测试）

　　2.所谓的有命名分组就使用命名参数，忽略非命名参数是下面这样的：

url(r'add/(\d+)/(?P<num1>\d+)/(?P<num2>\d+)/', add, name='add'),

def add(request, num1, num2):

    num1 = int(num1)

    num2 = int(num2)

    return HttpResponse(num1 + num2)

　　在这里，request 是 Httprequest，是 django 自动传递的，我们只要看 num1 和 num2 两个参数就可以的。这里我的处理函数除了 request 之外还需要 2 个参数，但是我在 url 中使用了三个分组，理论上应该会捕获 3 个参数。

　　但是，当我访问 http://127.0.0.1:8000/add/666/321/123/ 时，我得到的结果是：

　　aaarticlea/png;base64,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" alt="" />

　　另外，因为捕获的参数是字符串类型，所以我使用了 int() 函数进行类型转换，如果不这样的话：

def add(request, num1, num2):

    return HttpResponse(num1 + num2)

得到的结果就是：

aaarticlea/png;base64,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" alt="" />

　　字符串的拼接，所以说，捕获的参数都是字符串。

　　好了，回到正题。我的函数需要除了 request 之外的 2 个参数，但是我在 url 中捕获了三个，得到的结果是后面的两个命名组的参数，也就是多出来的被忽略了。

　　这就是所谓的当命名组存在的时候，非命名组会被忽略。

　　但是，我的 url 是这样写的：

 url(r'add/(\d+)/(?P<num2>\d+)/', add, name='add'),

　　我希望前面的未命名组按位置传给 num1 而 num2 使用关键字参数。

　　现在，我访问： http://127.0.0.1:8000/add/321/123/

aaarticlea/png;base64,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" alt="" />

　　报错的信息是，函数需要 3 个参数，而我们给了 2 个，其中，去除自动传递的 request，也就是我们只捕获到了 1 个参数。

　　此时，再看看这句活：当命名组存在时，会忽略非命名组。

　　因为非命名组捕获的参数被忽略了，所以才导致我们少传了一个参数。

　　这个时候，你应该知道这里的忽略是什么意思了吧。

URLconf 在什么上查找

　　请求的URL被看做是一个普通的Python 字符串， URLconf在其上查找并匹配。进行匹配时将不包括GET或POST请求方式的参数以及域名。

　　例如，http://www.example.com/myapp/请求中，URLconf 将查找myapp/。

　在http://www.example.com/myapp/?page=3 请求中，URLconf 仍将查找myapp/。

　　URLconf 不检查使用了哪种请求方法。换句话讲，所有的请求方法 —— 即，对同一个URL的无论是POST请求、GET请求、或HEAD请求方法等等 —— 都将匹配到相同的函数。

　　但是，我们能限制某个函数只能由某种方式访问，但这里不是 url 这里的内容了，以后再讲。

捕获的参数永远是字符串

　　关于这句话我在刚才的 num1 和 num2 相加的示例中已经演示过了，这里记住这句话就行了。

指定视图参数的默认值

　　这并不是 django 特有的用法，这是 python中的函数默认参数的内容。但是django这里能处理一些特殊的情况：

from django.conf.urls import url

from . import views

urlpatterns = [

    url(r'^blog/$', views.page),

    url(r'^blog/page(?P<num>[0-9]+)/$', views.page),
]

def page(request, num=""):

    ......

    return .....

　　在上面的例子中，两个URL模式指向同一个视图views.page —— 但是第一个模式不会从URL 中捕获任何值。如果第一个模式匹配，page() 函数将使用num参数的默认值"1"。如果第二个模式匹配，page() 将使用正则表达式捕获的 num 值。

性能

　　urlpatterns 中的每个正则表达式在第一次访问它们时被编译。这使得系统相当快。

urlpatterns 变量的语法

　　urlpatterns 应该是一个 python 列表，列表中存放的都是 url() 的实例。

错误处理

　　当Django 找不到一个匹配请求的 URL 的正则表达式时，或者当抛出一个异常时，Django 将调用一个错误处理视图。

　这些情况发生时使用的视图通过4个变量指定。它们的默认值应该满足大部分项目，但是通过赋值给它们以进一步的自定义也是可以的。

　　完整的细节请参见自定义错误视图。

　　这些值可以在你的根URLconf 中设置。在其它URLconf 中设置这些变量将不会生效果。

　　它们的值必须是可调用的或者是表示视图的Python 完整导入路径的字符串，可以方便地调用它们来处理错误情况。

这些值是：

handler404 —— 参见django.conf.urls.handler404。

handler500 —— 参见django.conf.urls.handler500。

handler403 —— 参见django.conf.urls.handler403。

handler400 —— 参见django.conf.urls.handler400。

　关于这部分我目前也在研究中，以后研究出结果再分享出来。