（1）Django1.x版本语法#

1
from django.conf.urls import url
2

3
urlpatterns = [
4
     url(正则表达式, views视图函数，参数，别名),
5
]#

（2）Django2.x+版本语法#

1
from django.urls import path
2

3
from . import views
4

5
urlpatterns = [
6
    path('articles/2003/', views.special_case_2003),
7
    path('articles/<int:year>/', views.year_archive),
8
    path('articles/<int:year>/<int:month>/', views.month_archive),
9
    path('articles/<int:year>/<int:month>/<slug:slug>/', views.article_detail),
10
]

• 注意
  • 要从 URL 中取值，使用尖括号。
  • 捕获的值可以选择性地包含转换器类型。比如，使用 int:name 来捕获整型参数。如果不包含转换器，则会匹配除了 / 外的任何字符。
  • 这里不需要添加反斜杠，因为每个 URL 都有。比如，应该是 articles 而不是 /articles 。

（3）参数说明#

1
from django.conf.urls import url
2

3
urlpatterns = [
4
     path(路径名, views视图函数，参数，别名),
5
]

• 路径名：
  • 在浏览器端口后请求的路径名
• views视图函数：
  • 一个可调用对象，通常为一个视图函数或一个指定视图函数路径的字符串
• 参数：
  • 可选的要传递给视图函数的默认参数（字典形式）
• 别名：
  • 一个可选的name参数

【3】路由系统自动添加 /#

• 在配置文件中，有一个参数可以帮助我们干这件事

1
APPEND_SLASH = True

• 当设置为 True 时，如果请求的 URL 不符合 URLconf 中的任何模式，并且不以斜线结尾，则会发出一个 HTTP 重定向到相同的URL，并附加一个斜线。
• 注意，重定向可能会导致 POST 请求中提交的任何数据丢失。

APPEND_SLASH 的配置只有在安装了 CommonMiddleware 的情况下才会使用（参见 中间件）。也请参见 PREPEND_WWW。

（1）基础的URL配置#

• 在实际的Django项目中，经常需要获取某个具体对象的URL，为生成的内容配置URL链接。
• 比如，我要在页面上展示一列文章列表，每个条目都是个超级链接，点击就进入该文章的详细页面。
• 现在我们的urlconf是这么配置的：

1
path('post/<int:pk>/'，views.some_view),

（2）问题引入#

• 在前端中，这就需要为HTML的标签的href属性提供一个诸如http://www.xxx.com/post/3/的值。其中的域名部分，Django会帮你自动添加无须关心，我们关注的是post/3/。
• 此时，一定不能硬编码URL为post/3/，那样费时费力、修改困难，而且容易出错。试想，如果哪天，因为某种原因，需要将urlconf中的表达式改成entry/int:pk/，为了让链接正常工作，必须修改对应的herf属性值，于是你去项目里将所有的post/…/都改成entry/…/吗？显然这是不现实的！
• 我们需要一种安全、可靠、自适应的机制，当修改URLconf中的代码后，无需在项目源码中大范围搜索、替换失效的硬编码URL。

（3）解决方案#

• 为了解决这个问题，Django提供了一种解决方案，只需在URL中提供一个name参数，并赋值一个你自定义的、好记的、直观的字符串。
• 通过这个name参数，可以反向解析URL、反向URL匹配、反向URL查询或者简单的URL反查。

（4）解决方案实现#

• 在需要解析URL的地方，对于不同层级，Django提供了不同的工具用于URL反查：
  • 在模板语言中：使用url模板标签。(也就是写前端网页时）
  • 在Python代码中：使用reverse()函数。（也就是写视图函数等情况时）
  • 在更高层的与处理Django模型实例相关的代码中：使用get_absolute_url()方法。(也就是在模型model中，参考前面的章节)
• 所有上面三种方式，都依赖于首先在path种为url添加name属性！

1
from django.urls import path
2

3
from . import views
4

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

1
<a href="{% url 'news-year-archive' 2020 %}">2020 Archive</a>
2

3
{# 或者使用for循环变量 #}
4
<ul>
5
    {% for yearvar in year_list %}
6
        <li><a href="{% url 'news-year-archive' yearvar %}">{{ yearvar }} Archive</a></li>
7
    {% endfor %}
8
</ul>

1
from django.http import HttpResponseRedirect
2
from django.urls import reverse
3

4
def redirect_to_year(request):
5
    # ...
6
    year = 2020
7
    # ...
8
    return HttpResponseRedirect(reverse('news-year-archive', args=(year,)))

（1）引入#

1
# 无名分组反向解析
2
re_path(r'^index/(\d+)/', views.index, name='xxx'),

1
def home(request):
2
    print(reverse('xxx')
3
    return render(request, 'home.html')

1
<a href="">{% url 'xxx' %}</a>

（2）解决办法#

1
# 无名分组反向解析
2
re_path(r'^index/(\d+)/', views.index, name='xxx'),

1
def home(request):
2
    print(reverse('xxx', args=(1,)))
3
    return render(request, 'home.html')

1
<a href="">{% url 'xxx' 123 %}</a>

（3）小结#

• 这个数字存在的意义到底是什么？
  • 数字一般情况下放的是数据的主键值
  • 数据的标记和删除功能

通过在根路径的后面拼接指定的 地址 ，从而对这个指定的地址进行数据的更改

1
# 一个小的实例演示
2

3
# 路由层
4
re_path('edit/<int:pk>/',views.edit,name='edit')
5

6
# 视图层
7
def edit(request,edit_id):
8
    reverse("edit",args=(edit_id,))
9

10
# 前端
11
{% for user.obj in user_queryset %}
12
<a href="{% url 'eidt' user_obj.id %}">
13
{% endfor %}

（1）问题引入#

1
# 有名分组反向解析
2
re_path(r'^fuc/(?P<year>\d+)', views.func, name='ooo')

1
def func(request,year):
2
    print(reverse('000')
3
    return render(request, 'home.html')

（2）解决方案#

1
# 有名分组反向解析
2
re_path(r'^fuc/(?P<year>\d+)', views.func, name='ooo')

1
def home(request,year):
2
    # 有名分组的标准写法
3
    # print(reverse('ooo', kwargs={"year": 123}))
4
    # 也可以写成
5
    year = 123
6
    print(reverse("ooo",args=(year,))
7
    return render(request, 'home.html')

1
<a href="">{% url 'ooo' year=123 %}</a>有名分组

（1）方式一：转发app下的urls#

• 例如，下面是Django网站本身的URLconf节选。 它包含许多其它URLconf：

1
from django.urls import include, path
2

3
urlpatterns = [
4
    # ... 省略...
5
    path('community/', include('aggregator.urls')),
6
    path('contact/', include('contact.urls')),
7
    # ... 省略 ...
8
]

• 路由转发使用的是include()方法，需要提前导入，它的参数是转发目的地路径的字符串，路径以圆点分割。
• 每当Django 遇到include()时，它会去掉URL中匹配的部分并将剩下的字符串发送给include的URLconf做进一步处理，也就是转发到二级路由去。

（2）方式二：转发url列表#

• 另外一种转发其它URLconf的方式是使用一个path()实例的列表。 例如，下面的URLconf：

1
from django.urls import include, path
2

3
from apps.main import views as main_views
4
from credit import views as credit_views
5

6
extra_patterns = [
7
    path('reports/', credit_views.report),
8
    path('reports/<int:id>/', credit_views.report),
9
    path('charge/', credit_views.charge),
10
]
11

12
urlpatterns = [
13
    path('', main_views.homepage),
14
    path('help/', include('apps.help.urls')),
15
    path('credit/', include(extra_patterns)),
16
]

• 在此示例中，/credit/reports/URL将由credit_views.report()视图处理。
• 这种做法，相当于把二级路由模块内的代码写到根路由模块里一起了，不是很推荐。

（1）总路由#

1
from django.contrib import admin
2
from django.urls import path, re_path, include
3

4
import app01
5
import app02
6

7
urlpatterns = [
8
    path('admin/', admin.site.urls),
9
    path('app01/', include(app01.urls)),
10
    path('app02/', include(app02.urls)),
11
]

（2）子路由#

1
# 自己的逻辑路径
2
from django.contrib import admin
3
from django.urls import path, re_path, include
4
from app01 import login
5

6
urlpatterns = [
7
    path('login/', views.login),
8
]

（1）配置一#

1
from django.urls import include, path
2

3
urlpatterns = [
4
    path('blog/', include('inner'), {'blog_id': 3}),
5
]
6

7
# inner.py
8
from django.urls import path
9
from mysite import views
10

11
urlpatterns = [
12
    path('archive/', views.archive),
13
    path('about/', views.about),
14
]

（2）配置二#

1
from django.urls import include, path
2
from mysite import views
3

4
urlpatterns = [
5
    path('blog/', include('inner')),
6
]
7

8
# inner.py
9
from django.urls import path
10

11
urlpatterns = [
12
    path('archive/', views.archive, {'blog_id': 3}),
13
    path('about/', views.about, {'blog_id': 3}),
14
]

• 注意，只有当你确定被include的URLconf中的每个视图都接收你传递给它们的额外的参数时才有意义，否则其中一个以上视图不接收该参数都将导致错误异常。

（1）引入#

• 前面我们为介绍了path的name参数，为路由添加别名，实现反向url解析和软编码解耦。
• 但是，我们思考这么一个问题，假设下面的情况：
  • appA，有一条路由A，它的name叫做’index’
  • appB，有一条路由B，它的name也叫做’index’
• 这种情况完全是有可能的，甚至还常见！
• 请问，你在某个视图中使用reverse(‘index’,args=(…))或者在模板中使用{% url ‘index’ … %}，它最终生成的URL到底是路由A还是路由B呢？
• 不管是哪个，肯定都不好，因为我们需要确定状态的路由，而不是混乱的。
• 之所以造成这种情况，根本上还是各个app之间没有统一的路由管理，实际上也不可能有。

（2）解决方案#

• 最佳解决问题的办法就是隔离分治，命名空间解耦，这也是常用的设计模式。
• Django提供了一个叫做app_name的属性，帮我们实现应用级别的命名空间，这样，虽然大家都叫‘大伟’，但一个是‘张大伟’，一个是‘王大伟’，自然就分清楚了甲乙丙丁。

1
from django.urls import path
2

3
from . import views
4

5
app_name = 'your_app_name'   # 重点是这行！
6

7
urlpatterns = [
8
    ...
9
]

（3）使用方法#

• 我么只需要在app自己本身的urls.py文件内，添加一行app_name = ‘your_app_name’即可。注意不是在根路由文件中。一般就和自己的app同命即可，因为项目里面不会有2个同样名字的app。
• 使用的方式很简单：

1
# 视图中
2
reverse('your_app_name:index',args=(...))
3

4
# 模板中
5
{% url 'your_app_name:index' ... %}

• 注意your_app_name和index之间是冒号分隔。

（1）引入#

• 首先我们要知道，Django是可以对app进行实例化的。也就是说：
  • 一个app在运行的时候，可以同时生成多个实例
  • 每个实例运行同样的代码
  • 但是不同的实例，可能会有不同的状态
• 以上不好理解，甚至很多人都不知道这个知识点。
• 假设我们有个app，实现一个index页面展示功能：
  • 假设访问Django服务器的人分两类，author和publisher，作者和出版社
  • 他们都需要访问app
  • 业务需求：为两类人实现不同的权限或者页面内容
  • 尽可能重用代码
• 为此，我们可以这么实现：
  • 根据不同的url来区分两类人，author访问author/…，publisher访问publisher/…。
  • 两个url都指向同一个app的url：include(‘app.urls’)
  • 在视图中，根据来访人员的不同，if/else判断，实现不同的业务逻辑。
  • 这样，我们就相当于共用了urls和views实现了两套app
• 而这，就是所谓的app的多个实例！

（2）问题#

• 但这种做法有个明显的问题，就是对于每条URL，如何区分两种人员？
• 使用应用命名？像reverse(‘your_app_name’,args=(…))这样？
• 显然是不行的，因为多个应用的实例共享应用空间名，通过app_name是区分不了的！
• 针对这种情况，Django提供了一个namespace属性，用于标记不同的应用实例，如下所示：

1
# 根urls.py
2
from django.urls import include, path
3

4
urlpatterns = [
5
    path('author/', include('app.urls', namespace='author')),
6
    path('publisher/', include('app.urls', namespace='publisher')),
7
]
8

9
# app/urls.py
10
from django.urls import path
11

12
from . import views
13

14
app_name = 'app'          # 这行不能少
15

16
urlpatterns = [
17
    path('index/', views.index, name='index'),
18
    path('detail/', views.detail, name='detail'),
19
]
20

21
# app/views.py
22
from django.shortcuts import render,HttpResponse
23

24

25
def index(request):
26

27
    return HttpResponse('当前的命名空间是%s'% request.resolver_match.namespace)
28

29
def detail(request):
30
    if request.resolver_match.namespace == 'author':
31
        return HttpResponse('这里是作者的页面')
32
    elif request.resolver_match.namespace == 'publisher':
33
        return HttpResponse('这里是出版商的页面')
34
    else:
35
        return HttpResponse('去liujiangblog.com学习Django吧')

• 启动服务器，分别访问author/index/和publisher/index，你应该能看到不同的结果。
• 要注意：
  • namespace定义在include中
  • **整个项目的所有app中的所有namespace不能重名，也就是全局唯一！**所以我们一般设计成appname_spacename。（文中为了简洁，偷了个懒）
  • 使用namespace功能的前提是设置app_name，如果不设置，会弹出异常
  • 要在视图中获取namespace属性值，通过request.resolver_match.namespace
• 这样，我们实现了URL的正向解析。那么反向解析怎么做呢？
• 为根urls.py添加一条路由：

1
from app import views
2

3
path('goto/', views.goto)

• 为app/views.py添加一个视图：

1
def goto(request):
2
    return HttpResponseRedirect(reverse('app:index', current_app='author' ))

• 注意reverse方法提供的current_app参数!
• 然后我们访问goto/，可以看到页面跳转到了author的index。
• 是直接指定字符串形式的namespace名称，还是使用request.resolver_match.namespace，取决于你当前视图是从哪个URL路由过来的，该URL是否携带了namespace属性。

在基于类的视图的方法中，我们也可以这样使用：

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

• 再拓展一下，实际上我们再reverse的时候完全可以直接指定使用哪个命名空间：

1
reverse('author:index')
2

3
# 或者
4

5
reverse('publisher:index')

• 那么在HTML模板中怎么使用呢？
• 可以这么用：

1
{% url 'app:index' %}

• 但是要注意，这会有两种情况：
• 视图携带了namespace，那么访问对应的namespace
• 视图未携带namespace，app应用上一次使用的是author还是pushliser中的哪个，就访问哪个
• 所以为了彻底区分每个实例，你也可以这么用：

1
{% url 'author:index' %}
2

3
或者
4

5
{% url 'publisher:index' %}

• 其实，从这里也能看出，Django为什么要求namespace全局唯一。

（1）创建两个app#

• 当我们有两个APP时，如 app01 和 app02
• 并且在这两个APP下，存在同名的带有反向解析的路由映射关系

1
from django.urls import path
2
from app01.views import index
3

4
urlpatterns = [
5
    path("index/", index, name="index_view")
6
]
7

8
# app01/view.py
9
from django.shortcuts import render, reverse, HttpResponse
10

11
def index(request):
12
    print(f"from app01 view :>>>>> {reverse('index_view')}")
13
    return HttpResponse("FROM APP01 INDEX_VIEW")

1
from django.urls import path
2
from app02.views import index
3

4
urlpatterns = [
5
    path("index/", index, name="index_view")
6
]
7

8
# app02/view.py
9
from django.shortcuts import render, reverse, HttpResponse
10

11
def index(request):
12
    print(f"from app02 view :>>>> {reverse('index_view')}")
13
    return HttpResponse("FROM APP02 INDEX VIEW")

1
# 根路由 urls.py
2
from django.contrib import admin
3
from django.urls import path
4
from django.urls.conf import include
5

6
urlpatterns = [
7
    path('admin/', admin.site.urls),
8
    # 路由分发，将 app01 的前缀的路由分发
9
    path("app01/", include(arg="app01.urls")),
10
    # 路由分发，将 app02 的前缀的路由分发
11
    path("app02/", include(arg="app02.urls")),
12
]

（2）启动Django访问路由#

• 此时启动Django项目，
• 分别访问这两个路由地址

1
# http://127.0.0.1:8000/app01/index
2

3
# http://127.0.0.1:8000/app02/index

• 此时查看控制台输出，并查看当前解析到的同名的路由名是否一致

1
# from app02 view :>>>> /app02/index/
2
# [28/Feb/2024 05:08:02] "GET /app02/index/ HTTP/1.1" 200 21
3

4
# app01/views.py
5
# from app01 view :>>>>> /app02/index/
6
# [28/Feb/2024 05:08:06] "GET /app01/index/ HTTP/1.1" 200 21

• 此时我们会发现，Django自带的反向解析并没有自动识别到各自的路由映射关系上，而是都解析到了位于最后位置的解析上
• 即Django不会自动解析当前路由前缀

（3）解决路由解析一致问题#

1
from django.urls import path
2
from app01.views import index
3

4
# 在路由分发文件中给当前APP创建一个app的应用命名空间
5
app_name="app01"
6

7
urlpatterns = [
8
    path("index/", index, name="index_view")
9
]
10

11
# app01/view.py
12
from django.shortcuts import render, reverse, HttpResponse
13

14
def index(request):
15
    # 解析路由映射关系时指定当前APP名字
16
    print(f"from app01 view :>>>>> {reverse('app01:index_view')}")
17
    return HttpResponse("FROM APP01 INDEX_VIEW")

1
from django.urls import path
2
from app02.views import index
3

4
# 在路由分发文件中给当前APP创建一个app的应用命名空间
5
app_name="app02"
6

7
urlpatterns = [
8
    path("index/", index, name="index_view")
9
]
10

11
# app02/view.py
12
from django.shortcuts import render, reverse, HttpResponse
13

14
def index(request):
15
    # 解析路由映射关系时指定当前APP名字
16
    print(f"from app02 view :>>>> {reverse('app02:index_view')}")
17
    return HttpResponse("FROM APP02 INDEX VIEW")

1
# 根路由 urls.py
2
from django.contrib import admin
3
from django.urls import path
4
from django.urls.conf import include
5
urlpatterns = [
6
    path('admin/', admin.site.urls),
7
     # 路由分发，将 app01 的前缀的路由分发
8
    # 给当前路由分发指定实例名称空间
9
    path("app01/", include(arg="app01.urls", namespace="app01")),
10
    # 路由分发，将 app02 的前缀的路由分发
11
    # 给当前路由分发指定实例名称空间
12
    path("app02/", include(arg="app02.urls", namespace="app02")),
13
]

1
# http://127.0.0.1:8000/app01/index
2

3
# http://127.0.0.1:8000/app02/index

1
# from app02 view :>>>> /app02/index/
2
# [28/Feb/2024 05:08:02] "GET /app02/index/ HTTP/1.1" 200 21
3

4
# app01/views.py
5
# from app01 view :>>>>> /app01/index/
6
# [28/Feb/2024 05:08:06] "GET /app01/index/ HTTP/1.1" 200 21

1
from django.urls import path
2
from app01.views import index
3

4
urlpatterns = [
5
    path("index/", index, name="index_view")
6
]
7

8
# app01/view.py
9
from django.shortcuts import render, reverse, HttpResponse
10

11
def index(request):
12
    # 解析路由映射关系时指定当前APP名字
13
    print(f"from app01 view :>>>>> {reverse('app01:index_view')}")
14
    return HttpResponse("FROM APP01 INDEX_VIEW")

1
from django.urls import path
2
from app02.views import index
3

4
urlpatterns = [
5
    path("index/", index, name="index_view")
6
]
7

8
# app02/view.py
9
from django.shortcuts import render, reverse, HttpResponse
10

11
def index(request):
12
    # 解析路由映射关系时指定当前APP名字
13
    print(f"from app02 view :>>>> {reverse('app02:index_view')}")
14
    return HttpResponse("FROM APP02 INDEX VIEW")

1
# 根路由 urls.py
2
from django.contrib import admin
3
from django.urls import path
4
from django.urls.conf import include
5
urlpatterns = [
6
    path('admin/', admin.site.urls),
7
     # 路由分发，将 app01 的前缀的路由分发
8
    # 给当前路由分发指定实例名称空间
9
    path("app01/", include(arg=("app01.urls","app01"), namespace="app01")),
10
    # 路由分发，将 app02 的前缀的路由分发
11
    # 给当前路由分发指定实例名称空间
12
    path("app02/", include(arg=("app02.urls","app02"), namespace="app02")),
13
]

1
# http://127.0.0.1:8000/app01/index
2

3
# http://127.0.0.1:8000/app02/index

1
# from app02 view :>>>> /app02/index/
2
# [28/Feb/2024 05:08:02] "GET /app02/index/ HTTP/1.1" 200 21
3

4
# app01/views.py
5
# from app01 view :>>>>> /app01/index/
6
# [28/Feb/2024 05:08:06] "GET /app01/index/ HTTP/1.1" 200 21

（4）补充：前端解析方法#

• 同后端解析方式一样，只需要指定上指定的APP名字即可完成反向解析

1
{% url 'app01:index' %}
2
{% url 'app02:index' %}

（1）导出项目模块文件#

1
pip freeze > requirements.txt

• 这行命令的含义是 “freeze”（冻结）当前环境中的所有已安装包及其版本信息，并将其输出重定向到 requirements.txt 文件中。
• 执行此命令后，requirements.txt 将列出你项目所需的全部依赖及其对应版本号。

（2）安装项目模块文件#

1
pip install -r requirements.txt

• 这将按照 requirements.txt 中列出的顺序及版本要求安装相应的 Python 包。

（1）初识#

• 虽然path不支持正则，但是其内部支持五种转换器

1
path('index/<int:id>/',views.index)
2
# 将第二个路由里面的内容先转成整型，然后以关键字的形式传递给后面的视图函数

1
from django.urls import path,re_path
2

3
from app01 import views
4

5
urlpatterns = [
6
    # 问题一的解决方案：
7
    path('articles/<int:year>/', views.year_archive),
8
    # <int:year>相当于一个有名分组，其中int是django提供的转换器，相当于正则表达式，专门用于匹配数字类型，而year则是我们为有名分组命的名，并且int会将匹配成功的结果转换成整型后按照格式（year=整型值）传给函数year_archive
9

10
    # 问题二解决方法：用一个int转换器可以替代多处正则表达式
11
    path('articles/<int:article_id>/detail/', views.detail_view),
12
    path('articles/<int:article_id>/edit/', views.edit_view),
13
    path('articles/<int:article_id>/delete/', views.delete_view),
14
]

（2）五种转换器#

• str
  • 匹配除了 ’/’ 之外的非空字符串。
  • 如果表达式内不包含转换器，则会默认匹配字符串。
• int
  • 匹配 0 或任何正整数。返回一个 int 。
• slug
  • 匹配任意由 ASCII 字母或数字以及连字符和下划线组成的短标签。
  • 比如，building-your-1st-django-site 。
• uuid
  • 匹配一个格式化的 UUID 。为了防止多个 URL 映射到同一个页面，必须包含破折号并且字符都为小写。
  • 比如，075194d3-6885-417e-a8a8-6c931e272f00。返回一个 UUID 实例。
• path
  • 匹配非空字段，包括路径分隔符 ’/’ 。
  • 它允许你匹配完整的 URL 路径而不是像 str 那样匹配 URL 的一部分。

（1）初识#

• 转换器是一个类，包含如下内容：
  • 字符串形式的 regex 类属性。
  • to_python(self, value) 方法，用来处理匹配的字符串转换为传递到函数的类型。如果没有转换为给定的值，它应该会引发 ValueError 。ValueError 说明没有匹配成功，因此除非另一个 URL 模式匹配成功，否则会向用户发送404响应。
  • 一个 to_url(self, value) 方法，它将处理 Python 类型转换为字符串以用于 URL 中。如果不能转换给定的值，它应该引发 ValueError。ValueError 被解释为无匹配项，因此 reverse() 将引发 NoReverseMatch，除非有其他 URL 模式匹配。

Changed in Django 3.1:

支持引发 ValueError 以表示没有匹配项被添加。

（2）自定义转换器示例#

• 在app01下新建文件 path_ converters.py（文件名可以随意命名）

1
class FourDigitYearConverter:
2
    # 此属性名为正则表达式（regex），用于匹配四位数的年份字符串
3
    regex = r'[0-9]{4}'
4

5
    def to_python(self, value):
6
        """
7
        将接收到的字符串值解析为Python整数类型表示四位数的年份。
8
        示例：输入 "2024" 会转换为 2024
9
        """
10
        return int(value)
11

12
    def to_url(self, value):
13
        """
14
        根据给定四位数年份（value）将其格式化为URL安全的四位数字形式，例如 "2024" -> "2024".
15
        注意这里的 "匹配的regex是四个数字" 应更改为 "此方法针对四位数的年份字符串"
16

17
        例如：输入 "2024" 会返回 "2024", 保持四位数且无前导零。
18
        """
19
        return '%04d' % value

（3）使用自定义转换器#

• 在urls.py中，使用register_converter() 将其注册到URL配置中：

1
# 引入所需的模块和从当前目录下的views.py导入视图函数
2
from django.urls import path, register_converter
3
from . import converters, views
4

5
# 在Django应用中注册自定义的日期转换器类，即位于converters文件中的FourDigitYearConverter
6
# 并为其指定别名 'yyyy', 这个别名可以方便地在URL模式中引用该转换器
7
register_converter(converters.FourDigitYearConverter, 'yyyy')
8

9
# 配置URL模式，其中：
10
#   path('/articles/2003/', views.special_case_2003) - 特殊情况处理，当访问 '/articles/2003/' 时调用 special_case_2003 视图函数
11
#   path('articles/<yyyy:year>/', views.year_archive) - 处理常规年份归档页面请求，
12
#       其中 '<yyyy:year>' 表示 URL 模板中 '<year>' 前面带有 'yyyy' 转换器别名，
13
#       Django将在实际匹配到的 URL 字符串中找到四位数的年份并传递给 views.year_archive 视图函数作为参数
14

15
urlpatterns = [
16
    path('articles/2003/', views.special_case_2003),
17
    path('articles/<yyyy:year>/', views.year_archive),
18
    ...
19
]

（4）转换器使用示例#

• app01/path_converters.py

1
class MonthConverter:
2
    regex = '\d{2}'  # 属性名必须为regex
3

4
    def to_python(self, value):
5
        return int(value)
6

7
    def to_url(self, value):
8
        return value  # 匹配的regex是两个数字，返回的结果也必须是两个数字

• urls.py

1
from django.contrib import admin
2
from django.urls import path
3
from app01 import views
4

5
register_converter(converters.FourDigitYearConverter, 'yyyy')
6

7
urlpatterns = [
8
    path('admin/', admin.site.urls),
9
    path('articles/<int:year>/<int:month>/<slug:other>/', views.article_detail)
10
    # 针对路径http://127.0.0.1:8000/articles/2009/123/hello/，path会匹配出参数year=2009,month=123,other='hello'传递给函数article_detail
11
]

• app01/views.py

1
from django.shortcuts import render,HttpResponse,reverse
2
from django.urls import reverse
3

4
def article_detail(request, year, month, other):
5
    print(year, type(year))
6
    print(month, type(month))
7
    print(other, type(other))
8
    print(reverse('article_detail', args=(1988, 12, 'hello')))  # 反向解析结果/articles/1988/12/hello/
9

10
    '''
11
    2009 <class 'int'>
12
    12 <class 'int'>
13
    hello <class 'str'>
14
    /articles/1988/12/hello/
15
    '''
16
    return HttpResponse('xxxx')

• 测试

1
# 在浏览器输入http://127.0.0.1:8000/articles/2009/12/hello/
2
# path会成功匹配出参数year=2009,month=12,other='hello'传递给函数article_detail

1
# 在浏览器输入http://127.0.0.1:8000/articles/2009/123/hello/
2
# path会匹配失败，因为我们自定义的转换器mon只匹配两位数字，而对应位置的123超过了2位