Django框架——基础之视图系统（View.py）

最新推荐文章于 2024-04-22 16:07:30 发布

weixin_30363509

最新推荐文章于 2024-04-22 16:07:30 发布

阅读量749

点赞数 1

文章标签： python json 前端 ViewUI

原文链接：http://www.cnblogs.com/mashangsir/p/11468420.html

版权

Django框架之View.py（视图文件）

1. 视图简介

视图层是Django处理请求的核心代码层，我们大多数Python代码都集中在这一层面。

它对外接收用户请求，对内调度模型层和模版层，统合数据库和前端，最后根据业务逻辑，将处理好的数据，与前端结合，返回给用户。视图层是真正的后端，是Python工程师的‘主营业务’。

视图就是每个创建的APP中的的view.py文件夹。我们处理数据的那些业务逻辑，就都存放（编辑）在这里。

Django的视图层包含下面一些主要内容：

URL路由
视图函数
快捷方式
装饰器
请求与响应
类视图
文件上传
CSV/PDF生成
内置中间件

注意：视图层应该包含视图文件（view.py）和路由文件（urls.py）两个系统组成。

一个最新建的Django APP ，新建的APP名称为（app001）如下：

1.1 一个简单的视图

下面是一个以HTML文档的形式返回当前日期和时间的视图：

from django.http import HttpResponse
from django.shortcuts import HttpResponse

import datetime

def current_datetime(request):
    now = datetime.datetime.now()
    html = "<html><body>It is now %s.</body></html>" % now
    return HttpResponse(html)

让我们来逐行解释下上面的代码：

首先，我们从 django.http（或者django.shorcuts）模块导入了HttpResponse类，以及Python的datetime库。

索引上面的两个from引入语句的功能是一样的，只需要其中一条就可以了！！！！！

接着，我们定义了current_datetime函数。它就是视图函数。
每个视图函数都使用接收到的HttpRequest对象作为第一个参数，并且通常称之为request。
注意，视图函数的名称并不重要；不需要用一个统一的命名方式来命名，以便让Django识别它。我们将其命名为current_datetime，是因为这个名称能够比较准确地反映出它实现的功能（唯一性）。
这个视图会返回一个HttpResponse对象，其中包含生成的响应（HTML页面或者一个字符串）。
每个视图函数都负责返回一个对象，可以是HttpResponse对象，也可以render对象，还可以是redirect对象。

　　　　所以，我们可以将上面的from引入语句修改得全一点，如下：　　　

from django.shortcuts import render, HttpResponse, redirect

　　　　在平时的开发中，我们也会称 render, HttpResponse, redirect 这三个为 “ 基础必配三件套 ” 。

　　　　注意，HttpResponse是一个类，而render和redirect是Django的内置函数！

Django使用请求和响应对象来通过系统传递状态。

当浏览器向服务端请求一个页面时，Django创建一个HttpRequest对象，该对象包含关于请求的元数据。然后，Django加载相应的视图，将这个HttpRequest对象作为第一个参数传递给视图函数。

每个视图负责返回一个HttpResponse对象给浏览器。

2. 视图函数的前奏（FBV和CBV）

什么是FBV? 在视图文件里面编辑的时候，基于函数的形式来编辑业务逻辑的视图view，就叫做FBV （function base view）。

什么是CBV? 而在编辑业务逻辑的时候，基于类的形式来编辑业务逻辑的则是叫做CBV（class base view）。

下面用一个简单的例子来说明：

使用FBV写：

from django.shortcuts import render, HttpResponse, redirect

def back_hello(request):
    return HttpResponse('大家好！')

使用CBV写：

from django.views import View    # 基于类的形式来写试图上的业务逻辑的时候，定义的类需要  继承 django 中的View类  ！！！！！！！
class BackHello(View):
    def get(self, request):
        return HttpResponse("get请求的时候！get大家好！")

    def post(self, request):
        return HttpResponse("post请求的时候！post大家好！")

注意：使用CBV形式的时候，urls.py上的路径与函数的对应关系，是与FBV不一样的，需要修改，如下：

urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^test/', views.BackHello.as_view()),
]

# 可以看出，test/位置中的路径写法与FBV一样，时候后面的引入格式变成了：
# views.类名.as_view()。而CBV情况下是写为: views.函数名
# 注意：as_view()，这个是固定的！！！！

3. Django视图函数

视图函数，简称视图，本质上就是一个Python函数，只是他在django的框架下能做一些特殊的相应，比如它可以接受Web请求做出一些逻辑运算，并且返回Web响应。

响应的内容可以是HTML网页、重定向、404错误，XML文档或图像等任何东西。但是，无论视图本身是个什么处理逻辑，必须都要有一个返回某种响应。

通常我们约定将视图放置在项目或应用程序目录中的名为views.py的文件中，而视图函数也是放在视图文件当中，这也是一种模块化思维，把各种功能规划好，方便未来的管理。

4. Django内置快捷方法（函数）

Django在django.shortcuts模块中，为我们提供了很多快捷方便的内置函数，其中有些使用的频率很高！

4.1 render()

Django关于render的源码如下：

结合一个给定的模板和一个给定的上下文字典，并返回一个渲染后的 HttpResponse 对象。

参数：
　　必备（常用）参数：
     request： 用于生成响应的请求对象。

     template_name：要使用的模板的完整名称，可选的参数

     context：添加到模板上下文的一个字典。默认是一个空字典。如果字典中的某个值是可调用的，视图将在渲染模板之前调用它。
　
　　可以选参数：
     content_type：生成的文档要使用的MIME类型。默认为 DEFAULT_CONTENT_TYPE 设置的值。默认为'text/html'

     status：响应的状态码。默认为200。

　　　useing: 用于加载模板的模板引擎的名称。

一个简单的例子：

from django.shortcuts import render

def my_view(request):
    # 视图的代码写在这里
    return render(request, 'myapp/index.html', {'foo': 'bar'})

上面的代码等于：

from django.http import HttpResponse
from django.template import loader

def my_view(request):
    # 视图代码写在这里
    t = loader.get_template('myapp/index.html')
    c = {'foo': 'bar'}
    return HttpResponse(t.render(c, request))

4.2 redirect()

参数：参数范围相对render来说比较广

一个模型：将调用模型的get_absolute_url() 函数
一个视图，可以带有参数：将使用urlresolvers.reverse 来反向解析名称
一个绝对的或相对的URL，将原封不动的作为重定向的位置。

默认返回一个临时的重定向；传递一个参数名为 permanent=True 就可以返回一个永久的重定向。

redirect使用的两个场景：其中，第一个场景使用的比较多！！！！

1. 传递视图名，使用reverse()方法反向解析url：

 
   from django.shortcuts import redirect
def my_view(request):
    ...
    return redirect('some-view-name', foo='bar') 
  

　　1.1 重定向到硬编码的URL：

 
   def my_view(request):
    ...
    return redirect('/some/url/') 
  

　　1.2 重定向到一个完整的URL：

def my_view(request):
    ...
    return redirect('https://example.com/')

2. 调用对象的get_absolute_url()方法来重定向URL：

def my_view(request):
    ...
    object = MyModel.objects.get(...)
    return redirect(object)

所有上述形式都接受permanent参数；如果设置为True，将返回永久重定向：

 
     def my_view(request):
    ...
    object = MyModel.objects.get(...)
    return redirect(object, permanent=True) 
    
5. 什么是临时重定向？永久重定向？

临时重定向的响应状态码：302

永久重定向的响应状态码：301

这两个的状态码对于普通的用户来说是没有任何区别，因为他们主要针对的是搜索引擎机器人。

这就涉及到了，另外一个领域了，这就是SEO工作人员的必配只是！

A页面临时重定向到B页面，那搜索引擎收录的就是A页面。

A页面永久重定向到B页面，那搜索引擎收录的就是B页面。

6. Django两个重要对象

6.1 request对象

每当一个用户请求发送过来，Django将HTTP数据包中的相关内容，打包成为一个HttpRequest对象，并传递给每个视图函数作为第一位置参数，也就是request，供我们调用。

说明为什么别的教程会叫HttpRequst对象？：这里说是request对象是不太严谨的，因为我们指的request只是每一个视图函数中，固定的第一位置的一个参数名称。至于为什么我们要取名为request，只是一个大家约定熟成而已，再者就是名称比HttpRequest短，大家更加好记 ~_~ 。所以，真正的应该是对象应该是，HttpRequest类生产的一个对象，所以在别的地方，也会成为HttpRequest对象。

6.1.1 请求相关的常用值

　　其实也是属于request的属性，只是平时使用频率很高，所以把它放大到前面一些，方便大家学习。

path_info 返回用户访问url，不包括域名

method 请求中使用的HTTP方法的字符串表示，全大写表示。

GET 包含所有HTTP GET参数的类字典对象

POST 包含所有HTTP POST参数的类字典对象

body 请求体，byte类型 request.POST的数据就是从body里面提取到的

6.1.2 request对象的属性：

　　下面的把request说成HttpRequest，这两个是没有区别的哦！！！！！上面也做了解释了

属性：
　　django将请求报文中的请求行、头部信息、内容主体封装成 HttpRequest 类中的属性。
   除了特殊说明的之外，其他均为只读的。


0.HttpRequest.scheme
   表示请求方案的字符串（通常为http或https）

1.HttpRequest.body

　　一个字符串，代表请求报文的主体。在处理非 HTTP 形式的报文时非常有用，例如：二进制图片、XML,Json等。

　　但是，如果要处理表单数据的时候，推荐还是使用 HttpRequest.POST 。

　　另外，我们还可以用 python 的类文件方法去操作它，详情参考 HttpRequest.read() 。

2.HttpRequest.path

　　一个字符串，表示请求的路径组件（不含域名）。

　　例如："/music/bands/the_beatles/"

3.HttpRequest.method

　　一个字符串，表示请求使用的HTTP 方法。必须使用大写。

　　例如："GET"、"POST"

4.HttpRequest.encoding

　　一个字符串，表示提交的数据的编码方式（如果为 None 则表示使用 DEFAULT_CHARSET 的设置，默认为 'utf-8'）。
   这个属性是可写的，你可以修改它来修改访问表单数据使用的编码。
   接下来对属性的任何访问（例如从 GET 或 POST 中读取数据）将使用新的 encoding 值。
   如果你知道表单数据的编码不是 DEFAULT_CHARSET ，则使用它。

5.HttpRequest.GET 

　　一个类似于字典的对象，包含 HTTP GET 的所有参数。详情请参考 QueryDict 对象。点我知道 >>> 什么是QueryDict对象？
6.HttpRequest.POST

　　一个类似于字典的对象，如果请求中包含表单数据，则将这些数据封装成 QueryDict 对象。

　　POST 请求可以带有空的 POST 字典 —— 如果通过 HTTP POST 方法发送一个表单，但是表单中没有任何的数据，QueryDict 对象依然会被创建。
   因此，不应该使用 if request.POST  来检查使用的是否是POST 方法；应该使用 if request.method == "POST" 

　　另外：如果使用 POST 上传文件的话，文件信息将包含在 FILES 属性中。

7.HttpRequest.COOKIES

　　一个标准的Python 字典，包含所有的cookie。键和值都为字符串。

8.HttpRequest.FILES

　　一个类似于字典的对象，包含所有的上传文件信息。
   FILES 中的每个键为<input type="file" name="" /> 中的name，值则为对应的数据。

　　注意，FILES 只有在请求的方法为POST 且提交的<form> 带有enctype="multipart/form-data" 的情况下才会
   包含数据。否则，FILES 将为一个空的类似于字典的对象。

9.HttpRequest.META

 　　一个标准的Python 字典，包含所有的HTTP 首部。具体的头部信息取决于客户端和服务器，下面是一些示例：

    CONTENT_LENGTH —— 请求的正文的长度（是一个字符串）。
    CONTENT_TYPE —— 请求的正文的MIME 类型。
    HTTP_ACCEPT —— 响应可接收的Content-Type。
    HTTP_ACCEPT_ENCODING —— 响应可接收的编码。
    HTTP_ACCEPT_LANGUAGE —— 响应可接收的语言。
    HTTP_HOST —— 客服端发送的HTTP Host 头部。
    HTTP_REFERER —— Referring 页面。
    HTTP_USER_AGENT —— 客户端的user-agent 字符串。
    QUERY_STRING —— 单个字符串形式的查询字符串（未解析过的形式）。
    REMOTE_ADDR —— 客户端的IP 地址。
    REMOTE_HOST —— 客户端的主机名。
    REMOTE_USER —— 服务器认证后的用户。
    REQUEST_METHOD —— 一个字符串，例如"GET" 或"POST"。
    SERVER_NAME —— 服务器的主机名。
    SERVER_PORT —— 服务器的端口（是一个字符串）。
 　　从上面可以看到，除 CONTENT_LENGTH 和 CONTENT_TYPE 之外，请求中的任何 HTTP 首部转换为 META 的键时，
    都会将所有字母大写并将连接符替换为下划线最后加上 HTTP_  前缀。
    所以，一个叫做 X-Bender 的头部将转换成 META 中的 HTTP_X_BENDER 键。

 
10.HttpRequest.user

　　一个 AUTH_USER_MODEL 类型的对象，表示当前登录的用户。

　　如果用户当前没有登录，user 将设置为 django.contrib.auth.models.AnonymousUser 的一个实例。你可以通过 is_authenticated() 区分它们。

    例如：

    if request.user.is_authenticated():
        # Do something for logged-in users.
    else:
        # Do something for anonymous users.
     

     　　user 只有当Django 启用 AuthenticationMiddleware 中间件时才可用。

     -------------------------------------------------------------------------------------

    匿名用户
    class models.AnonymousUser

    django.contrib.auth.models.AnonymousUser 类实现了django.contrib.auth.models.User 接口，但具有下面几个不同点：

    id 永远为None。
    username 永远为空字符串。
    get_username() 永远返回空字符串。
    is_staff 和 is_superuser 永远为False。
    is_active 永远为 False。
    groups 和 user_permissions 永远为空。
    is_anonymous() 返回True 而不是False。
    is_authenticated() 返回False 而不是True。
    set_password()、check_password()、save() 和delete() 引发 NotImplementedError。
    New in Django 1.8:
    新增 AnonymousUser.get_username() 以更好地模拟 django.contrib.auth.models.User。

11.HttpRequest.session
 　　一个既可读又可写的类似于字典的对象，表示当前的会话。只有当Django 启用会话的支持时才可用。
    完整的细节参见会话的文档。

request属性相关

示例：正在更新中………………

6.1.2 request对象的方法：

 1 1.HttpRequest.get_host()
 2 
 3 　　根据从HTTP_X_FORWARDED_HOST（如果打开 USE_X_FORWARDED_HOST，默认为False）和 HTTP_HOST 头部信息返回请求的原始主机。
 4    如果这两个头部没有提供相应的值，则使用SERVER_NAME 和SERVER_PORT，在PEP 3333 中有详细描述。
 5 
 6 　　USE_X_FORWARDED_HOST：一个布尔值，用于指定是否优先使用 X-Forwarded-Host 首部，仅在代理设置了该首部的情况下，才可以被使用。
 7 
 8 　　例如："127.0.0.1:8000"
 9 
10 　　注意：当主机位于多个代理后面时，get_host() 方法将会失败。除非使用中间件重写代理的首部。
11 
12  
13 
14 2.HttpRequest.get_full_path()
15 
16 　　返回 path，如果可以将加上查询字符串。
17 
18 　　例如："/music/bands/the_beatles/?print=true"
19 
20  
21 
22 3.HttpRequest.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)
23 
24 　　返回签名过的Cookie 对应的值，如果签名不再合法则返回django.core.signing.BadSignature。
25 
26 　　如果提供 default 参数，将不会引发异常并返回 default 的值。
27 
28 　　可选参数salt 可以用来对安全密钥强力攻击提供额外的保护。max_age 参数用于检查Cookie 对应的时间戳以确保Cookie 的时间不会超过max_age 秒。
29 
30         复制代码
31         >>> request.get_signed_cookie('name')
32         'Tony'
33         >>> request.get_signed_cookie('name', salt='name-salt')
34         'Tony' # 假设在设置cookie的时候使用的是相同的salt
35         >>> request.get_signed_cookie('non-existing-cookie')
36         ...
37         KeyError: 'non-existing-cookie'    # 没有相应的键时触发异常
38         >>> request.get_signed_cookie('non-existing-cookie', False)
39         False
40         >>> request.get_signed_cookie('cookie-that-was-tampered-with')
41         ...
42         BadSignature: ...    
43         >>> request.get_signed_cookie('name', max_age=60)
44         ...
45         SignatureExpired: Signature age 1677.3839159 > 60 seconds
46         >>> request.get_signed_cookie('name', False, max_age=60)
47         False
48         复制代码
49          
50 
51 
52 4.HttpRequest.is_secure()
53 
54 　　如果请求时是安全的，则返回True；即请求通是过 HTTPS 发起的。
55 
56  
57 
58 5.HttpRequest.is_ajax()
59 
60 　　如果请求是通过XMLHttpRequest 发起的，则返回True，方法是检查 HTTP_X_REQUESTED_WITH 相应的首部是否是字符串'XMLHttpRequest'。
61 
62 　　大部分现代的 JavaScript 库都会发送这个头部。如果你编写自己的 XMLHttpRequest 调用（在浏览器端），你必须手工设置这个值来让 is_ajax() 可以工作。
63 
64 　　如果一个响应需要根据请求是否是通过AJAX 发起的，并且你正在使用某种形式的缓存例如Django 的 cache middleware， 
65    你应该使用 vary_on_headers('HTTP_X_REQUESTED_WITH') 装饰你的视图以让响应能够正确地缓存。
66 
67 请求相关方法

5个request常用的方法

注意：键值对的值是多个的时候,比如checkbox类型的input标签，select标签，也就是一个标签可能会有很多值的时候，

需要用下面的getlist方法来获取多个值：

request.POST.getlist("hobby")

6.2 Response对象

HttpResponse类定义在django.http模块中。

HttpRequest对象由Django自动创建，而HttpResponse对象则由程序员手动创建.

我们编写的每个视图都要实例化、填充和返回一个HttpResponse对象。也就是函数的return值。

6.2.1 使用方法

　　1. 传递一个字符串

最简单的方式是传递一个字符串作为页面的内容到HttpResponse构造函数，并返回给用户:

from django.http import HttpResponse
response = HttpResponse("Here's the text of the Web page.")
response = HttpResponse("Text only, please.", content_type="text/plain")

　　2. 传递可迭代对象

HttpResponse会立即处理这个迭代器，并把它的内容存成字符串，最后废弃这个迭代器。比如文件在读取后，会立刻调用close()方法，关闭文件。

　　3. 设置或删除响应头信息

response = HttpResponse()
response['Content-Type'] = 'text/html; charset=UTF-8'
del response['Content-Type']

6.2.2 Response对象的属性

前面三个重点记忆：
1. HttpResponse.content
响应的内容。bytes类型。

2. HttpResponse.charset
编码的字符集。 如果没指定，将会从content_type中解析出来。

3. HttpResponse.status_code
响应的状态码，比如200。
后面三个尽力而为：
4. HttpResponse.reason_phrase
响应的HTTP原因短语。 使用标准原因短语。

除非明确设置，否则reason_phrase由status_code的值决定。

5. HttpResponse.streaming
这个属性的值总是False。由于这个属性的存在，使得中间件能够区别对待流式响应和常规响应。

6. HttpResponse.closed
如果响应已关闭，那么这个属性的值为True。

6.3 JsonResponse类对象

JsonResponse是HttpResponse的子类，专门用来生成JSON编码的响应。

大白话的说：就是JsonResponse类，可以把一些数据类型，比如：字典，列表，元组，集合等数据类型的结构，转换成为字符串，以便用于转递到别的地方，提供别人使用！！！！

例如：有一个字典dict = {"aa":11, "bb":22}，此时的dict只是一个字典（数据类型），当把字典dict经过JsonResponse类的内部变换之后，会把dict变成字符串 ” {"aa":11, "bb":22} “，注意字典两边的大括号都会一起变成字符串！！！！

from django.http import JsonResponse

response = JsonResponse({'foo': 'bar'})
print(response.content)

b'{"foo": "bar"}'

JsonResponse默认只能传递字典类型，如果要传递非字典类型需要设置一下safe关键字参数。

response = JsonResponse([1, 2, 3], safe=False)

什么是QueryDict对象？

类的原型：class QueryDict[source]

在HttpRequest对象中，GET和POST属性都是一个django.http.QueryDict的实例。也就是说你可以按本文下面提供的方法操作request.POST和request.GET。

request.POST或request.GET的QueryDict都是不可变，只读的。如果要修改它，需要使用QueryDict.copy()方法，获取它的一个拷贝，然后在这个拷贝上进行修改操作。

一、方法
QueryDict 实现了Python字典数据类型的所有标准方法，因为它是字典的子类。

不同之处在于下面：

1. QueryDict.init(query_string=None, mutable=False, encoding=None)[source]
QueryDict实例化方法。注意：QueryDict的键值是可以重复的！

>>> QueryDict('a=1&a=2&c=3')
<QueryDict: {'a': ['1', '2'], 'c': ['3']}>
如果需要实例化可以修改的对象，添加参数mutable=True。

2. classmethod QueryDict.fromkeys(iterable, value='', mutable=False, encoding=None)[source]
Django1.11中的新功能。

循环可迭代对象中的每个元素作为键值，并赋予同样的值（来至value参数）。

>>> QueryDict.fromkeys(['a', 'a', 'b'], value='val')
<QueryDict: {'a': ['val', 'val'], 'b': ['val']}>
3. QueryDict.update(other_dict)
用新的QueryDict或字典更新当前QueryDict。类似dict.update()，但是追加内容，而不是更新并替换它们。 像这样：

>>> q = QueryDict('a=1', mutable=True)
>>> q.update({'a': '2'})
>>> q.getlist('a')
['1', '2']
>>> q['a'] # returns the last
'2'
4. QueryDict.items()
类似dict.items()，如果有重复项目，返回最近的一个，而不是都返回：

>>> q = QueryDict('a=1&a=2&a=3')
>>> q.items()
[('a', '3')]
5. QueryDict.values()
类似dict.values()，但是只返回最近的值。 像这样：

>>> q = QueryDict('a=1&a=2&a=3')
>>> q.values()
['3']
6. QueryDict.copy()[source]
使用copy.deepcopy()返回QueryDict对象的副本。 此副本是可变的！

7. QueryDict.getlist(key, default=None)
返回键对应的值列表。 如果该键不存在并且未提供默认值，则返回一个空列表。

8. QueryDict.setlist(key, list_)[source]
为list_设置给定的键。

9. QueryDict.appendlist(key, item)[source]
将键追加到内部与键相关联的列表中。

10. QueryDict.setdefault(key, default=None)[source]
类似dict.setdefault()，为某个键设置默认值。

11. QueryDict.setlistdefault(key, default_list=None)[source]
类似setdefault()，除了它需要的是一个值的列表而不是单个值。

12. QueryDict.lists()
类似items()，只是它将其中的每个键的值作为列表放在一起。 像这样：

>>> q = QueryDict('a=1&a=2&a=3')
>>> q.lists()
[('a', ['1', '2', '3'])]
13. QueryDict.pop(key)[source]
返回给定键的值的列表，并从QueryDict中移除该键。 如果键不存在，将引发KeyError。 像这样：

>>> q = QueryDict('a=1&a=2&a=3', mutable=True)
>>> q.pop('a')
['1', '2', '3']
14. QueryDict.popitem()[source]
删除QueryDict任意一个键，并返回二值元组，包含键和键的所有值的列表。在一个空的字典上调用时将引发KeyError。 像这样：

>>> q = QueryDict('a=1&a=2&a=3', mutable=True)
>>> q.popitem()
('a', ['1', '2', '3'])
15. QueryDict.dict()
将QueryDict转换为Python的字典数据类型，并返回该字典。

如果出现重复的键，则将所有的值打包成一个列表，最为新字典中键的值。

>>> q = QueryDict('a=1&a=3&a=5')
>>> q.dict()
{'a': '5'}
16. QueryDict.urlencode(safe=None)[source]
已url的编码格式返回数据字符串。 像这样：

>>> q = QueryDict('a=2&b=3&b=5')
>>> q.urlencode()
'a=2&b=3&b=5'
使用safe参数传递不需要编码的字符。 像这样：

>>> q = QueryDict(mutable=True)
>>> q['next'] = '/a&b/'
>>> q.urlencode(safe='/')
'next=/a%26b/'

QueryDict对象内容

转载于:https://www.cnblogs.com/mashangsir/p/11468420.html

weixin_30363509

关注

1
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
Django框架——基础之视图系统（View.py）

Django框架之View.py（视图文件）1. 视图简介视图层是Django处理请求的核心代码层，我们大多数Python代码都集中在这一层面。它对外接收用户请求，对内调度模型层和模版层，统合数据库和前端，最后根据业务逻辑，将处理好的数据，与前端结合，返回给用户。视图层是真正的后端，是Python工程师的‘主营业务’。视图就是每个创建的APP中的的view.py文件夹。我...
复制链接

扫一扫