Django — 请求和响应

一、请求

1、概念

请求（Request）就是浏览器（客户端）通过 HTTP 协议或者 HTTPS 协议向服务器发送请求获取数据。

2、请求参数方式分类

• URL 路径参数
• 查询字符串参数
• 请求体参数
  • form 表单传参
  • json 格式参数
  • 上传文件

3、案例

3.1、URL 路径参数

re_path：路径是动态的，一般使用 re_path，写法：(?P<变量>正则表达式)

<> 表示接收的数据，^ 表示路由开始，$ 表示路由结尾

# Project 项目中的 urls.py
from django.contrib import admin  # 导入 Django 的管理员模块，用于管理网站后台
from django.urls import path,include  # 导入 Django 的 path 函数，用于配置 URL 路由

# URL 配置列表，定义了网站的所有 URL 路径和对应的处理程序
urlpatterns = [
    # 配置 URL 路由
    path('', include('users.urls'))
]
1
2
3
4
5
6
7
8
9

# 子应用的 urls.py
from django.urls import path,re_path # 导入 Django 的 path 函数，用于配置 URL 路由，导入 re_path，用于正则匹配
from .import views # 导入当前目录下的 views.py 文件中的模块或视图函数

# URL 配置列表，定义 URL 路径和对应的处理程序
urlpatterns = [
    # 配置 URL 路由，调用 views.py 中的 weacher 视图函数
    re_path(r'^weather/(?P[a-z]+)/(?P\d{8})/$',views.weather)
]
1
2
3
4
5
6
7
8
9

# 子应用的 views.py
from django.http import HttpResponse  # 导入 Django 的 HttpResponse 类，用于创建 HTTP 响应对象

# Create your views here.

# 定义视图函数
def weather(request,city,year):
    """
    天气
    :param request:
    :param city:城市
    :param year:日期
    :return:
    """
    print(city)
    print(year)
    return HttpResponse('获取天气成功')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在 manage.py 文件下运行代码，访问网址 http://127.0.0.1:8000/weather/shanghai/20230101/ 显示以下页面

3.2、查询字符串参数

不是路由匹配的东西，可以使用 request 模块获取数据

在地址栏输入 http://127.0.0.1:8000/qs/?a=111&b=222&a=333

# Project 项目中的 urls.py
from django.urls import path,include  # 导入 Django 的 path 函数，用于配置 URL 路由，include 函数，用于将其它 URL 模式包含在当前 URL 配置中

# URL 配置列表，定义了网站的所有 URL 路径和对应的处理程序
urlpatterns = [
    # 配置 URL 路由
    path('', include('users.urls'))
]
1
2
3
4
5
6
7
8

# 子应用的 urls.py
from django.urls import path,re_path  # 导入 Django 的 path 函数，用于配置 URL 路由，导入 re_path，用于正则匹配
from .import views  # 导入当前目录下的 views.py 文件中的模块或视图函数

# URL 配置列表，定义 URL 路径和对应的处理程序
urlpatterns = [
    # 配置 URL 路由，调用 views.py 中的 querys 视图函数
    path('qs/',views.querys)
]
1
2
3
4
5
6
7
8
9

# 子应用的 views.py
from django.http import HttpResponse  # 导入 Django 的 HttpResponse 类，用于创建 HTTP 响应对象

# Create your views here.

# 定义视图函数
def querys(request):
    # 获取数据，查询字符串是不区分请求方式的
    a = request.GET.get("a")
    b = request.GET.get("b")
    print(a) # 333
    print(type(a)) # 
    print(b) # 222
    # 获取多个查询字符串
    a_new = request.GET.getlist('a')
    print(a_new) # ['111', '333']
    print(type(a_new)) # 
    return HttpResponse('XXX')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

3.3、form 表单传参

# Project 项目中的 urls.py
from django.urls import path,include  # 导入 Django 的 path 函数，用于配置 URL 路由，include 函数，用于将其它 URL 模式包含在当前 URL 配置中

# URL 配置列表，定义了网站的所有 URL 路径和对应的处理程序
urlpatterns = [
    # 配置 URL 路由
    path('', include('users.urls'))
]
1
2
3
4
5
6
7
8

# users 子应用的 urls.py
from django.urls import path  # 导入 Django 的 path 函数，用于配置 URL 路由
from .import views # 导入当前目录下的 views.py 文件中的模块或视图函数

# URL 配置列表，定义 URL 路径和对应的处理程序
urlpatterns = [
    # 配置 URL 路由，调用 views.py 中的 ge_form 视图函数
    path('ge_form/',views.ge_form)
]
1
2
3
4
5
6
7
8
9

# 子应用的 views.py
from django.shortcuts import render  # 导入 Django 的 render 函数，用于渲染模板并返回响应
from django.http import HttpResponse  # 导入 Django 的 HttpResponse 类，用于创建 HTTP 响应对象

# Create your views here.

# 定义视图函数
def ge_form(request):
    """
    获取表单参数
    :param request:
    :return:
    """
    print(request) # 
    return HttpResponse("XXX123")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Apifox 接口管理工具下载

状态码显示 403，将下面这个认证注释掉，需要认证的可以自己写一个认证。

# setting.py
# 中间件
MIDDLEWARE = [
    # Django 自带的 CSRF 保护中间件
    # 'django.middleware.csrf.CsrfViewMiddleware',
]
1
2
3
4
5
6

打断点，改为调试模式后，再次点击发送，可以看到传递的数据。

打印数据。

# 子应用的 views.py
from django.shortcuts import render  # 导入 Django 的 render 函数，用于渲染模板并返回响应
from django.http import HttpResponse  # 导入 Django 的 HttpResponse 类，用于创建 HTTP 响应对象

# Create your views here.

# 定义视图函数
def ge_form(request):
    """
    获取表单参数
    :param request:
    :return:
    """
    print(request) # 
    # 获取数据
    username = request.POST.get('username')
    pwd = request.POST.get('pwd')
    print(username) # abc
    print(pwd) # 123456
    return HttpResponse("XXX123")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

3.4、Json 格式参数

# Project 项目中的 urls.py
from django.urls import path,include  # 导入 Django 的 path 函数，用于配置 URL 路由，include 函数，用于将其它 URL 模式包含在当前 URL 配置中

# URL 配置列表，定义了网站的所有 URL 路径和对应的处理程序
urlpatterns = [
    # 配置 URL 路由
    path('', include('users.urls'))
]
1
2
3
4
5
6
7
8

# users 子应用的 urls.py
from django.urls import path  # 导入 Django 的 path 函数，用于配置 URL 路由
from .import views  # 导入当前目录下的 views.py 文件中的模块或视图函数

# URL 配置列表，定义 URL 路径和对应的处理程序
urlpatterns = [
    # 配置 URL 路由，调用 views.py 中的 get_json 视图函数
    path('get_json/',views.get_json)
]
1
2
3
4
5
6
7
8
9

# 子应用的 views.py
from django.shortcuts import render  # 导入 Django 的 render 函数，用于渲染模板并返回响应
from django.http import HttpResponse  # 导入 Django 的 HttpResponse 类，用于创建 HTTP 响应对象

# Create your views here.

# 定义视图函数
def get_json(request):
    '''
    获取json请求数据
    :param request:
    :return:
    '''
    print(request) # 
    return HttpResponse('JSON')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

打断点，改为调试模式后，再次点击发送，可以看到传递的数据。

打印数据。

# 子应用的 views.py
from django.shortcuts import render  # 导入 Django 的 render 函数，用于渲染模板并返回响应
from django.http import HttpResponse  # 导入 Django 的 HttpResponse 类，用于创建 HTTP 响应对象
import json

# Create your views here.

# 定义视图函数
def get_json(request):
    '''
    获取json请求数据
    :param request:
    :return:
    '''
    print(request) # 
    # 获取数据
    json_bytes = request.body
    print(json_bytes) # b'{\r\n    "username":"abc",\r\n    "age":18\r\n}'
    # 解码
    json_str = json_bytes.decode()
    print(json_str)
    # {
    #     "username": "abc",
    #     "age": 18
    # }
    print(type(json_str)) # 
    # 字符串转字典
    json_dict = json.loads(json_str)
    print(json_dict) # {'username': 'abc', 'age': 18}
    print(type(json_dict)) # 
    username = json_dict.get('username')
    print(username) # abc
    age = json_dict.get('age')
    print(age)  # 18
    return HttpResponse('JSON')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

3.5、上传文件

上传单张图片并保存

# Project 项目中的 urls.py
from django.urls import path,include  # 导入 Django 的 path 函数，用于配置 URL 路由，include 函数，用于将其它 URL 模式包含在当前 URL 配置中

# URL 配置列表，定义了网站的所有 URL 路径和对应的处理程序
urlpatterns = [
    # 配置 URL 路由
    path('', include('users.urls'))
]
1
2
3
4
5
6
7
8

# users 子应用的 urls.py
from django.urls import path  # 导入 Django 的 path 函数，用于配置 URL 路由
from .import views  # 导入当前目录下的 views.py 文件中的模块或视图函数

# URL 配置列表，定义 URL 路径和对应的处理程序
urlpatterns = [
    # 配置 URL 路由，调用 views.py 中的 get_file 视图函数
    path('get_file/',views.get_file)
]
1
2
3
4
5
6
7
8
9

# 子应用的 views.py
from django.shortcuts import render  # 导入 Django 的 render 函数，用于渲染模板并返回响应
from django.http import HttpResponse  # 导入 Django 的 HttpResponse 类，用于创建 HTTP 响应对象

# Create your views here.

# 定义视图函数
def get_file(request):
    '''
    上传单个文件
    :param request:
    :return:
    '''
    print(request)
    return HttpResponse('xxxx')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

打断点，改为调试模式后，再次点击发送，可以看到传递的数据。

改为 POST 请求。

保存上传文件。

在 setting.py 文件中新增以下代码，并且在根目录下新建文件夹 media。

# setting.py
# 指定上传文件的存储路径
MEDIA_ROOT = BASE_DIR / 'media'
1
2
3

# 子应用的 views.py
from django.shortcuts import render  # 导入 Django 的 render 函数，用于渲染模板并返回响应
from django.http import HttpResponse  # 导入 Django 的 HttpResponse 类，用于创建 HTTP 响应对象
from Project import settings

# Create your views here.

# 定义视图函数
def get_file(request):
    '''
    上传单个文件
    :param request:
    :return:
    '''
    print(request)
    # 从请求中获取上传的文件，'picture' 是文件字段的名称
    file = request.FILES['picture']
    # 打印上传的文件对象
    print(file)
    # 构建保存文件的完整路径，使用 settings.MEDIA_ROOT 作为根目录
    # file.name 是上传文件的原始文件名
    image = '%s/%s' % (settings.MEDIA_ROOT, file.name)
    # 打印保存文件的完整路径
    print(image)
    # 打开文件并将上传的文件数据写入磁盘
    with open(image, 'wb') as f:
        for files in file.chunks():
            f.write(files)
    return HttpResponse('上传成功')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

导入 from Project import settings 的快捷方式。

上传多张图片并保存

方式一：

# users 子应用的 urls.py
from django.urls import path  # 导入 Django 的 path 函数，用于配置 URL 路由
from .import views  # 导入当前目录下的 views.py 文件中的模块或视图函数

# URL 配置列表，定义 URL 路径和对应的处理程序
urlpatterns = [
    # 配置 URL 路由，调用 views.py 中的 get_files 视图函数
    path('get_files/',views.get_files)
]
1
2
3
4
5
6
7
8
9

# 子应用的 views.py
from django.shortcuts import render  # 导入 Django 的 render 函数，用于渲染模板并返回响应
from django.http import HttpResponse  # 导入 Django 的 HttpResponse 类，用于创建 HTTP 响应对象
from Project import settings

# Create your views here.

# 定义视图函数
def get_files(request):
    '''
    上传多个文件
    :param request:
    :return:
    '''
    print(request)
    # 获取请求中上传的多个文件，request.FILES 是一个字典，其中键是文件字段的名称
    pictures = request.FILES
    # 遍历上传的每个文件
    for i in pictures:
        # 获取当前文件对象
        file = pictures[i]
        # 构建保存文件的完整路径，使用 settings.MEDIA_ROOT 作为根目录
        # file.name 是上传文件的原始文件名
        image = '%s/%s' % (settings.MEDIA_ROOT, file.name)
        # 打印保存文件的完整路径
        print(image)
        # 打开文件并将上传的文件数据写入磁盘
        with open(image, 'wb') as f:
            for files in file.chunks():
                f.write(files)
    return HttpResponse('上传成功')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

方式二：

# users 子应用的 urls.py
from django.urls import path  # 导入 Django 的 path 函数，用于配置 URL 路由
from .import views  # 导入当前目录下的 views.py 文件中的模块或视图函数

# URL 配置列表，定义 URL 路径和对应的处理程序
urlpatterns = [
    # 配置 URL 路由，调用 views.py 中的 get_files 视图函数
    path('get_pictures/',views.get_pictures)
]
1
2
3
4
5
6
7
8
9

# 定义视图函数
def get_pictures(request):
    '''
    上传多个文件
    :param request:
    :return:
    '''
    print(request)
    # 使用 request.FILES.getlist('picture') 获取多个上传的文件对象
    # 'picture' 是表单中文件字段的名称
    pictures = request.FILES.getlist('picture')
    # 遍历上传的每个文件
    for file in pictures:
        # 构建保存文件的完整路径，使用 settings.MEDIA_ROOT 作为根目录
        # file 是文件对象，而不是文件名
        image = '%s/%s' % (settings.MEDIA_ROOT, file)
        # 打印保存文件的完整路径
        print(image)
        # 打开目标文件并将上传的文件数据写入磁盘
        with open(image, 'wb') as f:
            for files in file.chunks():
                f.write(files)
    return HttpResponse('上传成功')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

二、响应

响应（Response）是用于向客户端（通常是 Web 浏览器）发送数据的方式。

1、HttpResponse

• HttpResponse 是 Django 中最常用的响应类型之一，它用于发送 HTML 内容或文本数据作为 HTTP 响应。
• HttpResponse 的构造函数接受一个字符串参数，该字符串包含要发送的内容。
• HttpResponse 可以设置 HTTP 响应的状态码、响应头、Cookie 等。

# users 子应用的 urls.py
from django.urls import path  # 导入 Django 的 path 函数，用于配置 URL 路由
from .import views  # 导入当前目录下的 views.py 文件中的模块或视图函数

# URL 配置列表，定义 URL 路径和对应的处理程序
urlpatterns = [
    # 配置 URL 路由，调用 views.py 中的 my_view 视图函数
    path('my_view/',views.my_view)
]
1
2
3
4
5
6
7
8
9

# 子应用的 views.py
from django.http import HttpResponse  # 导入 Django 的 HttpResponse 类，用于创建 HTTP 响应对象

# Create your views here.

# 定义视图函数
def my_view(request):
    """
    HttpResponse 响应
    :param request:
    :return:
    """
    # 创建一个字符串变量 content，内容为 "Hello, world!"
    content = "Hello, world!"

    # 创建一个 HTTP 响应对象 HttpResponse，将 content 作为响应内容
    # content_type 参数指定了响应的内容类型为 "text/plain"
    response = HttpResponse(content, content_type="text/plain")
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

2、JsonResponse

• JsonResponse 是用于发送 JSON 格式数据的特殊响应类型。它常用于向客户端提供数据，特别是在前后端分离的应用中，前端通常通过 AJAX 请求获取 JSON 数据。

• JsonResponse 的构造函数接受一个 Python 字典作为参数，它会自动将字典转换为 JSON 格式并发送给客户端。

• JsonResponse 支持设置 HTTP 状态码、响应头、JSON 编码选项等。

传字典

# users 子应用的 urls.py
from django.urls import path  # 导入 Django 的 path 函数，用于配置 URL 路由
from .import views  # 导入当前目录下的 views.py 文件中的模块或视图函数

# URL 配置列表，定义 URL 路径和对应的处理程序
urlpatterns = [
    # 配置 URL 路由，调用 views.py 中的 demo_view 视图函数
    path('demo_view/',views.demo_view)
]
1
2
3
4
5
6
7
8
9

# 子应用的 views.py
from django.http import JsonResponse  # 导入 Django 的 JsonResponse 类，用于创建 HTTP 响应对象

# Create your views here.

# 定义视图函数
def demo_view(request):
    """
    JsonResponse 响应
    :param request:
    :return:
    """
    # 创建一个字典变量 dit，包含两个键值对，分别是 'name' 和 'age'
    dit = {
        'name': 'abc',
        'age': 18
    }

    # 使用 JsonResponse 函数创建一个 JSON 格式的 HTTP 响应对象，并将 dit 字典作为数据传递给它
    return JsonResponse(dit)  # 写成 data=dit 也可以
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

传列表

传的值不是字典类型要加 safe=False

# users 子应用的 urls.py
from django.urls import path  # 导入 Django 的 path 函数，用于配置 URL 路由
from .import views  # 导入当前目录下的 views.py 文件中的模块或视图函数

# URL 配置列表，定义 URL 路径和对应的处理程序
urlpatterns = [
    # 配置 URL 路由，调用 views.py 中的 demo_view 视图函数
    path('demo_view2/',views.demo_view2)
]
1
2
3
4
5
6
7
8
9

# 子应用的 views.py
from django.http import JsonResponse  # 导入 Django 的 JsonResponse 类，用于创建 HTTP 响应对象

# Create your views here.

# 定义视图函数
def demo_view2(request):
    """
    JsonResponse 响应
    :param request:
    :return:
    """
    # 创建一个空列表 lst，用于存储字典数据
    lst = []
    # 创建一个字典变量 dit，包含两个键值对，分别是 'name' 和 'age'
    dit = {
        'name': 'abc',
        'age': 18
    }
    # 将 dit 字典添加到列表 lst 中
    lst.append(dit)
    # 使用 JsonResponse 函数创建一个 JSON 格式的 HTTP 响应对象，
    # 将 lst 列表作为数据传递给它，并设置 safe 参数为 False
    return JsonResponse(lst, safe=False)  # 写成 data=lst 也可以
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

三、GET 和 POST 区别

1、相同点

都是请求方式

都是使用 HTTP 协议，底层用的 TCP 传输

2、不同点

GET

把参数包含到 url 中，不适合传输敏感信息，不安全

通常在2048个字符以内，适合传输较少的数据

产生一个 TCP 包

POST

一般都是通过 request.body 里面传递的参数，不可见于 URL，更适合传输敏感信息，安全

没有严格的长度限制，适合传输大量数据

产生两个 TCP 包

记录学习过程，欢迎讨论交流，尊重原创，转载请注明出处~