【三】路由转换器_路由转换器的作用-CSDN博客

本文链接：https://blog.csdn.net/m0_58310590/article/details/137355251

1.浏览器输入网址后，发生了哪些事

解析为域名，并通过 DNS 查找该域名对应的 IP 地址。
浏览器使用获取到的 IP 地址跟服务器建立 TCP 连接。
浏览器向服务器发送 HTTP 请求（GET、POST 等），请求包含所需的资源和其他参数。
服务器接收到请求后，处理请求并返回 HTTP 响应，响应包含所请求的资源以及其他相关信息。
浏览器接收到响应后，根据响应中的内容进行渲染和显示，最终呈现给用户。

2.如何阻止事件冒泡

使用event.stopPropagation()方法

3.什么是事务，如何开启事务

事务是指一系列数据库操作被视为一个单独的工作单元，要么全部成功执行，要么全部回滚到初始状态，保持数据库的一致性和完整性。

START TRANSACTION;

1.MySQL的索引类型有哪些，如何加索引

主键约束（PRIMARY KEY）：
主键约束用于定义一个表中的唯一标识符，每个表只能有一个主键。主键通常与索引相关联，以提高主键字段的查询性能。
唯一约束（UNIQUE）：
唯一约束用于确保一个或多个字段的值在表中是唯一的。唯一约束通常与索引相关联，以提高唯一字段的查询性能。
外键约束（FOREIGN KEY）：
外键约束用于定义表之间的关系，确保引用表中的值与被引用表中的值保持一致。外键约束通常与索引相关联，以提高外键字段的查询性能。
普通索引（INDEX）：
普通索引是最常见的索引类型，它用于加速查询操作。普通索引可以基于一个或多个字段创建，以提高这些字段的查询性能。

2.为什么计算密集型用多进程，io密集型用多线程

主要是基于它们对计算资源和IO资源的需求不同。

计算密集型任务主要涉及大量的CPU计算，而对于计算资源的利用是关键。多进程可以充分利用多核CPU的并行计算能力。
IO密集型任务主要涉及大量的IO操作，如读写文件、网络通信等。在这种情况下，计算资源的利用并不是瓶颈，而是IO资源的利用成为关键。

【前言】Django的路由系统

URL调度器 | Django 文档 | Django (djangoproject.com)
URL配置(URLconf)就像Django 所支撑网站的目录。

Django生命周期请求流程图

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

缓存数据库
- 提前已经将你想要的数据准备好了你来直接拿就可以
- 提高效率和响应时间

一般流程：

浏览器发送请求：当用户在浏览器中访问 Django 网站时，浏览器将发送 HTTP 请求到服务器。
web 服务器：web 服务器（如 Apache、Nginx）接收到请求后，将其传递给 Django 的 Web 服务网关接口（WSGI）。
WSGI 接口：WSGI 接口是 Django 与 web 服务器之间的桥梁。Django 使用 WSGI 接口来处理请求和生成响应。WSGI 接口可以处理高并发请求，不受 1000 并发连接的限制。
中间件处理：在 Django 中，中间件组件是在请求和视图处理之间进行处理的。中间件可以执行各种任务，如身份验证、日志记录、请求/响应转换等。
URL 路由：Django 的 URL 路由系统根据请求的 URL 决定将请求发送给哪个视图处理函数。URL 路由系统会根据项目中的 URL 配置文件（通常是 urls.py）将请求与相应的视图函数进行匹配。
视图处理函数：一旦 URL 路由系统确定了要调用的视图处理函数，Django 将创建一个包含请求信息的 HttpRequest 对象，并将其传递给视图处理函数。视图处理函数负责处理请求并生成响应。
模型层：在视图处理函数中，你可以使用 Django 的模型层来与数据库进行交互。模型层定义了与数据库表对应的模型类，你可以使用这些模型类执行数据库操作，如查询、插入、更新等。
模板渲染：在视图函数中，你可以使用 Django 的模板系统来生成动态的 HTML 页面。模板系统允许你将数据与 HTML 模板进行结合，生成最终的响应内容。
响应返回：视图函数生成的 HttpResponse 对象将作为响应返回给客户端。响应可以包含 HTML 内容、重定向指令、错误状态码等。
响应发送：最终，WSGI 接口将响应发送回 web 服务器，web 服务器将其返回给浏览器，浏览器接收到响应后将其显示在界面上。

【一】路由匹配

【1】前言

url(r'test',views.test),
url(r'testadd',views.testadd)

url方法第一个参数是正则表达式。
- 只要你第一个参数正则表达式能匹配到内容。那么就会立即定制往下匹配。
- 直接执行对应的视图函数。
你在输入url的时候会默认加斜杠。
- Django内部帮你做到重定向。
  - 一次匹配不行。
  - url后面加斜杠再来一次。

取消自动加斜杠

APPEND_SLASH = False

url(r'^test/$',views.test),
url(r'testadd',views.testadd)

第一种

# 设置主界面
#  urls.py文件
url(r'^$',views.test),

# views.py文件
	def redirect_view(request):
    	return HttpResponse('Hello, world!')

第二种

# 设置主界面
#  urls.py文件
path('', home, name='home'),

# views.py文件
def home(request):
    return render(request, 'home.html')

【2】路由匹配规则

Django 的 URL 路由系统使用正则表达式来匹配请求的 URL，并将其映射到相应的视图处理函数。下面是 Django 路由匹配规则的一般流程：

URL 配置文件：在 Django 项目中，通常有一个名为 urls.py 的文件，用于配置 URL 路由规则。该文件位于项目的根目录或某个应用程序的目录中。
导入模块：在Django的2x版本中在 urls.py 文件中，首先需要导入必要的模块和函数。通常会导入 django.urls 模块中的 path 或 re_path 函数。
定义 URL 规则：在 urls.py 文件中，使用 path 或 re_path 函数来定义 URL 规则。这些函数接受两个参数：URL 模式和要调用的视图处理函数。
- path 函数使用简单的字符串模式进行匹配，例如 path('about/', views.about) 表示匹配以 about/ 结尾的 URL。
- re_path 函数使用正则表达式模式进行匹配，例如 re_path(r'^articles/(?P<slug>[\w-]+)/$', views.article) 表示匹配类似于 articles/some-article/ 的 URL，其中 some-article 是一个参数。
参数传递：如果在 URL 模式中定义了参数（使用 <param_name> 或正则表达式捕获组），Django 将提取这些参数的值，并将其作为关键字参数传递给视图处理函数。
URL 优先级：URL 路由系统按照在 urls.py 文件中定义的顺序逐个匹配 URL 规则。当匹配到第一个符合条件的规则时，将停止匹配后续规则。
包含其他 URL 配置：在 urls.py 文件中，可以使用 include 函数来包含其他 URL 配置文件。这样可以将 URL 配置分解为多个文件，使其更加模块化和可维护。
命名 URL 模式：可以给 URL 规则命名，以便在模板中和其他地方引用。使用 name 参数来为 URL 规则命名，例如 path('articles/', views.article_list, name='article-list')。

【二】URL配置

【1】什么是URL配置

URL配置是指定义URL模式和对应视图函数之间映射关系的过程。URL配置告诉Django如何解析传入的URL，并将其路由到相应的视图函数处理。

URL配置的本质是建立URL模式和视图函数之间的映射关系。
它告诉Django如何解析传入的URL，并将其路由到相应的视图函数处理。
可以将用户的URL请求与相应的处理逻辑关联起来，实现网站的页面导航和功能交互。

URL配置的本质是实现了URL的分发和路由功能，将用户请求导向正确的处理函数，从而完成相应的操作和返回相应的结果。

【2】基本格式

（1）Django 1.x版本的

from django.conf.urls import url

#循环urlpatterns，找到对应的函数执行,匹配上一个路径就找到对应的函数执行，就不再往下循环了，并给函数传一个参数request，和wsgiref的environ类似，就是请求信息的所有内容

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

r'正则表达式': 正则表达式用于匹配 URL 地址。
views.视图函数: 指定处理该 URL 请求的视图函数。
参数: 可以将额外的参数传递给视图函数。这些参数可以是字典、列表或其他数据类型
name='别名': 为该 URL 路由规则指定一个别名。别名可以在模板中使用 {% url '别名' %} 的方式来生成相应的 URL 地址

（2）Django 2.x版本

注意：

Django 2.0版本中的路由系统已经替换成下面的写法，但是django2.0是向下兼容1.x版本的语法的（官方文档）

# urls.py
from django.urls import path

urlpatterns = [
    path('articles/2003/', views.special_case_2003),
    # http://127.0.0.1:8000/articles/2003/ 
    path('articles/<int:year>/', views.year_archive),
    # http://127.0.0.1:8000/articles/2023/
    path('articles/<int:year>/<int:month>/', views.month_archive),
    # http://127.0.0.1:8000/articles/2023/12/
    path('articles/<int:year>/<int:month>/<slug:slug>/', views.article_detail),
    # http://127.0.0.1:8000/articles/2023/12/example-article/ 
]

views.py
def special_case_2003(request):
    return HttpResponse("This is a special case for year 2003")

def year_archive(request, year):
    return HttpResponse("Year archive: {}".format(year))

def month_archive(request, year, month):
    return HttpResponse("Month archive: {} {}".format(year, month))

def article_detail(request, year, month, slug):
    return HttpResponse("Article detail: {} {} {}".format(year, month, slug))

【3】使用正则表达式

如果路径和转化器语法不能很好的定义你的 URL 模式，你可以可以使用正则表达式。如果要这样做，请使用 re_path() 而不是 path() 。
在 Python 正则表达式中，命名正则表达式组的语法是

(?P<name>pattern) ，其中 name 是组名，pattern 是要匹配的模式。
这里是先前 URLconf 的一些例子，现在用正则表达式重写一下：

urlpatterns = [
    path('articles/2003/', views.special_case_2003),
    re_path(r'^articles/(?P<year>[0-9]{4})/$', views.year_archive),
    re_path(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/$', views.month_archive),
    re_path(r'^articles/(?P<year>[0-9]{4})/(?P<month>[0-9]{2})/(?P<slug>[\w-]+)/$', views.article_detail),
]

【三】分组

无名分组

分组：就是给某一端正则表达式用小括号扩起来
无名分组就是将括号内正则表达式匹配到的内容位置参数传递给后面的视图函数。

# urls.py
from django.urls import path
from django.urls import re_path
from . import views

urlpatterns = [
    # 无名分组
    re_path(r'^text/(\d+)/$', views.text),
     # http://127.0.0.1:8000/text/1/
]

views.py
def text(request, dep):
    dep_value = request.GET.get("dep")  # 获取查询参数
    print(dep_value)
    return HttpResponse(f'这是无名分组！: {dep_value}')  # 使用 f-string 进行字符串格式化

有名分组

可以给正则表达式起一个别名
有名分组就是将括号内正则表达式匹配到的内容位置参数传递给后面的视图函数。

from django.urls import path, re_path
from . import views

urlpatterns = [
    path('admin/', admin.site.urls),
    # 有名分组
    re_path(r"^textadd/(?P<year>\d+)/",views.textadd)
]

?P<text_id>：指定了参数的名称为 text_id。
\d+：匹配一个或多个数字字符。

def textadd(request,year):
    print(year)
    return HttpResponse('textadd')

【四】反向解析

【1】什么是反向解析

方向解析（Reverse Resolution）是指在 Django 中根据 URL 名称和参数生成对应的 URL 的过程。Django 提供了 {% url %} 模板标签和 reverse() 函数来进行方向解析。

就是通过一些方法得到一个结果该结果可以直接访问对应的url触发视图函数（views.py）
先给路由与试图函数起一个别名

# 反向解析
    re_path(r'^func66/',views.func, name ='123')

后端反向解析

from django.shortcuts import render,HttpResponse,redirect,reverse
def home(request):
    print(reverse('123'))
    return render(request,'home.html')

def func(request):
    return render(request,'login_success.html')

前端反向解析
```
<a href="{% url '123' %}">111</a>
```

【2】反向解析的本质

先给路由起一个别名，然后，通过一些方法去解析别名，可以得到这个别名对应的路由地址

先给路由与视图函数起一个别名

re_path(r'index/(\d+)/(\d+)/', views.func,name="index"),

【3】有名无名的反向解析

在urls.py文件中

# 无名分组
urlpatterns = [
re_path(r'^bai/(\d+)$', views.bai, name='111'),]
#  http://127.0.0.1:8686/bai/456   原则上在bai/叫上任何数字都可以

在views.py文件中

from django.urls import reverse
from django.shortcuts import render,HttpResponse

def bai(request, mao):
    url = reverse('111', args=(mao,))
    # 使用反向解析函数获取别名为'111'的URL，并提供参数
    print(url)
    return HttpResponse(f'URL: {url}')

urls.py

    # 有名分组反向解析
    re_path(r'^bai/(?P<mao>\d+)/', views.bai, name='456'),

views.py

def bai(request,mao):

    print(reverse("456", args=(mao,)))
    return HttpResponse(f'URL: {mao}')

【五】路由分发

Django每一个应用都可以拥有属于自己的
- templates文件夹
- urls.py
- static文件夹

个人理解：路由分发不应该是比如我在django框架下创建两个app应用文件夹跟一个django文件项目然后想在django文件项目上调用app软件应用上的url路由上的功能

语法：

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

示例：

假设 app1 的 URL 配置文件 urls.py 中包含了如下内容：

from django.urls import path
from . import views

urlpatterns = [
    path('app1/', views.app1_function),
    # 其他 app1 的路由配置...
]

而 app2 的 URL 配置文件 urls.py 中包含了如下内容：

from django.urls import path
from . import views

urlpatterns = [
    path('app2/', views.app2_function),
    # 其他 app2 的路由配置...
]

然后，在项目级别的 urls.py 中，你可以这样配置：

from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('myapp/', include('app1.urls')),  # 分发到 app1 应用
    path('myapp/', include('app2.urls')),  # 分发到 app2 应用
]

在这个配置中，当用户访问 http://yourdomain.com/myapp/app1/ 时，Django 就会调用 app1 应用中的对应视图函数；当用户访问 http://yourdomain.com/myapp/app2/ 时，Django 就会调用 app2 应用中的对应视图函数。

前期的准备工作：

在 settings.py 文件中的 INSTALLED_APPS

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'app1.apps.App1Config',  # 添加 app1 应用的配置
    'app2.apps.App2Config',  # 添加 app2 应用的配置
]

数据库配置：在 settings.py 文件中，找到 DATABASES 设置，根据你的数据库类型（如 SQLite、MySQL、PostgreSQL 等）填写相应的数据库连接信息。例如，如果你使用 SQLite 数据库，配置可能如下所示：

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': BASE_DIR / 'db.sqlite3',
    }
}

静态文件配置：在 settings.py 文件中，配置静态文件路径和 URL。确保 STATIC_URL 是你想要的访问静态文件的 URL，STATICFILES_DIRS 包含了你的静态文件目录。例如：

STATIC_URL = '/static/'
STATICFILES_DIRS = [
    BASE_DIR / "static",
]

模板配置：在 settings.py 文件中，找到 TEMPLATES 设置，在其中配置模板引擎和模板路径。确保 DIRS 包含了你的模板目录。例如：

TEMPLATES = [
    {
        'BACKEND': 'django.template.backends.django.DjangoTemplates',
        'DIRS': [BASE_DIR / 'templates'],
        ...
    },
]

国际化和时区配置：在 settings.py 文件中，配置 LANGUAGE_CODE 和 TIME_ZONE 来设置项目的语言和时区。例如：

LANGUAGE_CODE = 'en-us'
TIME_ZONE = 'UTC'

安全设置：配置安全设置，包括设置一个安全的 SECRET_KEY、允许的主机列表等。例如：

SECRET_KEY = 'your_secret_key'
ALLOWED_HOSTS = ['yourdomain.com']

日志配置：根据需要配置日志记录方式和级别。在 settings.py 文件中，可以使用 LOGGING 设置进行配置。例如：

LOGGING = {
    'version': 1,
    'disable_existing_loggers': False,
    'handlers': {
        'file': {
            'level': 'DEBUG',
            'class': 'logging.FileHandler',
            'filename': 'debug.log',
        },
    },
    'loggers': {
        'django': {
            'handlers': ['file'],
            'level': 'DEBUG',
            'propagate': True,
        },
    },
}

【1】前言

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

【2】为什么要使用路由分发（URL分发）

如果views和models文件是不是都放在每一个app应用里面了啊，而urls.py这个文件放在哪了，是不是放在项目文件夹里面了，说明什么，说明是不是所有的app都在使用它，如果你一个项目有10个应用，每个应用有100个url，那意味着你要在urls文件里面要写多少条url对应关系，并且所有的app的url都写在了这一个urls文件里面啊，这样好吗，当然也没有问题，但是耦合程度太高了，所以django在url这里给你提供了一个分发接口，叫做include。

分离请求和处理逻辑：通过路由分发，可以将请求和处理逻辑分离开来。
实现灵活的URL模式：路由分发可以根据URL配置定义灵活的URL模式，包括参数化的URL、正则表达式匹配等。
支持多种HTTP请求方法：路由分发可以根据不同的HTTP请求方法（例如GET、POST、PUT、DELETE）将请求路由到相应的处理函数。
实现功能扩展和插件化：通过添加新的URL配置和对应的处理函数，可以轻松地扩展和定制应用的功能。
支持多应用架构：路由分发可以支持多应用架构，即将不同的功能模块或应用拆分成多个子应用。

1.聊聊三次握手和四次挥手

三握

客户端向服务端告诉自己的需求
服务端知道了客户端的需求
然后它们两个建立起了联系

四挥手

客户端想断开连接找服务端
服务端接受它的请求并同意
然后服务端在去找客户端发起断开连接的请求
客户端接收到了信息并回复了消息

2.Python是值传递还是引用传递

Python的参数是可以共享的所有应该是值传递在对于不可变对象来说的话就是值传递

3.什么是粘包问题，如何解决

固定信息长度
设置边界值

#服务端
import socket

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(('localhost', 8888))
server.listen(5)

while True:
    conn, addr = server.accept()
    data_length = conn.recv(4)  # 读取长度字段
    length = int.from_bytes(data_length, byteorder='big')  # 将长度字段转换为整数
    data = conn.recv(length)  # 读取实际数据
    print(data.decode('utf-8'))

import socket

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(('127.0.0.1', 8888))

data = "asbdiuashdasjd"
data_length = len(data).to_bytes(4, byteorder='big')  # 将数据长度转换为4字节的bytes
client.send(data_length + data.encode('utf-8'))  # 发送长度字段和实际数据

4.写出你目前所学的Djangoorm操作语句

from myapp.models import MyModel

# 创建对象
obj = MyModel(name='example', value=123)


# 获取所有对象
all_objects = MyModel.objects.all()

# 获取对象
obj = MyModel.objects.get(id=1)
# 修改属性
obj.name = 'new name'

# 删除对象
obj.delete()

# 保存到数据库
obj.save()

【6】伪静态（了解）

静态网页
- 数据是写死的万年不变
伪静态
- 将一个动态网页伪装成静态网页
为什么要伪装呢？
- www.baidu.com
- 百度就是一个典型的静态网页
- 伪装的目的在于增大本网站的seo查询力度
- 并且增加搜索引擎收藏本网上的概率
搜索引擎的本质就是一个巨大的爬虫程序

小结：

无论你怎么优化怎么处理
都干不过rmb玩家

urlpatterns = [
    path('login.html/', views.login_view, name='login'),

    path('register/', views.register_view, name='register'),

]

【7】虚拟环境（了解）

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

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

扩展：

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

【八】Django版本的区别

【1】路由匹配规则

Django1.x路由层使用的是url方法
在Django2.x版本以后在路由层使用的是path方法
- url() 第一个参数支持正则
- path() 第一个参数不支持正则，写什么就匹配到什么

【2】正则匹配规则

Django 1.x 示例：
- 在 Django 1.x 中，通常使用
```
url()
```
  函数结合正则表达式来定义 URL 规则，例如：
```
from django.conf.urls import url
from . import views

urlpatterns = [
    url(r'^text/(?P<year>[0-9]{4})/$', views.year_archive),
]
```
- 上述示例中，使用正则表达式 r'^articles/(?P<year>[0-9]{4})/$' 匹配类似 /articles/2024/ 这样的 URL 地址。
Django 2.0 示例：
- 在 Django 2.0 中引入了
```
path()
```
  函数，可以更简洁地定义 URL 规则，例如：
```
from django.urls import path
from . import views

urlpatterns = [
    path('text/<int:year>/', views.year_archive),
]
```
- 使用 path() 函数可以直观地将 URL 地址与视图函数关联起来，不再需要显式地使用正则表达式。
Django 3.1+ 示例：
- 在 Django 3.1+ 中，推荐使用
```
re_path()
```
  函数来支持正则表达式的 URL 匹配规则，例如：
```
from django.urls import re_path
from . import views

urlpatterns = [
    re_path(r'^text/(?P<year>[0-9]{4})/$', views.year_archive),
]
```
- 使用 re_path() 函数可以灵活地使用正则表达式来定义复杂的 URL 匹配规则，同时保持简洁性和可读性。
- 一般来说path就够用了

【3】路由转换器

在 Django 2.0 及之后的版本中，引入了一些方便的路径转换器
虽然path不支持正则，但是其内部支持五种转换器

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

一个简单的示例

# urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('test/<str:dep>/', views.test),
]

# views.py
def text(request, dep):
    dep_value = request.GET.get(dep)
    print(dep_value)
    return HttpResponse('you habby！')

在 Django 2.x 和 Django 3.x 中，路径转换器的基本功能是相似的，都是用于捕获 URL 中特定部分并将其作为参数传递给视图函数。然而，在 Django 3.x 中引入了一些新的路径转换器，同时对一些已有的转换器进行了改进和优化。

区别

新增路径转换器：
- Django 3.x 引入了一些新增的路径转换器，如 <uuid:parameter> 用于捕获 UUID 类型的参数，以及 <path:parameter> 用于捕获包含斜杠的字符串参数。
改进的路径转换器：
- 在 Django 3.x 中，一些已有的路径转换器经过了改进和优化，使其更加灵活和功能更强大。例如对于 <int:parameter> 转换器，Django 3.x 提供了更多的参数校验和类型转换功能。
性能优化：
- Django 3.x 对路径转换器的实现进行了一些性能优化，使得路径匹配和参数提取过程更加高效，提升了整体的性能表现。
兼容性：
- 大多数情况下，Django 3.x 的路径转换器是向后兼容的，即可以在 Django 2.x 中使用 Django 3.x 的路径转换器，但需要确保 Django 版本符合最低要求。

转换器

int：捕获正整数，例如 <int:my_var>。
str：捕获任何没有斜杠的字符串，例如 <str:slug>。
uuid：捕获UUID，例如 <uuid:my_uuid>。
path：捕获包含斜杠的字符串，例如 <path:my_path>。
slug：捕获由字母、数字、下划线或连字符组成的字符串，例如 <slug:my_slug>。
date：捕获日期（年、月、日），例如 <date:my_date>。
datetime：捕获日期时间，例如 <datetime:my_datetime>。
float：捕获浮点数，例如 <float:my_float>。
str列表：捕获一个或多个字符串，例如 <str:categories>。
int列表：捕获一个或多个整数，例如 <int:id_list>。

# urls.py
from django.urls import path
from . import views

urlpatterns = [
    path('post/<int:post_id>/', views.postext, name='postext'),
    # http://127.0.0.1:8686/post/123/
]

# views.py
from django.shortcuts import render
from django.http import HttpResponse

def postext(request, post_id):
    return HttpResponse(f'Post ID: {post_id}')

【九】名称空间

在Django框架中，命名空间（Namespace）是用于区分不同应用的URL模式的一种机制。它允许在一个项目中拥有多个应用，并确保它们的URL模式不会发生冲突。

【1】使用命名空间的好处：

避免不同应用之间的URL模式冲突，确保URL的唯一性。
提供更好的URL管理和维护，使代码更具可读性。
在生成URL链接时，可以更方便地使用命名空间和URL名称，而不需要硬编码URL路径。

命名空间通过在应用的URL配置文件中设置app_name属性来定义。

app_name 这个一般在子路由的urls.py文件里面定义的

app_name = 'myapp'  # myapp  这个是我们定义的命名空间的名字

示例：

1.在主项目的URL配置文件中，使用include()函数引入应用的URL配置时，可以通过namespace参数将应用的命名空间传递给include()函数。例如：

from django.contrib import admin
from django.urls import path,re_path,include
from apply01 import views
# include

urlpatterns = [
    path('admin/', admin.site.urls),
    re_path(r'^home/',views.home),
    re_path(r'^login/',views.login,name = 'login'),
    re_path(r'^register/',views.register),

    path('myapp/',include('apply01.urls',namespace='myapp')),
# namespace = 'myapp'  

]

2.在应用程序的URL配置文件（自己创建通常是应用目录下的urls.py）中，定义应用的URL模式，并为每个URL模式指定一个名称。

from django.urls import path
from . import views

app_name = 'myapp'  # 设置应用的命名空间

urlpatterns = [
    path('index/', views.index, name='index'),  # 设置URL模式和名称
    path('mei/', views.detail, name='mei'),  # 设置URL模式和名称
    # 其他URL模式...
]

3.再到应用程序的views.py文件中定义自己的index跟mei 函数。这里要导入HttpResponse模块


from django.shortcuts import render, HttpResponse, redirect,reverse
from django.http import HttpResponse

def index(request):
    return HttpResponse('当前的命名空间是%s'% request.resolver_match.namespace)

def mei(request):
    if request.resolver_match.namespace == 'author':
        return HttpResponse('这里是作者的页面')
    elif request.resolver_match.namespace == 'publisher':
        return HttpResponse('这里是出版商的页面')
    else:
        return HttpResponse('去liujiangblog.com学习Django吧')

【2】注意事项：

在前端开发中，命名空间的概念通常不是直接应用于前端代码本身，而是在后端框架（如Django）中使用。前端代码通常通过后端框架生成的URL链接来引用后端提供的功能和数据。

在使用Django框架的前端开发中，可以通过模板语言（如Django模板语言）来生成后端的URL链接，并将其用于前端代码中。下面是一个示例：

<!-- 前端模板代码 -->
<a href="{% url 'myapp:index' %}">Go to My App</a>

在上述示例中，{% url 'myapp:index' %}使用Django模板语言的url标签来生成名为myapp:index的URL链接。这里的myapp是应用的命名空间，index是URL名称。通过使用命名空间和URL名称，我们可以生成与后端相关的URL链接，并将其用于前端代码中，例如超链接的href属性。

总结来说，在前端开发中，命名空间的使用是通过后端框架定义和生成的URL链接来实现的，前端代码只需正确引用这些链接，而不需要直接使用命名空间。

###############其实只要名字不冲突就不需要使用到名称空间
django.http import HttpResponse

def index(request):
return HttpResponse(‘当前的命名空间是%s’% request.resolver_match.namespace)

def mei(request):
if request.resolver_match.namespace == ‘author’:
return HttpResponse(‘这里是作者的页面’)
elif request.resolver_match.namespace == ‘publisher’:
return HttpResponse(‘这里是出版商的页面’)
else:
return HttpResponse(‘去liujiangblog.com学习Django吧’)


## 【2】注意事项：

		在前端开发中，命名空间的概念通常不是直接应用于前端代码本身，而是在后端框架（如Django）中使用。前端代码通常通过后端框架生成的URL链接来引用后端提供的功能和数据。

在使用Django框架的前端开发中，可以通过模板语言（如Django模板语言）来生成后端的URL链接，并将其用于前端代码中。下面是一个示例：

```html
<!-- 前端模板代码 -->
<a href="{% url 'myapp:index' %}">Go to My App</a>

###############其实只要名字不冲突就不需要使用到名称空间