标签：index name app 虚拟环境反向 func path 分组路由

Ⅰ 反向解析

【一】基础的URL配置

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

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

【二】问题引入

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

【1】页面上有很多a标签链接了其他路由

index.html代码


<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<a href="/func/">func</a>
<a href="/func/">func</a>
<a href="/func/">func</a>
<a href="/func/">func</a>
<a href="/func/">func</a>
<a href="/func/">func</a>
<a href="/func/">func</a>
<a href="/func/">func</a>

</body>
</html>

views.py代码

from django.shortcuts import render,HttpResponse

# Create your views here.
def index(request):
    return render(request, 'index.html')


def func(request):
    return HttpResponse('from func view')

图片展示

点开之后

【2】路由匹配表达式出现了变化，html页面上的地址全部失效

将func变为func666

再点击网页上的a超链接

【三】解决方案

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

【四】解决方案实现

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

【1】前端使用起别名

# 原理是 根据 当前 url 的名字去 路由系统中找对应名字的路径 然后将路径添加到制定位置
# 在定义路由和视图映射时候加上一个参数 name="自定义值"
from django.urls import path
from  user.views import index,func

urlpatterns = [
    path('admin/', admin.site.urls),

    path('index/',index),
    path('func666/',func,name='func_view'),

使用{% url '路由规则名字' %}并且现在再前端页面点击也可以跳转

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<a href="/func/">func</a>
<a href="/func/">func</a>
<a href="/func/">func</a>
<a href="/func/">func</a>

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


</body>
</html>

现在重新修改URL

from django.contrib import admin
from django.urls import path
from  user.views import index,func


urlpatterns = [
    path('admin/', admin.site.urls),

    path('index/',index),
    path('func9999999/',func,name='func_view'),

点击之后，可以跳转

【2】后端使用

from django.shortcuts import reverse
reverse("定义的规则名字") ---> 帮你解析到指定的路由规则

from django.shortcuts import render,HttpResponse,reverse

# Create your views here.
def index(request):
    print(reverse('func_view'))
    # 现在指定跳转就是
    return render(to=reverse('func_view'))

def func(request):
    return HttpResponse('from func view')

Ⅱ 有名分组和无名分组的反向解析

本质上还是通过一些方法得到一个结果，该结果可以访问到对应的url从而触发相应的视图和功能

【一】无名分组反向路由解析

【1】前端的反向解析

from django.contrib import admin
from django.urls import path,re_path
from  user.views import index,func,no_name,have_name

urlpatterns = [
    # 有几个参数就直接向后加(\d+)/即可
    re_path(r'^no_name/(\d+)/(\d+)/',no_name,name='no_name'),
    re_path(r'^have_name/(?P<year>\d+)/',have_name,name='have_name')
]

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<h1>旧语法</h1>
<a href="http://localhost:8000/no_name/1/">no</a>
<a href="http://localhost:8000/have_name/2/">have</a>

<h1>新语法</h1>
<a href="{% url 'no_name' 1  %}">no</a>
<a href="{% url 'have_name' '2' %}">have</a>

</body>
</html>

【2】后端的反向解析

from django.shortcuts import render, HttpResponse, reverse

def no_name(request, *args, **kwargs):
    # 这里反向解析的时候如果 路由路径代参数但是你没有解析进去传参数 就会报错
	# print(reverse("no_name"))
	# 无名分组在传递参数的时候不仅仅要加 规则名字 还要加 args = (元组)
    print(reverse("no_name", args=('1', '2')))

【二】有名分组的反向解析

【1】前端的反向解析

# 有几个参数(?P<year>\d+)，前端在规则名字后面就直接向后加即可，如：'2'
 re_path(r'^have_name/(?P<year>\d+)/',have_name,name='have_name')

<p><a href="{% url 'have_name' '2' %}">you_name</a></p>

【2】后端反向解析

# 有名分组可以按照位置传递参数 这样传递参数的时候就不能随便换位置
print(reverse("have_name", args=(1,)))
# 有名分组还可以按照关键字传递参数 这样传递参数就可以打乱位置传递 关键字对应即可
print(reverse("have_name", kwargs={"year":1}))

【三】代码展示

index.html

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

<a href="/func/">func</a>
<a href="/func/">func</a>
<a href="/func/">func</a>
<a href="/func/">func</a>


<h1>旧语法</h1>
<a href="http://localhost:8000/no_name/1/">no</a>
<a href="http://localhost:8000/have_name/2/">have</a>

<h1>新语法</h1>
<a href="{% url 'no_name' 1 2 %}">no</a>
<a href="{% url 'have_name' '2' %}">have</a>

</body>
</html>

views.py

from django.shortcuts import render, HttpResponse, reverse


# Create your views here.
def index(request):
    return render(request, 'index.html')


def func(request):
    return HttpResponse('from func view')


def no_name(request, *args, **kwargs):
    # 这里反向解析的时候如果 路由路径带参数但是你没有 解析进去传参数 就会报错

    # 无名分组在传递参数的时候不仅仅要加 规则名字 还要加 args = (元祖)
    print(reverse("no_name", args=('1', '2')))
    print(args)
    print(kwargs)

    return HttpResponse('no_name')


def have_name(request, *args, **kwargs):
    print(reverse('have_name',args=(1,)))
    # 有名分组还可以按照关键字传递参数 这样传递参数就可以打乱位置传递 关键字对应即可
    print(reverse('have_name', kwargs={'year':1}))

    print(args)
    print(kwargs)
    return HttpResponse('have_name')

urls.py

from django.contrib import admin
from django.urls import path,re_path
from  user.views import index,func,no_name,have_name


urlpatterns = [
    path('admin/', admin.site.urls),
    path('index/', index),
    path('func/', func),

    re_path(r'^no_name/(\d+)/(\d+)/',no_name,name='no_name'),
    re_path(r'^have_name/(?P<year>\d+)/',have_name,name='have_name')
]

Ⅲ 路由分发

【一】前言引入

# 一个Django项目下面有 4 个APP
# 4个APP下面又有 10 个接口(路由映射规则)
# urlpatterns 里面就要写  40 个接口规则
# 所有接口都写在同一个 urls.py 文件中的时候就会导致整个文件的内容杂乱并且冗余

Django每一个应用都可以拥有属于自己的
- templates文件夹
- urls.py
- static文件夹
正是基于上述的特点，Django可以很好的做到自己的分组开发(每个人只写自己的app)
最后只需要将所有的app拷贝到新的文件，并将这些APP注册到配置文件中，然后再利用路由分发的特点，将所有的APP整合起来
当一个项目中的URL特别多的时候，总路由urls.py的代码非常冗余而且不好维护，这个时候就可以利用路由分发来减轻总路由的压力
利用路由分发之后，总路由不再干预路由与视图函数的直接对应关系
- 而是做一个分发处理
- 识别当前的url是属于哪个应用下的，直接分发给对应的应用去处理

【二】路由分发系统

通常，我们会在每个app里，各自创建一个urls.py路由模块，然后从根路由出发，将app所属的url请求，全部转发到相应的urls.py模块中。

# 在每一个APP下面都有一个属于自己的 路由映射规则文件
# 将所有的规则文件统合到一起
# 再根据制定的规则进行分发

# user
#   login
#   register
#   logout
# shop
#   buy_good
#   payfor

# 【一】原本的路由规则模式
urlpatterns = [
    path('user/login/', login),
    path('user/register/', register),
    path('user/logout/', logout),
    path('shop/buy_good/', buy_good),
    path('shop/payfor/', payfor),
    ]
# 【二】Django的路由分发系统
urlpatterns = [ ]
# 分配所有的用户功能
user_urlpatterns = [
    path('user/login/', login),
    path('user/register/', register),
    path('user/logout/', logout),
]
# 分配所有的购物功能
shop_urlpatterns = [
    path('shop/buy_good/', buy_good),
    path('shop/payfor/', payfor),
]
urlpatterns += user_urlpatterns
urlpatterns += shop_urlpatterns
# 【3】将每个路由映射规则分配到每个app下面
# 在每一个app下面新建一个 urls.py
# 在总的路由中定义每一个子路由规则
from django.urls import include
path("user/",include("user.urls")),
path("shop/",include("shop.urls")),
# 有问题 ： does not appear to have any patterns in it.
# 启动Django项目会报错 ---> 上面  urls.py 文件是空的
# 根目录下的  urls.py 文件是有参数的
# 要新加一个参数  urlpatterns = []
# 在每一个app下面配置相应的路由映射关系即可
# 解决办法：在每一个 app 下面的空文件中增加一个内容
urlpatterns = []

【三】路由分发后的反向解析

# 【四】路由分发后的反向解析
path("user/",include("user.urls")),

urlpatterns = [
path("user/admin/login",login,name="login")
]
# 在你 user app 下面的每一个路由规则中都会为你 匹配一个 user 前缀
# 如果想让每一个 app 下面你的路由规则都进行分类
# 在指定分发的时候就必须戴前缀
# 不分类就什么 都别写

# 访问的网址路径应该是 http://127.0.0.1:8000/user/user/admin/login

# 如果不反向解析 你自己写的路径可能就是 http://127.0.0.1:8000/user/admin/login
# 所以当路由太多的时候我们会选择使用路由反向解析

# 如果是自己写的路由规则路径 在前端使用可能会失效
# 所以为了避免是自己的失误，建议使用 Django提供的路由解析方案

【四】路由携带额外参数

path("buy/<int:year>/", buy, {"good_name": "玩偶"}, name="buy")


def buy(request,*args,**kwargs):
    print(args)
    print(kwargs)
    return HttpResponse("buy")
    
http://localhost:8000/shop/buy/2/

# {'year': 2, 'good_name': '玩偶'}

【五】include分发携带额外参数

# include 分发路由的时候传递额外的参数
# include 分发路由 传递的参数 是每一个分路由接口都会携带的参数

path("shop/", include("shop.urls"), {"tag": "shop"}),


访问 buy 的时候 
iclude 分发 带了  {"tag": "shop"}
buy 自己有一个 {"good_name": "玩偶"}

# {'tag': 'shop', 'year': 2, 'good_name': '玩偶'}

Ⅳ 名称空间

【一】应用命名空间(app_name)

【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的属性，帮我们实现应用级别的命名空间，这样，虽然大家都叫‘大伟’，但一个是‘张大伟’，一个是‘王大伟’，自然就分清楚了甲乙丙丁。

# 在每一个app下面的 urls.py 中增加配置项
# app_name = "your_app_name"

from django.urls import path

from . import views

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

urlpatterns = [
    ...
]

# 在做反向解析的时候
# 前端 : {% url 'user:login'%}
# 后端 : reverse("user:login")

【3】使用方法

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

# 后端中
reverse('your_app_name:index',args=(...))

# 前端中
{% url 'your_app_name:index': ... %}

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

#user app 

# urls.py
app_name = 'user'
path('index/', index, name="index"),

# views.py 
def index(request):
    # 后端解析
    print(reverse("user:index"))  # /user/index/
    return HttpResponse("user 下的 index")
    
    
# 前端解析
<p><a href="{% url 'user:index' %}">user 下 的 index页面</a></p>

# shop app 
app_name = 'shop'
path("index/", index, name="index"),

# views.py
def index(request):
    print(reverse("shop:index")) # /shop/index/
    return HttpResponse(" shop 下的 index")

# 前端解析
<p><a href="{% url 'shop:index' %}">shop 下 的 index页面</a></p>

【二】include 分发的时候里面有一个参数 namespace

【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:index',args=(...))这样？
显然是不行的，因为多个应用的实例共享应用空间名，通过app_name是区分不了的！
针对这种情况，Django提供了一个namespace属性，用于标记不同的应用实例，如下所示：

# 总路由进行分发的时候指定  app_name 以及 namespace 名称空间
path("shop/", include(("shop.urls", "shop"), namespace="shop")),
path("user/", include(("user.urls", "user"), namespace="user")),

# 在做反向解析的时候
# 前端 : {% url 'user:login'%}
# 后端 : reverse("user:login")

Ⅴ 虚拟环境

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

【一】虚拟环境

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

【二】模块管理文件

每个项目都需要用到很多模块，并且每个模块的版本可能是不一样的
这种情况下我们会给每一个项目配备一个requirements.txt文件，里面存放着我们这个项目所安装的所有模块及版本
只需要一条命令即可安装所有模块及版本

【三】模块文件导出和安装

【1】导出项目模块文件

# 导出
pip freeze > requirements.txt

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

【2】安装项目模块文件

# 安装
pip install -r requirements.txt

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

【四】虚拟环境补充

# 虚拟环境的使用
# 【一】创建虚拟环境
# 【1】Python自带的 venv 工具
# 【2】Python第三方模块 vertrualenv
# 【3】使用 pycahrm创建虚拟环境

# 【二】使用虚拟环境的目的
# 是为了项目与项目之间模块的隔离
# 一个项目使用 Django 3.2.12 版本写的 --- MySQL 5.44  --- 虚拟环境
# 另一个项目是 Django 5.0 写的 --- MySQL 8.0 -- 创建一个虚拟环境

# 你自己在本地使用虚拟环境不会有任何问题
# 将你的项目以及你的虚拟环境打包给别人用 ---> 解包 ---> 虚拟环境直接失效
# 别人用不了 ---> 他也不知道你到底安装了哪些模块

# 【三】将模块批量导出 以及 批量安装
# 【1】批量导出
# pip freeze > requirements.txt
# 回车后发现没有输出
# 在当前项目目录下多了一个 requirements.txt 在里面有你当前环境所有的模块及模块版本
# 【2】批量安装
# pip install -r requirements.txt
# 读取到 requirements.txt 里面的所有模块和版本
# 挨个进行安装

Ⅵ 路径转换器

【一】Django路径转换器 Django2.x 开始出现的

【二】语法

path("路由规则",视图函数名,name="路由解析名")

【三】在每一个路由中都可能会进行携带参数

解决参数的携带问题于是就有了路径转换器

【四】Django 提供了五种路径转换器

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

【四】自定义转换器

Django支持自定义转换器

# 【1】创建一个 .py 文件(名字自定义) 
# path_converters.py ---> 路径中不要有 空格
# 【2】在文件中定义方法
#在文件中定义一个类
# 在类里面吗写两个方法
# to_python : 将参数转换为 Python类型
# to_url : 匹配路径上的参数的

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

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

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

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

# 【3】使用
# 在视图函数中引入当前自定义转换器
# 导入内置的 转换器注册函数
# （1）将自定义的转换器注册成Django的转换器

from django.urls import  register_converter
# （2）导入转换器
from user.path_converters import FourDigitYearConverter
# （3）注册自定义转换器
register_converter(类名,type_name= '自定义转换器名字')
parse_self = register_converter(FourDigitYearConverter, 'my_path')
# （4）在路由中使用转换器
# path("login/<别名:后端的参数名>/",login,name="login")
# 访问指定接口的时候就会对路径参数进行提起并处理成指定的数据格式 (自定义转换器类里面的 to_python 决定的)
path("self_parse/<my_path:param>/", self_parse, name="self_parse")

def self_parse(request, param, *args, **kwargs):
    print(param, type(param)) # 9999 <class 'int'>
    print(args)
    print(kwargs)
    return redirect(reverse("index_home"))

标签：index,name,app,虚拟环境,反向,func,path,分组,路由
From： https://www.cnblogs.com/zyb123/p/18260629

虚拟环境 反向解析,有名分组和无名分组的反向解析,路由分发,名称空间,虚拟环境,路径转换器

Ⅰ 反向解析

【一】基础的URL配置

【二】问题引入

【1】页面上有很多a标签链接了其他路由

【2】路由匹配表达式出现了变化，html页面上的地址全部失效

【三】解决方案

【四】解决方案实现

【1】前端使用起别名

【2】后端使用

Ⅱ 有名分组和无名分组的反向解析

【一】无名分组反向路由解析

【1】前端的反向解析

【2】后端的反向解析

【二】有名分组的反向解析

【1】前端的反向解析

【2】后端反向解析

【三】代码展示

Ⅲ 路由分发

【一】前言引入

【二】路由分发系统

【三】路由分发后的反向解析

【四】路由携带额外参数

【五】include分发携带额外参数

Ⅳ 名称空间

【一】应用命名空间(app_name)

【1】引入

【2】解决方案

【3】使用方法

【二】include 分发的时候里面有一个参数 namespace

【1】引入

【2】问题

Ⅴ 虚拟环境

【一】虚拟环境

【二】模块管理文件

【三】模块文件导出和安装

【1】导出项目模块文件

【2】安装项目模块文件

【四】虚拟环境补充

Ⅵ 路径转换器

【一】Django路径转换器 Django2.x 开始出现的

【二】语法

【三】在每一个路由中都可能会进行携带参数

【四】Django 提供了五种路径转换器

【四】自定义转换器

相关文章

赞助商

阅读排行

虚拟环境反向解析,有名分组和无名分组的反向解析,路由分发,名称空间,虚拟环境,路径转换器