Django 视图层

Django的View（视图）

1 视图函数

一个视图函数，简称视图，是一个简单的Python 函数，它接受Web请求并且返回Web响应。响应可以是一张网页的HTML内容，一个重定向，一个404错误，一个XML文档，或者一张图片. . . 是任何东西都可以。无论视图本身包含什么逻辑，都要返回响应。代码写在哪里也无所谓，只要它在你的Python目录下面。除此之外没有更多的要求了——可以说“没有什么神奇的地方”。为了将代码放在某处，约定是将视图放置在项目或应用程序目录中的名为views.py的文件中。

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

from django.shortcuts import render, HttpResponse, HttpResponseRedirect, redirect
import datetime

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

让我们逐行阅读上面的代码：

首先，我们从 django.shortcuts模块导入了HttpResponse类，以及Python的datetime库。
接着，我们定义了current_datetime函数。它就是视图函数。每个视图函数都使用HttpRequest对象作为第一个参数，并且通常称之为request。

注意,视图函数的名称并不重要；不需要用一个统一的命名方式来命名，以便让Django识别它。我们将其命名为current_datetime，是因为这个名称能够精确地反映出它的功能。
这个视图会返回一个HttpResponse对象，其中包含生成的响应。每个视图函数都负责返回一个HttpResponse对象。

视图层，熟练掌握两个对象即可：请求对象(request)和响应对象(HttpResponse)

2 HttpRequest对象

request属性

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

'''

1.HttpRequest.GET

　　一个类似于字典的对象，包含 HTTP GET 的所有参数。详情请参考 QueryDict 对象。

2.HttpRequest.POST

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

　　POST 请求可以带有空的 POST 字典 —— 如果通过 HTTP POST 方法发送一个表单，但是表单中没有任何的数据，QueryDict 对象依然会被创建。
   因此，不应该使用 if request.POST  来检查使用的是否是POST 方法；应该使用 if request.method == "POST"
　　另外：如果使用 POST 上传文件的话，文件信息将包含在 FILES 属性中。
   
   注意：键值对的值是多个的时候,比如checkbox类型的input标签，select标签，需要用：
        request.POST.getlist("hobby")

3.HttpRequest.body

　　一个字符串，代表请求报文的主体。在处理非 HTTP 形式的报文时非常有用，例如：二进制图片、XML,Json等。
　　但是，如果要处理表单数据的时候，推荐还是使用 HttpRequest.POST 。


4.HttpRequest.path

　　一个字符串，表示请求的路径组件（不含域名）。
　　例如："/music/bands/the_beatles/"

5.HttpRequest.method

　　一个字符串，表示请求使用的HTTP 方法。必须使用大写。
　　例如："GET"、"POST"


6.HttpRequest.encoding

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


7.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 键。

8.HttpRequest.FILES

　　一个类似于字典的对象，包含所有的上传文件信息。
   FILES 中的每个键为<input type="file" name="" /> 中的name，值则为对应的数据。
　　注意，FILES 只有在请求的方法为POST 且提交的<form> 带有enctype="multipart/form-data" 的情况下才会
   包含数据。否则，FILES 将为一个空的类似于字典的对象。


9.HttpRequest.COOKIES

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



10.HttpRequest.session

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


11.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。

*/

request常用方法

'''
1.HttpRequest.get_full_path()

　　返回 path，如果可以将加上查询字符串。

　　例如："/music/bands/the_beatles/?print=true"
　　注意和path的区别：http://127.0.0.1:8001/order/?name=lqz&age=10

2.HttpRequest.is_ajax()

　　如果请求是通过XMLHttpRequest 发起的，则返回True，方法是检查 HTTP_X_REQUESTED_WITH 相应的首部是否是字符串'XMLHttpRequest'。

　　大部分现代的 JavaScript 库都会发送这个头部。如果你编写自己的 XMLHttpRequest 调用（在浏览器端），你必须手工设置这个值来让 is_ajax() 可以工作。

　　如果一个响应需要根据请求是否是通过AJAX 发起的，并且你正在使用某种形式的缓存例如Django 的 cache middleware，
   你应该使用 vary_on_headers('HTTP_X_REQUESTED_WITH') 装饰你的视图以让响应能够正确地缓存。

'''

3 HttpResponse对象

响应对象主要有三种形式：

HttpResponse()
render()
redirect()

HttpResponse()括号内直接跟一个具体的字符串作为响应体，比较直接很简单，所以这里主要介绍后面两种形式。

render()

render(request, template_name[, context]）
结合一个给定的模板和一个给定的上下文字典，并返回一个渲染后的 HttpResponse 对象。

参数：
     request： 用于生成响应的请求对象。

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

     context：添加到模板上下文的一个字典。默认是一个空字典。如果字典中的某个值是可调用的，视图将在渲染模板之前调用它。

render方法就是将一个模板页面中的模板语法进行渲染，最终渲染成一个html页面作为响应体。

redirect()

传递要重定向的一个硬编码的URL

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

也可以是一个完整的URL：

def my_view(request):
    ...
    return redirect('http://www.baidu.com/')

1）301和302的区别。

　　301和302状态码都表示重定向，就是说浏览器在拿到服务器返回的这个状态码后会自动跳转到一个新的URL地址，这个地址可以从响应的Location首部中获取
  （用户看到的效果就是他输入的地址A瞬间变成了另一个地址B）——这是它们的共同点。

　　他们的不同在于。301表示旧地址A的资源已经被永久地移除了（这个资源不可访问了），搜索引擎在抓取新内容的同时也将旧的网址交换为重定向之后的网址；

　　302表示旧地址A的资源还在（仍然可以访问），这个重定向只是临时地从旧地址A跳转到地址B，搜索引擎会抓取新的内容而保存旧的网址。 SEO302好于301

 

2）重定向原因：
（1）网站调整（如改变网页目录结构）；
（2）网页被移到一个新地址；
（3）网页扩展名改变(如应用需要把.php改成.Html或.shtml)。
        这种情况下，如果不做重定向，则用户收藏夹或搜索引擎数据库中旧地址只能让访问客户得到一个404页面错误信息，访问流量白白丧失；再者某些注册了多个域名的
    网站，也需要通过重定向让访问这些域名的用户自动跳转到主站点等。

4 JsonResponse

向前端返回一个json格式字符串的两种方式

    # 第一种方式
    # import json
    # data={'name':'lqz','age':18}
    # data1=['lqz','egon']
    # return HttpResponse(json.dumps(data1))
    # 第二种方式
    from django.http import JsonResponse
    # data = {'name': 'lqz', 'age': 18}
    data1 = ['lqz', 'egon']
    # return JsonResponse(data)
    return JsonResponse(data1,safe=False)

5 CBV和FBV

CBV基于类的视图(Class base view)和FBV基于函数的视图（Function base view）

from django.views import View
class AddPublish(View):
    def dispatch(self, request, *args, **kwargs):
        print(request)
        print(args)
        print(kwargs)
        # 可以写类似装饰器的东西，在前后加代码
        obj=super().dispatch(request, *args, **kwargs)
        return obj

    def get(self,request):
        return render(request,'index.html')
    def post(self,request):
        request
        return HttpResponse('post')

6 简单文件上传

        print(request.FILES)
        print(type(request.FILES.get('file_name')))

        file_name=request.FILES.get('file_name').name
        from django.core.files.uploadedfile import InMemoryUploadedFile
        with open(file_name,'wb')as f:
            for i in request.FILES.get('file_name').chunks():
                f.write(i)

CBV和FBV

我们之前写过的都是基于函数的view，就叫FBV。还可以把view写成基于类的。

就拿我们之前写过的添加班级为例：

FBV版：

# FBV版添加班级
def add_class(request):
    if request.method == "POST":
        class_name = request.POST.get("class_name")
        models.Classes.objects.create(name=class_name)
        return redirect("/class_list/")
    return render(request, "add_class.html")

CBV版：

# CBV版添加班级
from django.views import View


class AddClass(View):

    def get(self, request):
        return render(request, "add_class.html")

    def post(self, request):
        class_name = request.POST.get("class_name")
        models.Classes.objects.create(name=class_name)
        return redirect("/class_list/")

注意：

使用CBV时，urls.py中也做对应的修改：

# urls.py中
url(r'^add_class/$', views.AddClass.as_view()),

给视图加装饰器

使用装饰器装饰FBV

FBV本身就是一个函数，所以和给普通的函数加装饰器无差：

def wrapper(func):
    def inner(*args, **kwargs):
        start_time = time.time()
        ret = func(*args, **kwargs)
        end_time = time.time()
        print("used:", end_time-start_time)
        return ret
    return inner


# FBV版添加班级
@wrapper
def add_class(request):
    if request.method == "POST":
        class_name = request.POST.get("class_name")
        models.Classes.objects.create(name=class_name)
        return redirect("/class_list/")
    return render(request, "add_class.html")

使用装饰器装饰CBV

类中的方法与独立函数不完全相同，因此不能直接将函数装饰器应用于类中的方法，我们需要先将其转换为方法装饰器。

Django中提供了method_decorator装饰器用于将函数装饰器转换为方法装饰器。

# CBV版添加班级
from django.views import View
from django.utils.decorators import method_decorator

class AddClass(View):

    @method_decorator(wrapper)
    def get(self, request):
        return render(request, "add_class.html")

    def post(self, request):
        class_name = request.POST.get("class_name")
        models.Classes.objects.create(name=class_name)
        return redirect("/class_list/")

# 使用CBV时要注意，请求过来后会先执行dispatch()这个方法，如果需要批量对具体的请求处理方法，如get，post等做一些操作的时候，这里我们可以手动改写dispatch方法，这个dispatch方法就和在FBV上加装饰器的效果一样。

class Login(View):
     
    def dispatch(self, request, *args, **kwargs):
        print('before')
        obj = super(Login,self).dispatch(request, *args, **kwargs)
        print('after')
        return obj
 
    def get(self,request):
        return render(request,'login.html')
 
    def post(self,request):
        print(request.POST.get('user'))
        return HttpResponse('Login.post')

关于CBV的扩展阅读

from django.views.decorators.csrf import csrf_protect,csrf_exempt

@csrf_exempt           # 给视图加上装饰器后，当前的视图不需要CSRF校验
def index(request):
    pass

@csrf_protect           # 给视图加上装饰器后，当前的视图需要CSRF校验，需要把中间件的CSRF注释掉
def index(request):
    pass


from django import views
from django.views.decorators.csrf import csrf_protect,csrf_exempt
from django.utils.decorators import method_decorator

class Login(views.View):
    def get(self,request):
        pass

    @method_decorator(csrf_protect)
    def post(self,request):
        pass

Request对象和Response对象

request对象

当一个页面被请求时，Django就会创建一个包含本次请求原信息的HttpRequest对象。
Django会将这个对象自动传递给响应的视图函数，一般视图函数约定俗成地使用 request 参数承接这个对象。

官方文档

请求相关的常用值

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

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

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

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

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

属性

所有的属性应该被认为是只读的，除非另有说明。

属性：
　　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 对象。

 

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属性相关

上传文件示例

def upload(request):
    """
    保存上传文件前，数据需要存放在某个位置。默认当上传文件小于2.5M时，django会将上传文件的全部内容读进内存。从内存读取一次，写磁盘一次。
    但当上传文件很大时，django会把上传文件写到临时文件中，然后存放到系统临时文件夹中。
    :param request: 
    :return: 
    """
    if request.method == "POST":
        # 从请求的FILES中获取上传文件的文件名，file为页面上type=files类型input的name属性值
        filename = request.FILES["file"].name
        # 在项目目录下新建一个文件
        with open(filename, "wb") as f:
            # 从上传的文件对象中一点一点读
            for chunk in request.FILES["file"].chunks():
                # 写入本地文件
                f.write(chunk)
        return HttpResponse("上传OK")

上传文件示例代码

方法

1.HttpRequest.get_host()

　　根据从HTTP_X_FORWARDED_HOST（如果打开 USE_X_FORWARDED_HOST，默认为False）和 HTTP_HOST 头部信息返回请求的原始主机。
   如果这两个头部没有提供相应的值，则使用SERVER_NAME 和SERVER_PORT，在PEP 3333 中有详细描述。

　　USE_X_FORWARDED_HOST：一个布尔值，用于指定是否优先使用 X-Forwarded-Host 首部，仅在代理设置了该首部的情况下，才可以被使用。

　　例如："127.0.0.1:8000"

　　注意：当主机位于多个代理后面时，get_host() 方法将会失败。除非使用中间件重写代理的首部。

 

2.HttpRequest.get_full_path()

　　返回 path，如果可以将加上查询字符串。

　　例如："/music/bands/the_beatles/?print=true"

 

3.HttpRequest.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)

　　返回签名过的Cookie 对应的值，如果签名不再合法则返回django.core.signing.BadSignature。

　　如果提供 default 参数，将不会引发异常并返回 default 的值。

　　可选参数salt 可以用来对安全密钥强力攻击提供额外的保护。max_age 参数用于检查Cookie 对应的时间戳以确保Cookie 的时间不会超过max_age 秒。

        复制代码
        >>> request.get_signed_cookie('name')
        'Tony'
        >>> request.get_signed_cookie('name', salt='name-salt')
        'Tony' # 假设在设置cookie的时候使用的是相同的salt
        >>> request.get_signed_cookie('non-existing-cookie')
        ...
        KeyError: 'non-existing-cookie'    # 没有相应的键时触发异常
        >>> request.get_signed_cookie('non-existing-cookie', False)
        False
        >>> request.get_signed_cookie('cookie-that-was-tampered-with')
        ...
        BadSignature: ...    
        >>> request.get_signed_cookie('name', max_age=60)
        ...
        SignatureExpired: Signature age 1677.3839159 > 60 seconds
        >>> request.get_signed_cookie('name', False, max_age=60)
        False
        复制代码
         


4.HttpRequest.is_secure()

　　如果请求时是安全的，则返回True；即请求通是过 HTTPS 发起的。

 

5.HttpRequest.is_ajax()

　　如果请求是通过XMLHttpRequest 发起的，则返回True，方法是检查 HTTP_X_REQUESTED_WITH 相应的首部是否是字符串'XMLHttpRequest'。

　　大部分现代的 JavaScript 库都会发送这个头部。如果你编写自己的 XMLHttpRequest 调用（在浏览器端），你必须手工设置这个值来让 is_ajax() 可以工作。

　　如果一个响应需要根据请求是否是通过AJAX 发起的，并且你正在使用某种形式的缓存例如Django 的 cache middleware， 
   你应该使用 vary_on_headers('HTTP_X_REQUESTED_WITH') 装饰你的视图以让响应能够正确地缓存。

请求相关方法

注意：键值对的值是多个的时候,比如checkbox类型的input标签，select标签，需要用：

request.POST.getlist("hobby")

回到顶部

Response对象

与由Django自动创建的HttpRequest对象相比，HttpResponse对象是我们的职责范围了。我们写的每个视图都需要实例化，填充和返回一个HttpResponse。

HttpResponse类位于django.http模块中。

使用

传递字符串

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

设置或删除响应头信息

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

属性

HttpResponse.content：响应内容

HttpResponse.charset：响应内容的编码

HttpResponse.status_code：响应的状态码

JsonResponse对象

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

from django.http import JsonResponse

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

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

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

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

回到顶部

Django shortcut functions

官方文档

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))

redirect()

参数可以是：

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

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

示例:

你可以用多种方式使用redirect() 函数。

传递一个具体的ORM对象（了解即可）

将调用具体ORM对象的get_absolute_url() 方法来获取重定向的URL：

from django.shortcuts import redirect
 
def my_view(request):
    ...
    object = MyModel.objects.get(...)
    return redirect(object)

传递一个视图的名称

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

传递要重定向到的一个具体的网址

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

当然也可以是一个完整的网址

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

默认情况下，redirect() 返回一个临时重定向。以上所有的形式都接收一个permanent 参数；如果设置为True，将返回一个永久的重定向：

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

扩展阅读：

临时重定向（响应状态码：302）和永久重定向（响应状态码：301）对普通用户来说是没什么区别的，它主要面向的是搜索引擎的机器人。

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

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

视图

一个视图函数，简称视图，是一个简单的Python 函数，它接受Web请求并且返回Web响应。响应可以是一张网页的HTML内容，一个重定向，一个404错误，一个XML文档，或者一张图片. . . 是任何东西都可以。无论视图本身包含什么逻辑，都要返回响应。代码写在哪里也无所谓，只要它在你的Python目录下面。除此之外没有更多的要求了。为了将代码放在某处，约定是将视图放置在项目或应用程序目录中的名为views.py的文件中。

一、HttpRequest对象

django将请求报文中的请求行、首部信息、内容主体封装成 HttpRequest 类中的属性。

"""
一、属性
1. HttpRequest.scheme
字符串类型，表示请求的协议种类，'http'或'https'。
 
2. HttpRequest.body
一个字符串，代表请求报文的主体。在处理非 HTTP 形式的报文时非常有用，例如：二进制图像、XML等。如果要处理常规的表单数据，应该使用HttpRequest.POST。
还可以使用类似读写文件的方式从HttpRequest中读取数据，参见HttpRequest.read()。
 
3. HttpRequest.path
字符串类型，表示当前请求页面的完整路径，但是不包括协议名和域名。例如："/music/bands/the_beatles/"。这个属性，常被用于我们进行某项操作时，如果不通过，返回用户先前浏览的页面。非常有用！
 
4. HttpRequest.path_info
在某些Web服务器配置下，主机名后的URL部分被分成脚本前缀部分和路径信息部分。path_info 属性将始终包含路径信息部分，不论使用的Web服务器是什么。使用它代替path可以让代码在测试和开发环境中更容易地切换。
 
例如，如果应用的WSGIScriptAlias设置为/minfo，那么HttpRequest.path等于/music/bands/the_beatles/ ，而HttpRequest.path_info为/minfo/music/bands/the_beatles/。
 
5. HttpRequest.method
字符串类型，表示请求使用的HTTP方法。默认为大写。 像这样：
 
if request.method == 'GET':
    do_something()
elif request.method == 'POST':
    do_something_else()
通过这个属性来判断请求的方法，然后根据请求的方法不同，在视图中执行不同的代码。
 
6. HttpRequest.encoding
一个字符串，表示提交的数据的编码方式（如果为 None 则表示使用 DEFAULT_CHARSET 的设置，默认为 'utf-8'）。
这个属性是可写的，你可以修改它来修改访问表单数据使用的编码。
接下来对属性的任何访问（例如从 GET 或 POST 中读取数据）将使用新的 encoding 值。
如果你知道表单数据的编码不是 DEFAULT_CHARSET ，则使用它。
 
7. HttpRequest.content_type
Django1.10中新增。表示从CONTENT_TYPE头解析的请求的MIME类型。
 
8. HttpRequest.content_params
Django 1.10中新增。包含在CONTENT_TYPE标题中的键/值参数字典。
 
9 HttpRequest.GET
一个类似于字典的对象，包含GET请求中的所有参数。 详情参考QueryDict文档。
 
注意：键值对的值是多个的时候,比如checkbox类型的input标签，select标签，需要用：
request.POST.getlist("hobby")
 
10. HttpRequest.POST
一个包含所有POST请求的参数，以及包含表单数据的字典。 详情请参考QueryDict文档。 如果需要访问请求中的原始或非表单数据，可以使用HttpRequest.body属性。
 
注意：请使用if request.method == "POST"来判断一个请求是否POST类型，而不要使用if request.POST。
POST中不包含上传文件的数据。文件信息将包含在 FILES 属性中。
 
11. HttpRequest.COOKIES
包含所有Cookie信息的字典。 键和值都为字符串。可以类似字典类型的方式，在cookie中读写数据，但是注意cookie是不安全的，因此，不要写敏感重要的信息。
 
12. HttpRequest.FILES
一个类似于字典的对象，包含所有的上传文件信息。
FILES 中的每个键为<input type="file" name="" /> 中的name，值则为对应的数据。
注意，FILES 只有在请求的方法为POST 且提交的<form> 带有enctype="multipart/form-data" 的情况下才会
包含数据。否则，FILES 将为一个空的类似于字典的对象。
 
13. HttpRequest.META
包含所有HTTP头部信息的字典。 可用的头部信息取决于客户端和服务器，下面是一些示例：
 
CONTENT_LENGTH —— 请求正文的长度（以字符串计）。
CONTENT_TYPE —— 请求正文的MIME类型。
HTTP_ACCEPT —— 可接收的响应Content-Type。
HTTP_ACCEPT_ENCODING —— 可接收的响应编码类型。
HTTP_ACCEPT_LANGUAGE —— 可接收的响应语言种类。
HTTP_HOST —— 客服端发送的Host头部。
HTTP_REFERER —— Referring页面。
HTTP_USER_AGENT —— 客户端的user-agent字符串。
QUERY_STRING —— 查询字符串。
REMOTE_ADDR —— 客户端的IP地址。想要获取客户端的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键。
 
13. HttpRequest.resolver_match
代表一个已解析的URL的ResolverMatch实例。
 
 
 
二、可自定义的属性
Django不会自动设置下面这些属性，而是由你自己在应用程序中设置并使用它们。
 
1. HttpRequest.current_app
表示当前app的名字。url模板标签将使用其值作为reverse()方法的current_app参数。
 
2. HttpRequest.urlconf
设置当前请求的根URLconf，用于指定不同的url路由进入口，这将覆盖settings中的ROOT_URLCONF设置。
将它的值修改为None，可以恢复使用ROOT_URLCONF设置。
 
 
 
 
三、由中间件设置的属性
Django的contrib应用中包含的一些中间件会在请求上设置属性。
 
1. HttpRequest.session
一个既可读又可写的类似于字典的对象，表示当前的会话。只有当Django 启用会话的支持时才可用。
SessionMiddleware中间件：一个可读写的，类似字典的对象，表示当前会话。我们要保存用户状态，回话过程等等，靠的就是这个中间件和这个属性。
 
2. HttpRequest.site
CurrentSiteMiddleware中间件：get_current_site()方法返回的Site或RequestSite的实例，代表当前站点是哪个。
 
Django是支持多站点的，如果你同时上线了几个站点，就需要为每个站点设置一个站点id。
 
3. HttpRequest.user(用户认证组件下使用)
AuthenticationMiddleware中间件：表示当前登录的用户的AUTH_USER_MODEL的实例，这个模型是Django内置的Auth模块下的User模型。如果用户当前未登录，则user将被设置为AnonymousUser的实例。
可以使用is_authenticated方法判断当前用户是否合法用户，如下所示：
 
 
　　一个 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。
 
"""

request属性

"""
1.HttpRequest.get_full_path()
 
　　返回 path，如果可以将加上查询字符串。
 
　　例如："/music/bands/the_beatles/?print=true"
 
 
2.HttpRequest.is_ajax()
 
　　如果请求是通过XMLHttpRequest 发起的，则返回True，方法是检查 HTTP_X_REQUESTED_WITH 相应的首部是否是字符串'XMLHttpRequest'。
 
　　大部分现代的 JavaScript 库都会发送这个头部。如果你编写自己的 XMLHttpRequest 调用（在浏览器端），你必须手工设置这个值来让 is_ajax() 可以工作。
 
　　如果一个响应需要根据请求是否是通过AJAX 发起的，并且你正在使用某种形式的缓存例如Django 的 cache middleware，
   你应该使用 vary_on_headers('HTTP_X_REQUESTED_WITH') 装饰你的视图以让响应能够正确地缓存。
"""
 
"""
1. HttpRequest.get_host()[source]
根据HTTP_X_FORWARDED_HOST和HTTP_HOST头部信息获取请求的原始主机。 如果这两个头部没有提供相应的值，则使用SERVER_NAME和SERVER_PORT。
 
例如："127.0.0.1:8000"
 
注：当主机位于多个代理的后面，get_host()方法将会失败。解决办法之一是使用中间件重写代理的头部，如下面的例子：
 
from django.utils.deprecation import MiddlewareMixin
 
class MultipleProxyMiddleware(MiddlewareMixin):
    FORWARDED_FOR_FIELDS = [
        'HTTP_X_FORWARDED_FOR',
        'HTTP_X_FORWARDED_HOST',
        'HTTP_X_FORWARDED_SERVER',
    ]
 
    def process_request(self, request):
 
        Rewrites the proxy headers so that only the most
        recent proxy is used.
 
        for field in self.FORWARDED_FOR_FIELDS:
            if field in request.META:
                if ',' in request.META[field]:
                    parts = request.META[field].split(',')
                    request.META[field] = parts[-1].strip()
                     
2. HttpRequest.get_port()[source]
使用META中HTTP_X_FORWARDED_PORT和SERVER_PORT的信息返回请求的始发端口。
 
3. HttpRequest.get_full_path()[source]
返回包含完整参数列表的path。例如：/music/bands/the_beatles/?print=true
 
4. HttpRequest.build_absolute_uri(location)[source]

返回location的绝对URI形式。 如果location没有提供，则使用request.get_full_path()的值。
 
例如："https://example.com/music/bands/the_beatles/?print=true"
 
注：不鼓励在同一站点混合部署HTTP和HTTPS，如果需要将用户重定向到HTTPS，最好使用Web服务器将所有HTTP流量重定向到HTTPS。
 
5. HttpRequest.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None)[source]
从已签名的Cookie中获取值，如果签名不合法则返回django.core.signing.BadSignature。
可选参数salt用来为密码加盐，提高安全系数。 max_age参数用于检查Cookie对应的时间戳是否超时。
 
6. HttpRequest.is_secure()[source]
如果使用的是Https，则返回True，表示连接是安全的。
 
7. HttpRequest.is_ajax()[source]
如果请求是通过XMLHttpRequest生成的，则返回True。
这个方法的作用就是判断，当前请求是否通过ajax机制发送过来的。
 
8. HttpRequest.read(size=None)[source]
9. HttpRequest.readline()[source]
10. HttpRequest.readlines()[source]
11. HttpRequest.xreadlines()[source]
12. HttpRequest.iter()
上面的几个方法都是从HttpRequest实例读取文件数据的方法。
 
可以将HttpRequest实例直接传递到XML解析器，例如ElementTree：
 
import xml.etree.ElementTree as ET
for element in ET.iterparse(request):
    process(element)
 
"""

request常用方法

二、HttpResponse对象

响应对象主要有三种形式：

HttpResponse():HttpResponse()括号内直接跟一个具体的字符串作为响应体，比较直接很简单，所以这里主要介绍后面两种形式。
render():render方法就是将一个模板页面中的模板语法进行渲染，最终渲染成一个html页面作为响应体。
redirect():重定向一个URL

"""
render(request, template_name[, context]）
结合一个给定的模板和一个给定的上下文字典，并返回一个渲染后的 HttpResponse 对象。
参数：
 request： 用于生成响应的请求对象。
 template_name：要使用的模板的完整名称，可选的参数
 context：添加到模板上下文的一个字典。默认是一个空字典。如果字典中的某个值是可调用的，视图将在渲染模板之前调用它。
 render方法就是将一个模板页面中的模板语法进行渲染，最终渲染成一个html页面作为响应体。
"""
return render(request,"index.html",{"timer":ctime}) #  index.html 模板文件
# return render(request, "index.html", locals())  #
 
# HttpResponse
return HttpResponse(reverse("app01:index"))
return HttpResponse("<h1>OK</h1>")
 
#redirect
return redirect("/index/")
return redirect('http://baidu.com/')

View Code

"""
一、使用方法
1. 传递一个字符串
return HttpResponse("<h1>OK</h1>")

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

3. 设置头部字段
可以把HttpResponse对象当作一个字典一样，在其中增加和删除头部字段。
>>> response = HttpResponse()
>>> response['Age'] = 120
>>> del response['Age']
注意！与字典不同的是，如果要删除的头部字段如果不存在，del不会抛出KeyError异常。
HTTP的头部字段中不能包含换行。所以如果我们提供的头部字段值包含换行符（CR或者LF），将会抛出BadHeaderError异常。

4. 告诉浏览器将响应视为文件附件
让浏览器以文件附件的形式处理响应, 需要声明content_type类型和设置Content-Disposition头信息。 例如，给浏览器返回一个微软电子表格：
>>> response = HttpResponse(my_data, content_type='application/vnd.ms-excel')
>>> response['Content-Disposition'] = 'attachment; filename="foo.xls"'

二、属性
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。

三、 方法
1. HttpResponse.init(content='', content_type=None, status=200, reason=None, charset=None)[source]
响应的实例化方法。使用content参数和content-type实例化一个HttpResponse对象。

content应该是一个迭代器或者字符串。如果是迭代器，这个迭代期返回的应是一串字符串，并且这些字符串连接起来形成response的内容。 如果不是迭代器或者字符串，那么在其被接收的时候将转换成字符串。

content_type是可选地，用于填充HTTP的Content-Type头部。如果未指定，默认情况下由DEFAULT_CONTENT_TYPE和DEFAULT_CHARSET设置组成：text/html; charset=utf-8。

status是响应的状态码。reason是HTTP响应短语。charset是编码方式。

2. HttpResponse.has_header(header)
检查头部中是否有给定的名称（不区分大小写），返回True或 False。

3. HttpResponse.setdefault(header, value)
设置一个头部，除非该头部已经设置过了。

4. HttpResponse.set_cookie(key, value='', max_age=None, expires=None, path='/', domain=None, secure=None, httponly=False)
设置一个Cookie。 参数与Python标准库中的Morsel.Cookie对象相同。

max_age: 生存周期，以秒为单位。

expires：到期时间。

domain: 用于设置跨域的Cookie。例如domain=".lawrence.com"将设置一个www.lawrence.com、blogs.lawrence.com和calendars.lawrence.com都可读的Cookie。 否则，Cookie将只能被设置它的域读取。

如果你想阻止客服端的JavaScript访问Cookie，可以设置httponly=True。

5. HttpResponse.set_signed_cookie(key, value, salt='', max_age=None, expires=None, path='/', domain=None, secure=None, httponly=True)
与set_cookie()类似，但是在设置之前将对cookie进行加密签名。通常与HttpRequest.get_signed_cookie()一起使用。

6. HttpResponse.delete_cookie(key, path='/', domain=None)
删除Cookie中指定的key。

由于Cookie的工作方式，path和domain应该与set_cookie()中使用的值相同，否则Cookie不会删掉。

7. HttpResponse.write(content)[source]
将HttpResponse实例看作类似文件的对象，往里面添加内容。

8. HttpResponse.flush()
清空HttpResponse实例的内容。

9. HttpResponse.tell()[source]
将HttpResponse实例看作类似文件的对象，移动位置指针。

10. HttpResponse.getvalue()[source]
返回HttpResponse.content的值。 此方法将HttpResponse实例看作是一个类似流的对象。

11. HttpResponse.readable()
Django1.10中的新功能，值始终为False。

12. HttpResponse.seekable()
Django1.10中的新功能，值始终为False。

13. HttpResponse.writable()[source]
Django1.10中的新功能，值始终为True。

14. HttpResponse.writelines(lines)[source]
将一个包含行的列表写入响应对象中。 不添加分行符。

四、HttpResponse的子类
Django包含了一系列的HttpResponse衍生类（子类），用来处理不同类型的HTTP响应。与HttpResponse相同, 这些衍生类存在于django.http之中。

class HttpResponseRedirect[source]：重定向，返回302状态码。已经被redirect()替代。
class HttpResponsePermanentRedirect[source]:永久重定向，返回301状态码。
class HttpResponseNotModified[source]：未修改页面，返回304状态码。
class HttpResponseBadRequest[source]：错误的请求，返回400状态码。
class HttpResponseNotFound[source]：页面不存在，返回404状态码。
class HttpResponseForbidden[source]：禁止访问，返回403状态码。
class HttpResponseNotAllowed[source]：禁止访问，返回405状态码。
class HttpResponseGone[source]：过期，返回405状态码。
class HttpResponseServerError[source]：服务器错误，返回500状态码。


五、JsonResponse类
class JsonResponse（data，encoder = DjangoJSONEncoder，safe = True，json_dumps_params = None ，** kwargs）[source]

JsonResponse是HttpResponse的一个子类，是Django提供的用于创建JSON编码类型响应的快捷类。

它从父类继承大部分行为，并具有以下不同点：

它的默认Content-Type头部设置为application/json。

它的第一个参数data，通常应该为一个字典数据类型。 如果safe参数设置为False，则可以是任何可JSON 序列化的对象。

encoder默认为django.core.serializers.json.DjangoJSONEncoder，用于序列化数据。
布尔类型参数safe默认为True。 如果设置为False，可以传递任何对象进行序列化（否则，只允许dict 实例）。
典型的用法如下：

>>> from django.http import JsonResponse
>>> response = JsonResponse({'foo': 'bar'})
>>> response.content
b'{"foo": "bar"}'
若要序列化非dict对象，必须设置safe参数为False：

>>> response = JsonResponse([1, 2, 3], safe=False)
如果不传递safe=False，将抛出一个TypeError。
如果你需要使用不同的JSON 编码器类，可以传递encoder参数给构造函数：
>>> response = JsonResponse(data, encoder=MyJSONEncoder)

六、StreamingHttpResponse类
StreamingHttpResponse类被用来从Django响应一个流式对象到浏览器。如果生成的响应太长或者是占用的内存较大，这么做可能更有效率。 例如，它对于生成大型的CSV文件非常有用。

StreamingHttpResponse不是HttpResponse的衍生类（子类），因为它实现了完全不同的应用程序接口。但是，除了几个明显不同的地方，两者几乎完全相同。

七、FileResponse
文件类型响应。通常用于给浏览器返回一个文件附件。

FileResponse是StreamingHttpResponse的衍生类，为二进制文件专门做了优化。

FileResponse需要通过二进制模式打开文件，如下:

>>> from django.http import FileResponse
>>> response = FileResponse(open('myfile.png', 'rb'))

"""

HttpResponse对象

三、自定义错误页面

当Django找不到与请求匹配的URL时，或者当抛出一个异常时，将调用一个错误处理视图。错误视图包括400、403、404和500，分别表示请求错误、拒绝服务、页面不存在和服务器错误。它们分别位于

handler400 —— django.conf.urls.handler400。
handler403 —— django.conf.urls.handler403。
handler404 —— django.conf.urls.handler404。
handler500 —— django.conf.urls.handler500。

这些值可以在根URLconf中设置。在其它app中的二级URLconf中设置这些变量无效。

Django有内置的HTML模版，用于返回错误页面给用户，但是这些403，404页面实在丑陋，通常我们都自定义错误页面。

#首先，在根URLconf中额外增加下面的条目：
from django.conf.urls import url
from django.conf.urls import include
from django.contrib import admin
from . import views
 
urlpatterns = [
    url(r'^admin/', admin.site.urls),
    url(r'^backend/',include('backend.urls')),
    url(r'^', include('web.urls')),
]
 
# 增加的条目
handler400 = views.bad_request
handler403 = views.permission_denied
handler404 = views.page_not_found
handler500 = views.page_error

#然后在，views.py文件中增加四个处理视图：
from django.shortcuts import render
def page_not_found(request):
    return render(request, '404.html')
 
 
def page_error(request):
    return render(request, '500.html')
 
 
def permission_denied(request):
    return render(request, '403.html')
 
 
def bad_request(request):
    return render(request, '400.html')

View Code

posted @ 2019-05-29 16:52 silencio。阅读(152) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

silencio

Django 视图层

Django的View（视图）

1 视图函数

2 HttpRequest对象

request属性

request常用方法

3 HttpResponse对象

render()

redirect()

4 JsonResponse

5 CBV和FBV

6 简单文件上传

CBV和FBV

FBV版：

CBV版：

给视图加装饰器

使用装饰器装饰FBV

使用装饰器装饰CBV

Request对象和Response对象

request对象

请求相关的常用值

属性

方法

Response对象

使用

属性

JsonResponse对象

Django shortcut functions

render()

redirect()

视图

一、HttpRequest对象

二、HttpResponse对象

三、自定义错误页面

公告