第四篇：Django之路由层

第四篇：Django之路由层

目录

• 第四篇：Django之路由层
  • 1、路由匹配
  • 2、无名分组
  • 3、有名分组
  • 4、无名分组和有名分组是否可以混用？
  • 5、反向解析
  • 6、路由分发
  • 7、名称空间（了解）
  • 8、伪静态（了解）
  • 9、虚拟环境
  • 10、Django版本区别

1、路由匹配

为了测试路由，我们先设置这样的路由路径。

"""urls.py"""
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'test', views.test),
    url(r'testadd', views.testadd)
]

"""views.py"""
def test(request):
    return HttpResponse('date from test')

def testadd(request):
    return HttpResponse('date from testadd')

从浏览器中访问127.0.0.1：8000/test，得到以下效果。

看着很正确，但是我们又访问127.0.0.1:8000/testadd，我们会发现出现了错误，仍然得到了以前的页面。

原因如下：

url方法第一个参数是正则表达式,只要第一个参数正则表达式能够匹配到内容那么就会立刻停止往下匹配，直接执行对应的视图函数。

你在输入url的时候会默认加斜杠,django内部帮你做到重定向,一次匹配不行,url后面加斜杠再来一次。

我们将路由路径进行修改，改为下面这样。

"""urls.py"""
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'test/', views.test),
    url(r'testadd/', views.testadd)
]

我们再次进行访问127.0.0.1:8000、test,我们会发现django做了重定向。

总结：

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    # 首页【^以...开头，$以...结尾】
    url(r'^$',views.home),
    # 路由匹配
    url(r'^test/$',views.test),
    url(r'^testadd/$',views.testadd),
    # 尾页(了解，不完善，有小bug)
    url(r'',views.error),
]

补充：

# 取消自动加斜杠
APPEND_SLASH = False/True	# 默认是自动加斜杠的

2、无名分组

分组:就是给某一段正则表达式用小括号扩起来

无名分组就是将括号内正则表达式匹配到的内容当作位置参数传递给后面的视图函数。

url(r'^test/(\d+)/',views.test)  # \d匹配数字  +匹配一个或多个

def test(request,xx):
    print(xx)  # 使用xx作为形参，可以得到(\d+)匹配到的数字
    return HttpResponse('test')

3、有名分组

可以给正则表达式起一个别名

有名分组就是将括号内正则表达式匹配到的内容当作关键字参数传递给后面的视图函数。

url(r'^testadd/(?P<year>\d+)',views.testadd)  # (?P<year>\d+)

def testadd(request,year):
    print(year)  # 关键字实参year，必须是year
    return HttpResponse('testadd')

4、无名分组和有名分组是否可以混用？

不能混用，但是同一个分组可以使用N多次

url(r'^index/(\d+)/(\d+)/(\d+)/',views.index),
def index(request, x, y, z):  # 位置形参
    pass
# 可以写为
def index(request, *args, **kwargs):
    pass

url(r'^index/(?P<year>\d+)/(?P<age>\d+)/(?P<month>\d+)/',views.index),
def index(request, year, age, month)  # 关键字参数传参
    pass
# 可以写为
def index(request, *args, **kwargs):
    pass

5、反向解析

• 普通路由的反向解析

"""
本质:通过一些方法得到一个结果 该结果可以访问到对应的url从而触发视图函数的运行
"""
# 我们可以给路由与视图函数起一个别名
url(r'^func/',views.func,name='ooo')

# 访问方式如下即可
# 前端反向解析
<a href="{% url 'ooo' %}">111</a>  # a链接访问的路径为urls.py下 路由关系名为'ooo'的路径
# 后端方向解析
"""urls.py"""
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^func/', views.func, name='ooo')
]
"""views.py"""
def func(request):
    print(reverse('ooo'))   # /func/
    return HttpResponse('date from func')

访问127.0.0.1:8000/func/服务端效果如下。

• 无名分组的反向解析

  我们现在urls.py中配置这样的无名分组配置路径

  urlpatterns = [
      url(r'^admin/', admin.site.urls),
      url(r'^$', views.home),
      url(r'^index/(\d+)/', views.index, name='xxx')
  ]
  

  然后我们在前端home.html中可以这样解析

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

  我们在views.py中这样进行配置

  # 主页面
  def home(request):
      return render(request, 'home.html')
  
  def index(request, arg):  # 传进来的arg是str类型 <class 'str'>
    print(type(arg))  # <class 'str'>
    return HttpResponse('arg={}'.format(arg))
  

  具体流程如下，我们一点击'127.0.0.1:8000'，跳转到home.html界面，其中的链接经过<a href="{% url 'xxx' 123 %}">跳转</a>这样修饰，已经在浏览器中呈现了以下效果。

然后我们点击跳转,自动向http://127.0.0.1:8000/index/123/发送GET请求，经过路由中url(r'^index/(\d+)/', views.index, name='xxx')的解析，将匹配到的数字类型，作为位置实参传递给def index(request, arg):中的arg参数。

然后index函数向浏览器返回相应的内容。

我们在后端可以这样解析

reverse('xxx', args=(1,))

总结

"""无名分组反向解析"""
# 前端
{% url 'xxx' 123 %}

# 后端
reverse('xxx', args=(1,))

"""用途"""
数字一般情况下放的是数据的主键值，用于数据的编辑和删除
"""urls.py"""
url(r'^edit/(\d+)/',views.edit,name='xxx')  

"""views.py"""
def edit(request,edit_id):  # 拿到要编辑数据的id
    reverse('xxx',args=(edit_id,))

"""edit.html"""
{% for user_obj in user_queryset %}
	<a href="{% url 'xxx' user_obj.id %}">编辑</a>
{% endfor %}

• 有名分组的反向解析

  我们在urls.py中这样配置

  url(r'^func/(?P<year>\d+)/',views.func,name='ooo')
  

  然后我们在前端home.html中可以这样解析

  # 第一种【了解】
  <a href="{% url 'ooo' year=123 %}">111</a>
  # 第二种【掌握】
  <a href="{% url 'ooo' 123 %}">222</a>  
  

  我们在后端可以这样解析

  # 第一种方法
  print(reverse('ooo',kwargs={'year':123}))
  # 第二种方法
  print(reverse('ooo',args=(111,)))
  

  个人感觉：

  前端用途很多，可以用来携带一定的数据。但是后端解析貌似不会经常使用【因为其解析出来，也仅仅是一个字符串类型的数据】
  

6、路由分发

django的每一个应用都可以有自己的templates文件夹、urls.py、static文件夹。正是基于上述的特点 django能够非常好的做到分组开发(每个人只写自己的app)。作为项目组织者，只需要将下属书写的app全部拷贝到一个新的django项目中，然后在配置文件里面注册所有的app，之后再利用路由分发的特点将所有的app整合起来。

当一个django项目中的url特别多的时候，总路由urls.py代码非常冗余，不好维护，这个时候也可以利用路由分发来减轻总路由的压力。【即每个app中配置一个专门的路由】。

有了路由分发之后，总路由不再是路由与视图函数的直接对应关系，而是做一个分发处理，而是识别当前url是属于哪个应用下的，然后直接分发给对应的应用去处理。

具体操作如下：

我们重新创建要给app02，运行如下代码，创建一个app02

python3 manage.py startapp app02

然后在settings.py中对app02进行注册。

我们需要手动给app01和app02分别创建一个urls.py文件，然后在其中如此书写。

"""app01中的urls.py"""
from django.conf.urls import url
from app01 import views  # 直接import views也行，但是为了方便区分app。

urlpatterns = [
    url(r'^reg/',views.reg)
]

"""app02中的urls.py"""
from django.conf.urls import url
from app02 import views

urlpatterns = [
    url(r'^reg/',views.reg)
]

# 注意：我们在两个文件中都写了reg的路由。

然后我们在总路由这样书写

"""第一种写法"""
from django.conf.urls import url, include
from django.contrib import admin

from app01 import urls as app01_urls  # 起别名
from app02 import urls as app02_urls

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    # 1.路由分发
    url(r'^app01/',include(app01_urls)),  # 只要url前缀是app01开头，全部交给app01处理
    url(r'^app02/',include(app02_urls))   # 只要url前缀是app02开头，全部交给app02处理
]


"""第二种写法【推荐使用】"""
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^app01/',include('app01.urls')),
    url(r'^app02/',include('app02.urls'))
]

# 注意事项:总路由里面的url千万不能加$结尾

然后我们进行如下操作

如此一来，我们在浏览器中输入127.0.0.1:8000/app01/reg/，便会得到。

我们在浏览器中输入127.0.0.1:8000/app02/reg/，便会得到。

7、名称空间（了解）

试想一下，如果app01中的urls路由关系和app02中的路由关系起了相同的别名，如下所示。

"""app01中的urls.py"""
urlpatterns = [
   url(r'^reg/', views.reg, name='xxx')
]

"""app02中的urls.py"""
urlpatterns = [
   url(r'^reg/', views.reg, name='xxx')
]

当我们在前端以下的方式进行解析。

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

我们会发现跳转的是app02中的路由关系。

所以，当多个应用出现了相同的别名，正常情况下的反向解析是没有办法自动识别前缀的，由此引出了名称空间的概念。

我们使用namespace关键字。

# 总路由
url(r'^app01/',include('app01.urls',namespace='app01')),
url(r'^app02/',include('app02.urls',namespace='app02'))

# 前端进行解析时
<a href="{% url 'app01:xxx' %}">跳转</a>
<a href="{% url 'app02:xxx' %}">跳转</a>

# 后端进行解析时
{% url 'app01:xxx' %}
{% url 'app02:xxx' %}

当然，只要保证名字不冲突，就没有必要使用名称空间，一般情况下，有多个app的时候我们在起别名的时候会加上app的前缀，这样的话就能够确保多个app之间名字不冲突的问题。即下面这样。

urlpatterns = [
    url(r'^reg/',views.reg,name='app01_xxx')
]
urlpatterns = [
    url(r'^reg/',views.reg,name='app02_xxx')
]

# 注意：前端解析时 {% url 路由名 %}可以显示路由名【而不像以前的.之类，url会自动从所有的路由关系名中进行查找】。

8、伪静态（了解）

类似于访问博客园。https://www.cnblogs.com/yangyi215/p/14931830.html是以html为后缀的。

搜索引擎本质上就是一个巨大的爬虫程序，伪装的目的在于增大本网站的seo查询力度,并且增加搜索引擎收藏本网上的概率。

但是，无论你怎么优化和处理，都干不过RMB玩家【哈哈】。

如何处理，直接在路由加上.html后缀即可。

urlpatterns = [
    url(r'^reg.html',views.reg,name='app02_reg')
]

9、虚拟环境

在正常开发中，我们会给每一个项目配备一个该项目独有的解释器环境，该环境内只有该项目用到的模块，用不到一概不装。

每创建一个虚拟环境就类似于重新下载了一个纯净的python解释器，但是虚拟环境不要创建太多，是需要消耗硬盘空间的。

之后创建django项目的时候，方式如下。

扩展：

每一个项目都需要用到很多模块 并且每个模块版本可能还不一样
那我该如何安装呢？ 一个个看一个个装？？？
开发当中我们会给每一个项目配备一个requirements.txt文件
里面书写了该项目所有的模块即版本
你只需要直接输入一条命令即可一键安装所有模块即版本

10、Django版本区别

"""第一个区别"""
1.django1.X路由层使用的是url方法
而在django2.Xhe3.X版本中路由层使用的是path方法
url()第一个参数支持正则
path()第一个参数是不支持正则的,写什么就匹配什么
	
如果你习惯使用path那么也给你提供了另外一个方法
from django.urls import path, re_path
from django.conf.urls import url
		
re_path(r'^index/',index),
url(r'^login/',login)
# 2.X和3.X里面的re_path就等价于1.X里面的url
 
 
"""第二个区别"""
2.虽然path不支持正则 但是它的内部支持五种转换器
path('index/<int:id>/',index)
# 将第二个路由里面的内容先转成整型然后以关键字的形式传递给后面的视图函数

def index(request,id):
    print(id,type(id))  # int类型
    return HttpResponse('index')
    
  
"""
str,匹配除了路径分隔符（/）之外的非空字符串，这是默认的形式
int,匹配正整数，包含0。
slug,匹配字母、数字以及横杠、下划线组成的字符串。
uuid,匹配格式化的uuid，如 075194d3-6885-417e-a8a8-6c931e272f00。
path,匹配任何非空字符串，包含了路径分隔符（/）（不能用？）
""" 

"""第三个区别"""
3.除了有默认的五个转换器之外 还支持自定义转换器(了解)
class MonthConverter:
    regex='\d{2}' # 属性名必须为regex

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

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

	
from django.urls import path,register_converter
from app01.path_converts import MonthConverter

# 先注册转换器
register_converter(MonthConverter,'mon')

from app01 import views


urlpatterns = [
    path('articles/<int:year>/<mon:month>/<slug:other>/', 			 
    views.article_detail, name='aaa'),
]

"""第四个区别"""
4.模型层里面1.X外键默认都是级联更新删除的
但是到了2.X和3.X中需要你自己手动配置参数
models.ForeignKey(to='Publish')
	
models.ForeignKey(to='Publish',on_delete=models.CASCADE...)

补充：【使用反向解析实现编辑和删除数据的功能】(除了使用?携带数据的方式之外)代码如下。

"""第一种方式"""
"""urls.py"""
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^userlist', views.user_list),
    url(r'^edituser/(\d+)/', views.edit_user),
    url(r'^deleteuser/(\d+)/', views.delete_user)
]

"""user_list.html"""
<a href="/edituser/{{ user_obj.id }}" class="btn btn-success btn-xs">编辑</a>
<a href="/deleteuser/{{ user_obj.id }}" class="btn btn-danger btn-xs">删除</a>


"""第二种方法"""
"""urls.py"""
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^userlist', views.user_list),
    url(r'^edituser/(\d+)/', views.edit_user, name='xxx'),
    url(r'^deleteuser/(\d+)/', views.delete_user, name='ooo')
]
"""user_list.html"""
<a href="{% url 'xxx' user_obj.id %}" class="btn btn-success btn-xs">编辑</a>
<a href="{% url 'ooo' user_obj.id %}" class="btn btn-danger btn-xs">删除</a>


# 注意：在post请求中也可以得到get的数据【其原本get请求的后缀路径不会消失，所以可以串联起来操作】