• Django——路由层

    一. 路由匹配

    1. 路由匹配注意事项

    1. urlpatterns = [
    2.     url(r'^admin/', admin.site.urls),
    3.     # 首页
    4.     url(r'^$',views.home),
    5.     # 路由匹配
    6.     url(r'^test/$',views.test),
    7.     url(r'^testadd/$',views.testadd),
    8.     # 尾页(了解):  后期使用异常捕获处理, 这样的尾页让django的第二次在路径中斜杠APPEND_SLASH=True失去了意义, 第二次的重定向追加斜杠的机制等于失效了.
    9.     url(r'',views.error),
    10. ]
    11.  
    12. '''
    13. 1. url方法第一个参数是正则表达式， 只要第一个参数正则表达式能够匹配到内容 那么就会立刻停止往下匹配, 而是直接调用对应的视图函数
    14. 2. 不需要添加一个前导的反斜杠，因为每个URL 都有。例如，应该是^test 而不是 ^/test。
    15. 3. 每个正则表达式前面的'r' 是可选的但是建议加上。r是raw的意思标识原生字符串，声明被修饰的字符串中所有字符是普通字符。
    16. 4. 在第一次正则匹配机制没有匹配到想要的内容时，会在匹配的内容后面加一个斜杠\, 然后django内部帮你进行重定向在重头开始再匹配一次
    17. 5. 每个由正则匹配成功后所捕获的参数都作为一个普通的Python字符串传递给视图
    18. '''

    2. 取消路由匹配第一次匹配不成功，在匹配的内容后面加一个斜杠\，重定向重新匹配

    1. # 取消自动加斜杠: 到settings.py文件中写入以下内容
    2. APPEND_SLASH = False	# 默认是True自动加斜杠

    二. 分组命名匹配

    1. 无名分组

    1. # 无名分组: 无须定义名字
    2.     路由书写: url('^index/(\d+)', views.index)
    3.     内部逻辑: 括号内正则表达式匹配到的内容将会当作位置参数传递给与之绑定的视图函数index
    4.     视图函数:
    5.         def index(request,xx):
    6.             print(xx)
    7.             return HttpResponse('index')

    2. 有名分组

    1. # 有名分组: 需定义名字
    2.     路由书写: url('^index/(?P\d+)', views.index)
    3.     内部逻辑: 括号内正则表达式匹配到的内容将会当作关键字参数传递给与之绑定的视图函数index
    4.     视图函数:
    5.         def index(request,year):
    6.             print(year)
    7.             return HttpResponse('index')

    3. 无名有名是否可以混合使用

    1. # 又名无名分组不可混用, 不过可以单种多次使用.
    2.     url('^index/(\d+)/(\d+)/', views.index)
    3.     url('^index/(?P\d+)/(?P\d+)/', views.index)
    4.  
    5.     
    6. # 多次使用如果是无名分组, 视图函数中可以使用*args接收参数
    7. def index(request, *args):
    8.     print(args)
    9.     return HttpResponse('index')
    10.  
    11.  
    12. # 多次使用如果是有名分组, 视图函数中可以使用**kwargs接收参数
    13. def index(request, **kwargs):
    14.     print(kwargs)
    15.     return HttpResponse('index')

    三. 传递额外的参数给视图函数（了解）

    URLconfs 具有一个钩子，让你传递一个Python 字典作为额外的参数传递给视图函数。

    django.conf.urls.url() 函数可以接收一个可选的第三个参数，它是一个字典，表示想要传递给视图函数的额外关键字参数。

    例如：

    1. from django.conf.urls import url
    2. from . import views 
    3.  
    4. urlpatterns = [
    5.     url(r'^blog/(?P[0-9]{4})/$', views.year_archive, {'foo': 'bar'}),
    6. ]

    在这个例子中，对于/blog/2005/请求，Django 将调用views.year_archive(request, year='2005', foo='bar')。
    这个技术在Syndication 框架中使用，来传递元数据和选项给视图。

    四. 反向解析

    反向解析也叫反向URL 匹配、反向URL 查询或者简单的URL 反查。

    1. 什么是反向解析?

    反向解析就是通过一些方法得到一个结果 该结果可以直接访问对应的url触发视图函数

    2. 反向解析基本使用

    1. 第一步: 在urls.py中给路由与视图函数取一个别名(注意: 别名不能重复, 一定要唯一)
    2.         url('^index/', views.index, name='xxx')
    3.         
    4. 第二步: 使用反向解析
    5.     在模板层使用:
    6.         {% url 'xxx' %}
    7.         "{% url 'ooo' %}">111
    8.     在视图层使用:
    9.         from django.shortcuts import reverse
    10.         reverse('xxx')

     

    3. 无名有名分组反向解析

    3.1 无名分组反向解析
    1. # 路由层配置无名分组反向解析
    2.     url(r'^index/(\d+)/',views.index,name='xxx')
    3.  
    4. # 模板层使用反向解析
    5.     {% url 'xxx' 123 %}
    6.  
    7. # 视图层使用反向解析
    8.     reverse('xxx', args=(1, ))
    9.  
    10. """
    11. 路由层url分组匹配机制这个数字并不是写死的,
    12. 一般情况下放的是数据的主键值, 我们可以通过获取到的数据的主键值进而定位到数据对象,
    13. 从而可以对数据进行编辑和删除, 如下示例:
    14. """
    15. # 路由层配置无名分组反向解析
    16.     url(r'^edit/(\d+)/', views.edit, name='xxx')
    17.  
    18. # 视图层使用反向解析
    19.     def edit(request,edit_id):
    20.         reverse('xxx', args=(edit_id,))
    21.  
    22. # 模板层使用反向解析
    23.     {% for user_obj in user_queryset %}
    24.         "{% url 'xxx' user_obj.id %}">编辑
    25.     {% endfor %}

    3.2 有名分组反向解析
    1. # 有名分组反向解析
    2.    url(r'^func/(?P\d+)/',views.func,name='ooo')
    3.  
    4. # 模板层使用反向解析
    5.     第一种写法:
    6.         "{% url 'ooo' year=123 %}">111
    7.     第二种写法:  推荐
    8.         "{% url 'ooo' 123 %}">222
    9.  
    10. # 视图层使用反向解析
    11.    第一种写法:
    12.         print(reverse('ooo',kwargs={'year':123}))
    13.    第二种写法:
    14.         print(reverse('ooo',args=(111,)))

    四. 路由分发

    1. '''
    2. django的每一个应用都可以有自己的templates文件夹, urls.py文件, 以及static文件夹, 只有基于上述的这种特点, django就能够非常好的做到分组开发, 也就是说每个人只写自己的app中的功能就可以了.
    3. 因此作为组长 只需要将手下书写的app全部拷贝到一个新的django项目中 然后在配置文件里面注册所有的app再利用路由分发的特点将所有的app整合起来就可以了.
    5. 因此, 当一个django项目中的url特别多的时候, 总路由urls.py代码非常冗余不好维护这个时候也可以利用路由分发来减轻总路由的压力.
    7. 利用路由分发之后, 总路由不再干路由与视图函数的直接对应关系,而是做一个分发处理, 进而识别当前url所属的应用, 最后直接分发给对应的应用去处理就行了.
    8. '''

    总路由:

    1. from django.conf.urls import url
    2. from django.conf.urls import include
    3. from django.contrib import admin
    4.  
    5.  
    6. urlpatterns = [
    7.     url(r'^admin/', admin.site.urls),
    8.     # 方式一:
    9.     from app01 import urls as app01_urls
    10.     from app02 import urls as app02_urls
    11.     url(r'^app01/', include(app01_urls))  # 只要url前缀是app01开头 全部交给app01处理
    12.     url(r'^app02/', include(app02_urls))
    13.  
    14.     # 方式二: 终极写法 推荐
    15.     url(r'^app02/', include('app01.urls'))
    16.     url(r'^app01/', include('app02.urls'))
    17. ]
    18. # 注意: 总路由中不要使用`^app01/$`这种格式, 不然无法分发给子路由

    子路由设置:

    1. # app01中urls.py的配置
    2.     from django.conf.urls import url
    3.     from app01 import views
    4.     urlpatterns = [
    5.         url(r'^index/', views.index),
    6.     ]
    7.  
    8. # app02中urls.py的配置
    9.     from django.conf.urls import url
    10.     from app02 import views
    11.     urlpatterns = [
    12.         url(r'^index/', views.index),
    13.     ]

    五. 名称空间

    为什么需要名称空间?

    1. """
    2. 当多个应用设置了相同的别名, 使用反向解析时, 如果经过路由匹配规则匹配之后结果一样,
    3. 就会出现后面的覆盖前面的, 如果你是想触发的是前面的视图函数, 那么将访问不到.
    5. 正常情况下的反向解析是没有办法自动识别前缀的.
    6. 注意!!!: 这里说的是正常情况下, 如果反向解析所对应的url分组个数一样, 那么是可以识别的. 
    7. """

    总路由中配置名称空间:

    1. from django.conf.urls import url
    2. from django.conf.urls import include
    3. urlpatterns = [
    4.     url('^app01/', include('app01.urls', namespace='app01')),
    5.     url('^app02/', include('app02.urls', namespace='app02')),
    6. ]

    子路由中匹配规则与别名相同:

    1. # app01中urls.py的配置
    2.     from django.conf.urls import url
    3.     from app01 import views
    4.     urlpatterns = [
    5.         url('^reg/', views.reg, name='reg'),
    6.     ]
    7.  
    8. # app02中urls.py的配置
    9.     from django.conf.urls import url
    10.     from app02 import views
    11.     urlpatterns = [
    12.         url('^reg/', views.reg, name='reg'),
    13.     ]

    子路使用反向解析:

    1. # 视图层使用名称空间语法进行反向解析
    2.     reverse('app01:reg')
    3.     reverse('app02:reg')
    4.     
    5. # 模板层使用名称空间语法进行反向解析
    6.     {% url 'app01:reg' %}
    7.     {% url 'app02:reg' %}

    补充: 其实只要保证名字不冲突 就没有必要使用名称空间

    1. """
    2. 一般情况下 有多个app的时候我们在起别名的时候会加上app的前缀
    3. 这样的话就能够确保多个app之间名字不冲突的问题
    4. """
    5.  
    6. urlpatterns = [
    7.     url(r'^reg/',views.reg,name='app01_reg')
    8. ]
    9. urlpatterns = [
    10.     url(r'^reg/',views.reg,name='app02_reg')
    11. ]

    六. 伪静态

    1. # 什么是静态网页?
    2.     静态网页数据是写死的, 万年不变的.
    3.  
    4. # 什么是伪静态?
    5.     伪静态是将一个动态网页伪装成静态网页.
    6.     
    7. # 为什么要有伪静态呢？
    8.     https://www.cnblogs.com/Dominic-Ji/p/9234099.html
    9.     伪静态的目的在于增大本网站的SEO查询力度, 并且增加搜索引擎收藏本网上的概率.
    10.     (SEO全称Search Engine Optimization 搜索引擎优化)
    11.  
    12.     其实, 搜索引擎本质上就是一个巨大的爬虫程序,
    13.  
    14.     总结:
    15.         无论你怎么优化 怎么处理
    16.         始终还是干不过RMB玩家

    路由层使用伪静态: reg.html

    1. # 路由配置
    2. urlpatterns = [
    3.     url(r'^register.html', views.register),
    4. ]
    5.  
    6. # 浏览器url访问
    7. http://127.0.0.1:8002/app01/register.html/

    七. 虚拟环境

    1. 在正常开发中 我们会给每一个项目配备一个该项目独有的解释器环境
    2. 该环境内只有该项目用到的模块 用不到一概不装
    3.  
    4. linux: 缺什么才装什么
    5.  
    6. 虚拟环境
    7.     你每创建一个虚拟环境就类似于重新下载了一个纯净的python解释器
    8.     但是虚拟环境不要创建太多，是需要消耗硬盘空间的
    9.  
    10. 扩展:
    11.     每一个项目都需要用到很多模块 并且每个模块版本可能还不一样
    12.     那我该如何安装呢？ 一个个看一个个装？？？
    13.  
    14.     开发当中我们会给每一个项目配备一个requirements.txt文件
    15.     里面书写了该项目所有的模块即版本
    16.     你只需要直接输入一条命令即可一键安装所有模块即版本

     

    八. django版本区别

    1. django1.X路由层使用的是url方法, 而在django2.Xhe3.X版本中路由层使用的是path方法

    1. url() 第一个参数支持正则
    2. path()第一个参数是不支持正则的 写什么就匹配什么
    3.  
    4. 如果你习惯使用path那么也给你提供了另外一个方法
    5.     from django.urls import path, re_path
    6.     from django.conf.urls import url
    7.  
    8.     re_path(r'^index/',index),
    9.     url(r'^login/',login)
    10.  
    11. 提示: 2.X和3.X里面的re_path就等价于1.X里面的url

    2. 虽然path不支持正则 但是它的内部支持五种转换器

    1. path('index//',index)
    2. # 将中匹配到的内容, 先转成int类型, 再以关键字参数传递给与之绑定的index视图函数
    3.  
    4. def index(request,id):
    5. print(id,type(id))
    6. return HttpResponse('index')
    7.  
    8. str,匹配除了路径分隔符（/）之外的非空字符串，这是默认的形式
    9. int,匹配正整数，包含0。
    10. slug,匹配字母、数字以及横杠、下划线组成的字符串。
    11. uuid,匹配格式化的uuid，如 075194d3-6885-417e-a8a8-6c931e272f00。
    12. path,匹配任何非空字符串，包含了路径分隔符（/）（不能用？）

    3. 除了有默认的五个转换器之外 还支持自定义转换器(了解)

    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是两个数字，返回的结果也必须是两个数字
    9.  
    10.  
    11. from django.urls import path,register_converter
    12. from app01.path_converts import MonthConverter
    13.  
    14. # 先注册转换器
    15. register_converter(MonthConverter,'mon')
    16.  
    17. from app01 import views
    18.  
    19.  
    20. urlpatterns = [
    21.     path('articles////', 	views.article_detail, name='aaa'),
    22. ]

    4. 模型层里面1.X外键默认都是级联更新删除的, 但是到了2.X和3.X中需要你自己手动配置参数

    1. models.ForeignKey(to='Publish')
    2.  
    3. models.ForeignKey(on_delete=models.CASCADE, on_update=models.CASCADE)

     

    补充: url中的第三个参数{}

    1. def url(regex, view, kwargs=None, name=None)
    2.     ...
    3.  
    4. # urls.py
    5.     url(r'^third_params/', views.third_params, {'username': 'egon'}, name='third_params'),
    6.  
    7. # views.py
    8.     # def third_params(request, path):     # 注意: 关键字形式传参
    9.     def third_params(request, username):
    10.         return HttpResponse(username)       # username返回到前端页面就是egon

    九. 总结

    1. # 路由匹配
    2.     1. urls.py中url方法第一个参数是正则
    3.     2. Django默认帮你开启了第一次匹配不成功, 往匹配效验的路径末尾追加一个斜杠/, 再进行重定向重新遍历循环匹配一次
    4.         配置: 默认settings.py中没有需要自己添加
    5.         APPEND_SLASH = False/True
    6.     3. 定义首页url匹配规则: url('^$', views.home)
    7.     4. 定义尾页url匹配规则: url('', views.error)
    8.         提示: 尾页一般不使用这种方式, 这种方式会让jango的默认APPEND_SLASH机制失效
    9.         之后我们可以使用异常处理, 来作为尾页内容.
    10.  
    11. # 分组
    12.     # 无名分组: 无须定义名字
    13.         路由书写: url('^index/(\d+)', views.index)
    14.         内部逻辑: 括号内正则表达式匹配到的内容将会当作位置参数传递给与之绑定的视图函数index
    15.         视图函数:
    16.             def index(request, xxx):
    17.                 pass
    18.  
    19.     # 有名分组: 需定义名字
    20.         路由书写: url('^index/(?P\d+)', views.index)
    21.         内部逻辑: 括号内正则表达式匹配到的内容将会当作关键字参数传递给与之绑定的视图函数index
    22.         视图函数:
    23.             def index(request, year):
    24.                 pass
    25.  
    26.     # 注意事项:
    27.         又名无名分组不可混用, 不过可以单种多次使用.
    28.             url('^index/(\d+)/(\d+)/', views.index)
    29.             url('^index/(?P\d+)/(?P\d+)/', views.index)
    30.  
    31.         多次使用如果是无名分组, 视图函数中可以使用*args接收参数
    32.             def index(request, *args):
    33.                 pass
    34.  
    35.         多次使用如果是有名分组, 视图函数中可以使用**kwargs接收参数
    36.              def index(request, *kwargs):
    37.                 pass
    38.  
    39.         
    40. # 反向解析
    41.     # 什么是反向解析?
    42.         反向解析就是通过一些方法得到一个结果 该结果可以直接访问对应的url触发视图函数
    43.  
    44.     # 反向解析使用
    45.         第一步: 在urls.py中给路由与视图函数取一个别名(注意: 别名不能重复, 一定要唯一)
    46.             url('^index/', views.index, name='xxx')
    47.  
    48.         第二部: 使用反向解析
    49.             在模板层使用:
    50.                 {% url 'xxx' %}
    51.                 "{% url 'ooo' %}">111
    52.             在视图层使用:
    53.                 from django.shortcuts import reverse
    54.                 reverse('xxx') 
    55.                 
    56.                 
    57. # 无名有名分组反向解析
    58.     # 无名分组反向解析
    59.         # 路由层定义
    60.             url(r'^index/(\d+), views.index, name='index')
    61.         # 模板层使用:
    62.             {% url 'index' 数字 %}
    63.         # 视图层使用:
    64.             from django.shortcuts import reverse
    65.             def index(request, xxx)
    66.                 reverse('index', agrs=(xxx, )
    68.     # 有名分组反向解析
    69.         # 路由层定义
    70.             url(r'^index/(?P\d+), views.index, name='index')
    71.         # 模板层使用:
    72.             {% url 'index' year=数字 %}
    73.             {% url 'index' 数字 %}
    74.         # 视图层使用:
    75.             from django.shortcuts import reverse
    76.             def index(request, year)
    77.                 reverse('index', kwagrs=({'year': 数字})
    78.                 reverse('index', agrs=(数字, )
    79.  
    80.     # 无名有名分组反向解析使用场景
    81.         应用: 一般用作主键值
    82.         模板层应用: 通过给HTMl页面绑定分组反向解析, 等待用户提交时, 同时携带用户数据的主键值,
    83.             视图层获取到不同操作反馈过来的动态主键值, models就可以基于这个主键值, 来对当前操作
    84.             用户的其他数据进行定位.
    85.         视图层应用: 通过反向解析进行重定向操作
    86.  
    87.     # 注意: 无名有名分组反向解析是争对单个情况的解析, 对于反向解析时的参数,
    88.         只要是满足对于路由的正则匹配规则就行.
    89.  
    90.  
    91. # 路由分发:
    92.     # 因该分发的部分: templates, urls.py, models.py
    93.     # 路由分发的优势: 多应用之间路由不冲突, 减轻总路由的压力及维护性差的问题, 解耦合可以更好的实现分组开发
    94.     # 总路由设置:
    95.         from django.conf.urls import url
    96.         from django.conf.urls import include
    97.         urlpatterns = [
    98.             url(r'^admin/', admin.site.urls),
    99.             # 方式一:
    100.             from app01 import urls as app01_urls
    101.             from app02 import urls as app02_urls
    102.             url(r'^app01/', include(app01_urls))  # 只要url前缀是app01开头 全部交给app01处理
    103.             url(r'^app02/', include(app02_urls))
    104.  
    105.             # 方式二: 终极写法 推荐
    106.             url(r'^app02/', include('app01.urls'))
    107.             url(r'^app01/', include('app02.urls'))
    108.         ]
    109.         # 注意: 总路由中不要使用`^app01/$`这种格式, 不然无法分发给子路由
    110.  
    111.     # 子路由设置:
    112.         # app01中urls.py的配置
    113.             from django.conf.urls import url
    114.             from app01 import views
    115.             urlpatterns = [
    116.                 url(r'^index/', views.index),
    117.             ]
    118.  
    119.         # app02中urls.py的配置
    120.             from django.conf.urls import url
    121.             from app02 import views
    122.             urlpatterns = [
    123.                 url(r'^index/', views.index),
    124.             ]
    125.  
    126.  
    127. # 名称空间
    128.     # 为什么需要名称空间?
    129.        当多个应用中的路由设置了相同的别名, 使用反向解析时,          就会出现后面的覆盖前面的, 如果你是想触发的是前面的视图函数, 那么将访问不到.
    130.  
    131.     # 总路由中配置名称空间
    132.         from django.conf.urls import url
    133.         from django.conf.urls import include
    134.         urlpatterns = [
    135.             url('^app01/', include('app01.urls', namespace='app01')),
    136.             url('^app02/', include('app02.urls', namespace='app02')),
    137.         ]
    138.  
    139.     # 子路由中匹配规则与别名相同
    140.         # app01中urls.py的配置
    141.             from django.conf.urls import url
    142.             from app01 import views
    143.             urlpatterns = [
    144.                 url('^reg/', views.reg, name='reg'),
    145.             ]
    146.  
    147.         # app02中urls.py的配置
    148.             from django.conf.urls import url
    149.             from app02 import views
    150.             urlpatterns = [
    151.                 url('^reg/', views.reg, name='reg'),
    152.             ]
    153.  
    154.     # 子路由使用名称空间语法进行反向解析
    155.         # 视图层使用名称空间语法进行反向解析
    156.             reverse('app01:reg')
    157.             reverse('app02:reg')
    158.  
    159.         # 模板层使用名称空间语法进行反向解析
    160.             {% url 'app01:reg' %}
    161.             {% url 'app02:reg' %}
    162.  
    163.     # 补充:  其实只要保证名字不冲突 就没有必要使用名称空间
    164.         urlpatterns = [
    165.             url('^reg/', views.reg, name='app01_reg'),
    166.         ]
    167.         urlpatterns = [
    168.             url('^reg/', views.reg, name='app02_reg'),
    169.         ]
    170.  
    171.  
    172. # 伪静态
    173.     静态网页: 网页数据写死
    174.     伪静态: 将动态网页伪装成静态网页
    175.     作用: 提升网站SEO查询力度, 增加收藏网页概率. -> 爬虫搜索引擎
    176.     路由层使用伪静态:
    177.         urlpatterns = [
    178.             url('^reg.html/', views.reg, name='app01_reg'),
    179.         ]
    180.  
    181. # 虚拟环境部署
    182.  
    183. # django版本区别
    184.     1. django1.x版本路由层使用的是url方法, 而django2.x和3.x路由层使用的是path方法
    185.         1.x版本路由匹配支持正则
    186.         2.x和3.x版本path不支持正则, 如果想要支持正则导入re_path. 虽然保留了url方法但是不推荐使用了.
    187.  
    188.     2. django2.x和3.x版本虽然不支持正则, 但是它内部支持五种装换器
    189.         from django.urls import path
    190.         path('index/', views.index)
    191.         将<int:id>中匹配到的内容, 先转成int类型, 再以关键字参数传递给与之绑定的index视图函数
    192.  
    193.     3. 转换器支持自定义
    194.     4. 模型层中1.x默认级联更新级联删除, 而2.x和3.x版本需要手动指定
    195.         publish = models.ForeignKey(to='Publish', on_update=models.CASCADE, on_delete=models.CASCADE)
  • 相关阅读:
    TailwindCss Functions & Directives
    Web 前端基础—— Http 和CSS 学习笔记
    e智团队实验室项目-第二周-卷积神经网络的学习
    nuxt.js 进行项目重构-首页
    RabbitMQ
    计算机系统（23）--- 死锁的处理策略
    Linux_C_入门篇学习笔记
    【MongoDB】索引 – 文本索引（指定语言）
    【Python】JSON格式文件处理
    基于C#实现协同推荐 SlopeOne 算法
  • 原文地址：https://blog.csdn.net/m0_71115526/article/details/134376978