一、Django——路由层

Django——路由层相关(urls.py)

一、Django请求生命周期流程图

Django请求生命周期流程图.png

  1. 该图是我们学习的django的流程 也是后期复习django重要的手段
  2. 学习路线：
  3.     1、路由层
  4.     2、视图层
  5.     3、模板层
  6.     4、模型层

一、Django——路由层 - 图2

二、路由匹配

  1. 路由匹配的原则:
  2.     从上往下正则表达式能够匹配到内容就算匹配成功会立刻执行后面的视图函数并且结束整个路由匹配过程
  5. ----------------------------------"urls.py"----------------------------------
  6. urlpatterns = [
  7.     url(正则表达式,函数或者类型地址,name=None),
  8.     url(正则表达式,函数或者类型地址,name=None)
  9. ]
  11. url的三个参数:
  12.     1、正则表达式(正则表达式也可以加括号，然后起别名)
  13.     2、函数或者类型地址
  14.     3、name反向解析的别名
  17. 案例：
  18. urlpatterns = [
  19.     url(r'^admin/', admin.site.urls),
  20.     # 首页        (^$就是什么都不输，为空)
  21.     url(r'^$',views.home),
  22.     url(r'^test/$',views.test),
  23.     url(r'^testadd/$',views.testadd),
  24.     # 404页面        (放在最后，什么都没匹配上的话，那就默认返回404页面)
  25.     url(r'',views.error)
  26. ]
  30. 注意：
  31. """
  32. 当web浏览器访问不到路径，匹配不上的时候，Django会让浏览器的url最后一个加上"/"，再重新匹配一次
  34. 自动加"/"是Django的功能，不是web浏览器
  36. 在settings.py内，添加下面的参数即可关
  37. APPEND_SLASH = False  # 默认是True，改了False就是Django不自动加/
  38. """

三、无名和有名分组

  1. 分组：
  2.     定义：url的正则匹配项，将部分正则使用括号括起来
  4. 有名无名:
  5.     定义：在括号内的正则，起一个别名    
  6.     # 注意：不是url的第三个参数name
  9. 1、有名分组
  10.     定义：被'括号包含'的url的正则匹配项，起一个别名了
  11.     功能：会把'分组匹培到的内容'将'键值对'的形式传给对应的函数
  13.     正则案例：给[0-9]{4}正则项起别名:
  14.         (?P<year>[0-9]{4})        # 注意：是大写的P
  16. 有名分组例：
  17.     # urls.py
  18.     url(r'^hasname/(?P<year>[0-9]{4})',views.hasname)
  19.     #views.py
  20.     def hasname(request,**kwargs):
  21.     print(kwargs)
  22.     return HttpResponse("这是hasname")
  24.     流程1：
  25.         当输入    "127.0.0.1/hasname/1234/" ，urls路由匹配上hasname函数
  26.     流程2：
  27.         会把 year=1234 传给views.py的hasname的**kwargs
  30. """
  31. 在路由匹配如果将某部分正则使用括号括起来了
  32. 那么该部分正则匹配到的内容会当做关键字参数传递给后面的视图函数
  33. """
  36. 2、无名分组
  37.     定义：被'括号包含'的url的正则匹配项，没有起命名
  38.     功能：会把'分组匹培到的内容'按'位置参数'的形式传给对应的函数
  40. 无名分组例：
  41.     # urls.py
  42.     url(r'^noname/([0-9]{4})/',views.noname)  
  43.     #views.py
  44.     def noname(request,*args):
  45.     print(args)
  46.     return HttpResponse("这是noname")
  48.     流程1：
  49.         当输入    "127.0.0.1/test/1234/" ，urls路由匹配上noname函数
  50.     流程2：
  51.         会把 1234 传给views.py的noname的*args
  53. """
  54. 在路由匹配如果将某部分正则使用括号括起来了
  55. 那么该部分正则匹配到的内容会当做位置参数传递给后面的视图函数
  56. """

重要：

  1. 重要:
  2. 1、能否混用?
  3.     不能混用
  4.     url(r'^index/(\d+)/(?P<xxx>\d+)/',views.index)
  6. 2、单个情况下可以重复使用
  7. # 注意在views接受的时候要用*args和**kwargs接收。
  8.     url(r'^index/(\d+)/(\d+)/(\d+)/',views.index)
  9.     url(r'^index/(?P<yyy>\d+)/(?P<xxx>\d+)/',views.index)

四、反向解析

  1. 1.在路由层书写正则与函数名的时候 在后面加一个'唯一标识'
  2.     url(r'^login/',views.login,name='my_login')
  3. 2.前端反向解析
  4.     {% url 'my_login' %}
  5. 3.后端反向解析
  6.     from django.shortcuts import reverse
  7.     _url = reverse('my_login')
  8. """
  9. 通过标记解析出一个结果 该结果可以访问到标记所在的那一行地址
  10. """

反向解析案例：

1、需求：

  1.     # 当某个网址不是静态资源网址，会随着业务需求变更的时候，最好不要写死,利于后期维护
  2.     1、要求'127.0.0.1:8000/home/'网页上有跳转到'127.0.0.1:8000/func/'网页的标签
  3.     2、这个'127.0.0.1:8000/func/'的'/func/'不能写死
  4.     3、后期只要改url()的正则项，而不用再改html文件和views文件(也即网址更改，但是访问的内容不改)

2、准备

  1. ----------------------------'settings.py'-----------------------------------
  2. urlpatterns = [
  3.     url(r'^home/',views.home),
  4.     url(r'^func/',views.func,name="my_func")    # 起了个别名my_func
  5. ]
  7. ----------------------------'views.py'-----------------------------------
  8. from django.shortcuts import render,reverse
  10. def home(request):
  11.     return render(request,"home.html")
  13. def func(request):
  14.     print(reverse(viewname="my_func"))            #反向解析名
  15.     return render(request, "func.html")
  17. ----------------------------'home.html'-----------------------------------
  18. <body>
  19. <a href="{% url 'my_func' %}">111</a>
  20. <a href="{% url 'my_func' %}">222</a>
  21. <a href="{% url 'my_func' %}">333</a>
  22. <a href="{% url 'my_func' %}">444</a>
  23. <a href="{% url 'my_func' %}">555</a>
  24. <a href="{% url 'my_func' %}">666</a>
  25. </body>
  27. ----------------------------'func.html'-----------------------------------
  28. <body>
  29. <h1>这是func.html文件页面</h1>
  30. </body>

3、测试

  1. 1、打开web浏览器127.0.0.1:8000/home/
  2.     前端：①点击标签，正常跳转到127.0.0.1:8000/func/
  3.          ②访问到的是func.html文件
  4.     后端：pycharm打印出"/func/"
  6. 2、只修改url()的正则项
  7. urlpatterns = [
  8.     url(r'^home/',views.home),
  9.     url(r'^xxx/',views.func,name="my_func")    # 将/func/改为/xxx/
  10. ]
  12. 3、打开web浏览器127.0.0.1:8000/home/
  13.    前端：①点击标签跳转到127.0.0.1:8000/xxx/
  14.         ②依然访问func.html文件
  15.    后端：pycharm打印出"/xxx/"

结果

  1. 反向解析简单来说：
  2.     网页地址不是写死的,
  3.     而是通过'settings.py'的'url的第三个别名项',
  4.     让前端和后端通过别名查找'url的第一个正则匹配项'

五、无名有名反向解析

  1. 在理解了Django的：
  2.     1、分组
  3.     2、有名、无名
  4.     3、反向解析
  5. 可以继续往下结合应用
  6.     无名、有名分组、反向解析
  1. # 无名分组的反向解析
  2.     url(r'^login/(\d+)/',views.login,name='my_login')
  3.     后端
  4.         _url = reverse('my_login',args=(111,))
  5.         print(_url)  # /login/111/
  6.     前端
  7.         {% url 'my_login' 1 %}
  9. # 有名分组的反向解析
  10.     url(r'^login1/(?P<xxx>\d+)/',views.login1,name='my_login1')
  11.     后端
  12.         _url = reverse('my_login',kwargs={'xxx':123})
  13.         print(_url)  # /login/123/
  14.     前端
  15.         {% url 'my_login' xxx=1 %}
  17. """其实无名有名反向解析可以使用通用的方式"""
  18.     都可以使用无名分组的反向解析

测验

  1. 1.使用无名有名分组及反向解析完成ORM操作的数据增删改查(改 删)
  2. 2.整理今日内容及博客
  3. 3.使用虚拟环境下载一个django3.X版本备用

六、路由分发

  1. 当django项目特别庞大的时候 如果所有的路由匹配都写在项目的总路由中会导致总路由过于复杂不利于维护 此时可以将路由做拆分
  2. """
  3. django支持所有的应用都可以拥有自己的
  4.     urls.py 
  5.     templates文件夹 
  6.     static文件夹
  7. 也就意味着多人协同开发变得更加的简单了
  8. """
  9. 如何将多个单独的app组织到一起 >>> 路由分发
  12. 总路由
  13.     from app01 import urls as app01_urls
  14.     from app02 import urls as app02_urls
  15.     from django.conf.urls import url,include
  16.     # 路由分发
  17.     url(r'^app01/',include(app01_urls)),
  18.     url(r'^app02/',include(app02_urls)),
  19. 子路由
  20.     from django.conf.urls import url
  21.     from app01 import views
  22.     urlpatterns = [
  23.         url(r'^index/',views.index)
  24.     ]
  25. 子路由
  26.     from django.conf.urls import url
  27.     from app02 import views
  28.     urlpatterns = [
  29.         url(r'^index/',views.index)
  30.     ]
  32. # 更加简便的写法
  33.     url(r'^app01/',include('app01.urls')),
  34.     url(r'^app02/',include('app02.urls')),

七、名称空间(了解)

  1. # 当多个app中出现了相同的别名 那么使用反向解析无法自动识别
  3. 总路由
  4.     # 名称空间
  5.     url(r'^app01/',include('app01.urls',namespace='app01')),
  6.     url(r'^app02/',include('app02.urls',namespace='app02')),
  7. 反向解析
  8.     reverse('app01:my_index')
  9.     reverse('app02:my_index')
  10.     {% url 'app01:my_index' %}
  11.     {% url 'app02:my_index' %}
  13. """
  14. 名称空间其实也可以不用 只需要确保不同的app下别名不冲突即可
  15.     如何不冲突
  16.         可以在起别名的时候加上应用名前缀
  17.             app01_my_index
  18.             app02_my_index
  19. """

八、伪静态(了解)

  1. 静态页面
  2.     数据写死的 不怎么改变的
  3. 伪静态页面
  4.     看似是文件其实是动态网页 这么做事为了提高网站被搜索引擎收录的概率
  5. 将路径后缀改为.html形式即可

九、虚拟环境(了解)

  1. 虚拟环境能够实现针对不同的项目配备专属的编程环境
  2. 创建虚拟环境相当于重新下载了一个新的解释器
  5. 虚拟环境的唯一表示是venv文件夹