Django：URL映射

版权声明：本文为 [onefine] 原创文章，转载请注明出处： https://blog.csdn.net/jiduochou963/article/details/87116562

导航

跳转：视图简介

跳转：URL映射

跳转：一、URL中添加参数

跳转：二、指定默认的参数

跳转：三、URL中包含另一个urls模块

跳转：  include函数

跳转：四、path函数

跳转：  自定义url转换器

跳转：五、re_path函数

跳转：六、url反转

跳转：  反转时传递参数

---

视图简介

视图一般都写在app的views.py中。并且视图的第一个参数一般定义为request（一个HttpRequest）对象。这个对象存储了请求过来的所有信息，包括携带的参数以及一些头部信息等。

在视图中，一般是完成逻辑相关的操作。比如这个请求是添加一篇博客，那么可以通过request来接收到这些数据，然后存储到数据库中，最后再把执行的结果返回给浏览器。

视图函数的返回结果必须是 django.http.HttpResponseBase 对象或者子类的对象。

from django.http import HttpResponse
def book_list(request):
	return HttpResponse("书籍列表！ ")

返回顶部

---

URL映射

视图写完后，要与URL进行映射，也即用户在浏览器中输入什么 url 的时候可以请求到这个视图函数。在用户输入了某个 url ，请求到我们的网站的时候， django 会从项目的urls.py文件中寻找对应的视图。

为什么默认首先会去urls.py文件中寻找url映射呢？是因为在settings.py文件中有配置：

ROOT_URLCONF = 'djangoProjectName.urls'

ROOT_URLCONF配置了项目下的urls.py文件为url映射，所以Django会去urls.py中寻找。

在urls.py文件中有一个urlpatterns变量，以后 django 就会从这个变量中读取所有的匹配规则。

所有的映射匹配规则使用path函数或者re_path函数进行包裹，这个函数会根据传入的参数返回URLPattern或者是URLResolver的对象。

示例代码如下：

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

urlpatterns = [
	path('admin/', admin.site.urls),
	path('book/',views.book_list)
]

返回顶部

---

一、URL中添加参数

1、采用在url中使用变量的方式：在path的第一个参数中，使用<参数名>的方式可以传递参数。然后在视图函数中也要写一个参数，视图函数中的参数必须和url中的参数名称保持一致，不然就找无法获取这个参数。另外，url中当然可以传递多个参数。

2、采用查询字符串的方式：在url中，不需要单独的匹配查询字符串的部分。只需要在视图函数中使用request.GET.get(‘参数名称’)的方式来获取。

因为查询字符串使用的是GET请求，所以我们通过request.GET来获取参数，并且因为GET是一个类似于字典的数据类型，所以获取值跟字典的方式相似：

有时候，url 中包含了一些参数需要动态调整。比如简书某篇文章的详情页的url,如https://www.jianshu.com/p/a5aab9c4978e后面的a5aab9c4978e就是这篇文章的id，那么简书的文章详情页面的url就可以写成 https://www.jianshu.com/p/<id> ，其中id就是文章的id。那么如何在django中实现这种需求呢。这时候我们可以在 path 函数中，使用尖括号的形式来定义一个参数。比如我现在想要获取一本书籍的详细信息，那么应该在 url 中指定这个参数。示例代码如下：

from django.contrib import admin
from django.urls import path
from book import views
urlpatterns = [
	path('admin/', admin.site.urls),
	path('book/',views.book_list),
	
	path('book/<book_id>/',views.book_detail)
]

而 views.py 中的代码如下：

def book_detail(request,book_id):
	text = "您输入的书籍的id是： %s" % book_id
	return HttpResponse(text)

同理，path('book/<book_id>/<category_id>/',views.book_detail)将需要传递两个参数

注意，视图函数形参名称book_id应该和URL映射中的名称保持一致。

---

当然，也可以通过查询字符串的方式传递一个参数过去。示例代码如下：

urlpatterns = [
	path('admin/', admin.site.urls),
	path('book/',views.book_list),
	path('book/detail/',views.book_detail)
]

在 views.py 中的代码如下：

def book_detail(request):
	book_id = request.GET.get("id")
	# 效果一样：
	# 因为查询字符串使用的是`GET`请求，所以通过`request.GET`来获取参数，并且因为GET是一个类似于字典的数据类型，使用获取值的方式跟字典是一样的，即`request.GET['']`
	# book_id = request.GET["id"]
	text = "您输入的书籍id是： %s" % book_id
	return HttpResponse(text)

以后在访问的时候就是通过/book/detail/?id=1即可将参数id传递过去。

返回顶部

---

二、指定默认的参数

使用path或者是re_path后，在 route 中都可以包含参数，而有时候想指定默认的参数，这时候可以通过以下方式来完成。

from django.urls import path
from . import views
urlpatterns = [
	path('blog/', views.page),
	path('blog/page<int:num>/', views.page),
]

在视图函数中：

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

当在访问blog/的时候，因为没有传递num参数，所以会匹配到第一个url，这时候就执行view.page这个视图函数，而在 page 函数中，又有 num=1 这个默认参数。因此这时候就可以不用传递参数。而如果访问blog/1的时候，因为在传递参数的时候传递了num，因此会匹配到第二个url ，这时候也会执行views.page，然后把传递进来的参数传给 page 函数中的 num 。总之这里无论有没有传递num参数，都是执行视图函数中的page函数。

返回顶部

---

三、URL中包含另一个urls模块

在我们的项目中，不可能只有一个 app ，如果把所有的 app 的 views 中的视图都放在 urls.py 中进行映射，肯定会让代码显得非常乱。因此 django 给我们提供了一个方法，可以在 app 内部包含自己的 url 匹配规则，而在项目的 urls.py 中再统一包含这个 app 的 urls 。使用这个技术需要借助include函数。示例代码如下：

# first_project/urls.py文件：
from django.contrib import admin
from django.urls import path,include

urlpatterns = [
	path('admin/', admin.site.urls),
	path('book/',include("book.urls"))
]

在 urls.py 文件中把所有的和 book 这个 app 相关的 url 都移动到 app/urls.py 中了，然后在 first_project/urls.py 中，通过 include 函数包含 book.urls ，以后在请求 book 相关的url的时候都需要加一个 book 的前缀。

# book/urls.py文件：
from django.urls import path
from . import views
urlpatterns = [
	path('list/',views.book_list),
	path('detail/<book_id>/',views.book_detail)
]

以后访问书的列表的url的时候，就通过/book/list/来访问，访问书籍详情页面的 url 的时候就通过book/detail/<id>来访问。

注意：url是会根据主urls.py和app中的urls.py进行拼接的，因此注意不要多加斜杠。

返回顶部

---

include函数

在项目变大以后，经常不会把所有的url匹配规则都放在项目的urls.py文件中，而是每个app都建立自己的urls.py文件，在这个文件中存储的都是当前这个app的所有url匹配规则。然后再统一注册到项目的urls.py文件中。

用法一：include(pattern, namespace=None)

• pattern：子url的模块字符串
• namespace：实例命名空间

直接把其他app的urls包含进来。示例代码如下：

from django.contrib import admin
from django.urls import path,include
urlpatterns = [
	path('admin/', admin.site.urls),
	path('book/',include("book.urls"))
]

当然也可以传递namespace参数来指定一个实例命名空间（默认为None），但是在使用实例命名空间之前，必须先指定一个应用命名空间——在子url.py中添加app_name变量：

在子urls.py中即movie/urls.py中指定应用命名空间：

from django.urls import path
from . import views
# 子urls.py文件中指定 应用命名空间
app_name = 'movie'

urlpatterns = [
	path('',views.movie,name='index'),
	path('list/',views.movie_list,name='list'),
]

主urls.py文件：

from django.urls import path,include
urlpatterns = [
	path('movie/',include('movie.urls',namespace='movie')),
]

关于应用命名空间与实例命名空间的更详细用法，请参阅：https://blog.csdn.net/jiduochou963/article/details/87130352

---

用法二：include(pattern_list)

可以包含一个列表，这个列表中包含的是path或者是re_path函数。用法如下：

path('movie/', include([
    path('',views.movie),
    path('list/', views.movie_list),

]))

用法三：include((pattern, app_namespace), namespace=None)

在包含某个app的urls的时候，可以指定应用(app)命名空间，这样做的目的是为了防止不同的app下出现相同的url。

include函数的第一个参数可以为一个元组——元组的第一个参数是url.py模块的字符串，元组的第二个参数是应用命名空间。也就是说，应用命名空间既可以在子url.py中通过app_name指定，也可以通过这种方式在include函数中指定。

from django.contrib import admin
from django.urls import path, include
urlpatterns = [
	path('admin/', admin.site.urls),
	path('book/', include(("book.urls", 'book')), namespace='book')
]

返回顶部

---

四、path函数

path 函数的定义为：

path(route, view, name=None, kwargs=None) 

以下对这几个参数进行讲解。

1、route参数： url 的匹配规则。这个参数中可以指定 url 中需要传递的参数，比如在访问文章详情页的时候，可以传递一个 id 。传递参数是通过<>尖括号来进行指定的。并且在传递参数的时候，可以指定这个参数的数据类型，比如文章的 id 都是 int 类型，那么可以这样写<int:id>，以后匹配的时候，就只会匹配到 id 为 int 类型的 url 而不会匹配其他的，并且在视图函数中获取这个参数的时候，就已经被转换成一个 int 类型了。

以下是几种常用的类型——Django内置的URL转换器：

类型	说明
str	非空的字符串类型，不能包含斜杠。。默认的转换器。 对应正则表达式：regex = '[^/]+'
int	匹配任意的零或者正数的整形。到视图函数中就是一个int类型。 对应正则表达式：regex = '[0-9]+'
slug	由英文中的横杠-，或者下划线_连接英文字符或者数字而成的字符串。 对应正则表达式：regex = '[-a-zA-Z0-9_]+'
uuid	匹配uuid字符串。 对应正则表达式：regex = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}'
path	匹配非空的英文字符串，可以包含斜杠。 对应正则表达式：regex = '.+'

用法：

# urls.py
path('book/publisher/<int:book_id>/', views.book_detail)

# views.py
def book_detail(request, book_id):
    pass

在django.urls.converters.py中定义了这些内置的url转换器

DEFAULT_CONVERTERS = {
    'int': IntConverter(),
    # regex = '[0-9]+'
    'path': PathConverter(),
    # regex = '.+'
    'slug': SlugConverter(),
    # regex = '[-a-zA-Z0-9_]+'
    'str': StringConverter(),
    # regex = '[^/]+'
    'uuid': UUIDConverter(),
    # regex = '[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}'
    # 满足uuid.uuid4()这个函数返回的字符串的格式
}

以int的实现为例：

class IntConverter:
    regex = '[0-9]+'

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

    def to_url(self, value):
        return str(value)

2、view参数：可以为一个视图函数或者是 类视图.as_view() 或者是 django.urls.include() 函数的返回值。

3、name参数：这个参数是给这个 url 取个名字的，这在项目比较大， url 比较多的时候用处很大。

4、kwargs参数：有时候想给视图函数传递一些额外的参数，就可以通过 kwargs 参数进行传递。这个参数接收一个字典。传到视图函数中的时候，会作为一个关键字参数传过去。

比如以下的 url 规则：

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

那么以后在访问blog/1991/这个url的时候，会将foo=bar作为关键字参数传给 year_archive 函数。

返回顶部

---

自定义url转换器

正如之前的django内置url转换器，包括有 int 、 uuid 等。有时候这些内置的url转换器并不能满足我们的需求，因此django给我们提供了一个接口可以让我们自己定义自己的url转换器。
自定义 url 转换器按照以下五个步骤来走就可以了：

1. 定义一个类。
2. 在类中定义一个属性regex，这个属性是用来保存url转换器规则的正则表达式。
3. 实现to_python(self,value)方法，这个方法是将url中的值转换一下，然后传给视图函数的。
4. 实现to_url(self,value)方法，这个方法是在做url反转的时候，将传进来的参数转换后拼接成一个正确的url。
5. 将定义好的转换器，注册到django中。

比如写一个指定分类文章的转换器，用户可以根据/articles/文章分类/的方式来获取文章，其中文章分类采用的是分类1+分类2+分类3...的方式来拼接的，并且如果只有一个分类，那就不需要+：

re_path(r'list/(?P<categories>\w+|(\w+\+\w+)+)/', views.article_list, name='list')

如果自定义url转换器该怎么做呢？

新建converters.py文件：

from django.urls import register_converter, converters

# 自定义URL转换器的类
class SelfConverter(object):
	# 定义正则表达式
    regex = '\w+|(\w+\+\w+)+'

    def to_python(self, value):
        # Django+flask+scrapy
        # ['Django', 'flask', 'scrapy']
        result = value.split('+')
        return result

    def to_url(self, value):
        if isinstance(value, list):
            # 完成相反的操作
            # ['Django', 'flask', 'scrapy']
            # Django+flask+scrapy
            result = '+'.join(value)
            return result
        else:
            raise RuntimeError("转换异常！转换url的时候，分类参数必须为列表。")

# 注册自定义的url转换器
# register_converter()函数接收两个参数，第一个参数是自定义类，第二个是名称
register_converter(SelfConverter, 'self_rule')

__init__.py文件中，引入此文件的同时注册了url转换器：

from . import converters

编写视图函数：

def article_list(request, categories):
    # url反转测试：
    print(reverse('list', kwargs={"categories": categories}))
    text = 'test, 填写的分类是: %s' % categories
    return HttpResponse(text)

以上准备工作完成之后，就可以在urls.py文件中使用注册的url转换器了：

# 使用注册的url转换器
path("list/<self_rule:categories>", views.article_list, name='list')

返回顶部

---

五、re_path函数

有时候我们在写url匹配的时候，想要写使用正则表达式来实现一些复杂的需求，那么这时候我们可以使用 re_path 来实现。 re_path 的参数和 path 参数一模一样，只不过第一个参数也就是 route 参数可以为一个正则表达式。一些使用 re_path 的示例代码如下：

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

以上例子中我们可以看到，所有的 route 字符串前面都加了一个 r ，表示这个字符串是一个原生字符串，这样可以避免在 python 这一层面进行转义。

使用正则表达式捕获参数，需要使用圆括号括包裹起来，如果这个参数是有名字的，那么需要使用?P<参数的名字>，然后在后面添加正则表达式的匹配规则。

返回顶部

---

六、url反转

之前我们都是通过url来访问视图函数。有时候我们知道这个视图函数，但是想反转回他的url。这时候就可以通过reverse来实现：

from django.shortcuts import reverse
reverse("list")
> /book/list/

如果有应用命名空间或者有实例命名空间，那么应该在反转的时候加上命名空间：

reverse('book:list')
> /book/list/

返回顶部

---

反转时传递参数

url反转时传递参数一般有两种方式：

1、通过kwargs

如果这个url中需要传递参数，那么可以通过 kwargs 来传递参数：

urlpatterns = [
    path('detail/<book_id>/', views.article_detail, name='detail')
]

detail_url = reverse("book:detail", kwargs={"book_id":1})
# > /book/detail/1
return redirect(detail_url)

如果需要传递多个参数，如

path('detail/<article_id>/<page>/', views.article_detail, name='detail)

在kwargs字典中kwargs={"article_id":1, "page":2}，添加进去即可。

2、通过查询字符串的参数

因为 django 中的 reverse 反转 url 的时候不区分 GET 请求和 POST 请求，因此不能在反转的时候添加查询字符串的参数。如果想要添加查询字符串的参数，只能手动的进行拼接：

login_url = reverse('login') + "?next=/"
return redirect(login_url)

传递多个参数？ href="下一页面.jsp?"+参数+“&参数名”+参数值，加号不能少，不然页面跳转就会失败。

返回顶部

---