在使用三神装的时候，首先当然是得要导入它们：
from django.shortcuts import HttpResponse, render, redirect
 

一、HttpRequest捕获请求

捕获请求——HttpRequest对象

1、属性

HttpRequest.scheme  #一个字符串，表示请求的方案(通常是http或者https)
HttpRequest.body    #一个字节字符串，表示原始HTTP请求的正文
HttpRequest.path    #一个字符串，表示请求的页面的完整路径，不包含域名
HttpRequest.methed   #一个字符串，表示请求使用的HTTP方法，必须使用大写
HttpRequest.GET      #一个类似于字典的对象，包含HTTP GET的所有参数
HttpRequest.POST     #一个包含所有给定的HTTP POST参数的类字典对象，提供了包含表单数据的请求
HttpRequest.COOKIES    #一个标准的python字典，包含所有cookie，键和值都为字符串
HttpRequest.FILES     #一个类似于字典的对象，包含所有的上传文件
HttpRequest.META      #一个标准的python字典，包含所有的HTTP头部123456789

2、方法

HttpRequest.get_host()#返回请求的原始主机
HttpRequest.get_full_path()#返回path，如果可以将加上查询字符串
HttpRequest.read(size=None)
HttpRequest.readline()
HttpRequest.readlines()
HttpRequest.xreadlines()
HttpRequest.__iter__()
#这几个方法实现类文件的接口用于读取HttpRequest.示例。这使得可以用流的方式读#取进来的请求，一个常见的用例是使用迭代解析器处理大型XML有效载荷，
而不是内存#中构造一个完整的XML树。

3、详解

每当一个用户请求发送过来，Django将HTTP数据包中的相关内容，打包成为一个HttpRequest对象，并传递给每个视图函数作为第一位置参数，
也就是request，供我们调用，这一过程是系统自动完成的。
例如：前台请求数据包含username和password两个字段。例如网址http://127.0.0.1/xxxx/xxx?username=luanpeng&password=123
其中的xxx为网址映射，在urlsl路由映射部分再做详解。
 
# 接收请求数据返回字符串响应
def index(request):
    if request.method == “POST”:
        username = request.POST.get(“username”, None)   # 读取post数据，None为默认值
        password = request.POST.get(“password”, None)   # 读取post数据，None为默认值
    if request.method == “GET”:
        username = request.GET.get(“username”, None)   # 读取get数据
        password = request.GET.get(“password”, None)  # 读取get数据
    …123456789
在获取数据时，通常会提供一个默认值，防止请求数据中没有目标属性时触发KeyError异常。
不仅如此，HttpRequest对象中包含了非常多的重要的信息和数据，应该熟练掌握它。
1）HttpRequest属性
（1）、 HttpRequest.scheme
字符串类型，表示请求的协议种类，’http’或’https’。
（2）、 HttpRequest.body
bytes类型，表示原始HTTP请求的正文。它对于处理非HTML形式的数据非常有用：二进制图像、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()1234
通过这个属性来判断请求的方法，然后根据请求的方法不同，在视图中执行不同的代码。
（6）、HttpRequest.encoding
字符串类型，表示提交的数据的编码方式（如果为None 则表示使用DEFAULT_CHARSET设置）。 这个属性是可写的，可以通过修改它来改变表单数据的编码。任何随后的属性访问（例如GET或POST）将使用新的编码方式。
（7）、HttpRequest.content_type
Django1.10中新增。表示从CONTENT_TYPE头解析的请求的MIME类型。
（8）、HttpRequest.content_params
Django 1.10中新增。包含在CONTENT_TYPE标题中的键/值参数字典。
（9）、HttpRequest.GET
一个类似于字典的对象，包含GET请求中的所有参数。 详情参考QueryDict文档。
（10）、HttpRequest.POST
一个包含所有POST请求的参数，以及包含表单数据的字典。 详情请参考QueryDict文档。 如果需要访问请求中的原始或非表单数据，可以使用HttpRequest.body属性。
注意：请使用if request.method == “POST”来判断一个请求是否POST类型，而不要使用if request.POST。
POST中不包含上传文件的数据。
（11）、HttpRequest.COOKIES
包含所有Cookie信息的字典。 键和值都为字符串。可以类似字典类型的方式，在cookie中读写数据，但是注意cookie是不安全的，因此，不要写敏感重要的信息。
（12）、HttpRequest.FILES
一个类似于字典的对象，包含所有上传的文件数据。 FILES中的每个键为<input type=”file” name=”” />中的name属性值。 FILES中的每个值是一个UploadedFile。
要在Django中实现文件上传，就要靠这个属性！
如果请求方法是POST且请求的<form>中带有enctype=”multipart/form-data”属性，那么FILES将包含上传的文件的数据。 否则，FILES将为一个空的类似于字典的对象，属于被忽略、无用的情形。
下面为使用模型处理上传的文件的一个示例。
from django.http import HttpResponseRedirect
from django.shortcuts import render
from .forms import ModelFormWithFileField
def upload_file(request):
    if request.method == \’POST\’:
        form = ModelFormWithFileField(request.POST, request.FILES)
        if form.is_valid():
            # 这么做就可以了，文件会被保存到Model中upload_to参数指定的位置
            form.save()
            return HttpResponseRedirect(\’/success/url/\’)
    else:
        form = ModelFormWithFileField()
    return render(request, \’upload.html\’, {\’form\’: form})1234567891011121314
（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 —— 服务器的端口（字符串）。

2）HttpRequest方法
（1）、HttpRequest.get_host()[source]
据HTTP_X_FORWARDED_HOST和HTTP_HOST头部信息获取请求的原始主机。 如果这两个头部没有提供相应的值，则使用SERVER_NAME和SERVER_PORT。
例如：”127.0.0.1:8000”
注：当主机位于多个代理的后面，get_host()方法将会失败。解决办法之一是使用中间件重写代理的头部
（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实例读取文件数据的方法。
3）QueryDict对象
在应用中我们主要操作的就是GET和POST属性了。这里面包含了我们想要的数据。除了从QueryDict中获取数据，有时服务器还需要创建QueryDict对象发起向其他服务器的访问。
在HttpRequest对象中，GET和POST属性都是一个django.http.QueryDict的实例。也就是说你可以按本文下面提供的方法操作request.POST和request.GET。
3.1、QueryDict对象方法
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\’]}>12
（2） 、classmethod QueryDict.fromkeys(iterable, value=”, mutable=False, encoding=None)[source]
循环将可迭代对象中的每个元素作为键值，并赋予同样的值（来至value参数）。
QueryDict.fromkeys([\’a\’, \’a\’, \’b\’], value=\’val\’)
返回：QueryDict: {\’a\’: [\’val\’, \’val\’], \’b\’: [\’val\’]}>12
（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\’123456
（4）、QueryDict.items()
类似dict.items()，如果有重复项目，返回最近的一个，而不是都返回：
>>> q = QueryDict(\’a=1&a=2&a=3\’)
>>> q.items()
[(\’a\’, \’3\’)]123
（5）、 QueryDict.values()
类似dict.values()，但是只返回最近的值。 像这样：
>>> q = QueryDict(\’a=1&a=2&a=3\’)
>>> q.values()
[\’3\’]123
（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\’])]123
（13）、QueryDict.pop(key)[source]
返回给定键的值的列表，并从QueryDict中移除该键。 如果键不存在，将引发KeyError。 像这样：
>>> q = QueryDict(\’a=1&a=2&a=3\’, mutable=True)
>>> q.pop(\’a\’)
[\’1\’, \’2\’, \’3\’]123
（14）、QueryDict.popitem()[source]
删除QueryDict任意一个键，并返回二值元组，包含键和键的所有值的列表。在一个空的字典上调用时将引发KeyError。 像这样：
>>> q = QueryDict(\’a=1&a=2&a=3\’, mutable=True)
>>> q.popitem()
(\’a\’, [\’1\’, \’2\’, \’3\’])123
（15）、QueryDict.dict()
将QueryDict转换为Python的字典数据类型，并返回该字典。
如果出现重复的键，则将所有的值打包成一个列表，最为新字典中键的值。
>>> q = QueryDict(\’a=1&a=3&a=5\’)
>>> q.dict()
{\’a\’: \’5\’}123
（16）、QueryDict.urlencode(safe=None)[source]
已url的编码格式返回数据字符串。 像这样：
>>> q = QueryDict(\’a=2&b=3&b=5\’)
>>> q.urlencode()
\’a=2&b=3&b=5\’123
使用safe参数传递不需要编码的字符。 像这样：
>>> q = QueryDict(mutable=True)
>>> q[\’next\’] = \’/a&b/\’
>>> q.urlencode(safe=\’/\’)
\’next=/a%26b/\’
 

二、HttpResponseWeb响应

Web响应——HttpResponse

它是作用是内部传入一个字符串参数，然后发给浏览器。
例如：
def index(request):
    # 业务逻辑代码
    return HttpResponse(“OK”)
view视图函数返回给前端的是HttpResponse对象，HttpResponse类定义在django.http模块中。
HttpRequest对象由Django自动创建，而HttpResponse对象则由程序员手动创建.
我们编写的每个视图都要实例化、填充和返回一个HttpResponse对象。也就是函数的return值。数据表现有多种形式，可以是字符串、对象、网页。
HttpResponse属性

HttpResponse.content
响应的内容。bytes类型。
HttpResponse.charset
编码的字符集。 如果没指定，将会从content_type中解析出来。
HttpResponse.status_code
响应的状态码，比如200。
HttpResponse.reason_phrase
响应的HTTP原因短语。 使用标准原因短语。
除非明确设置，否则reason_phrase由status_code的值决定。
HttpResponse.streaming
这个属性的值总是False。由于这个属性的存在，使得中间件能够区别对待流式响应和常规响应。
HttpResponse.closed
如果响应已关闭，那么这个属性的值为True。


1、HttpResponse方法

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]
将一个包含行的列表写入响应对象中。 不添加分行符。
 

2.1 返回前台字符串

Django使用HttpResponse基类返回前端字符串。简单的返回如下
 
def test(request):
    …
    return HttpResponse(“接收数据成功”)   # 直接返回响应字符串123
当我们想以字符串的形式返回我们从数据查询到的数据集或数据对象时，可以使用序列化功能。
 
from django.core import serializers
jsonstr1 = serializers.serialize(“json”, dataset1)   # 将dataset转化为json字符串
return HttpResponse(jsonstr1 )1234
我们也可以直接返回html源代码的字符串形式，这样前端浏览器就会自动渲染成页面
 
html = “<html><body>It is now %s.</body></html>” % datetime.datetime.now()
return HttpResponse(html)12

2.2 返回前端字典

返回字典使用JsonResponse函数。
 
class JsonResponse（data，encoder = DjangoJSONEncoder，safe = True，json_dumps_params = None ，** kwargs）[source]1
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
from .models import User,Diary
from django.forms.models import model_to_dict
# 返回字典
def finduser(request):
    userid = request.POST.get(“userid”, None)  # 读取数据
    users = User.objects.filter(id=userid)  # 获取一个用户，返回QuerySet
    user = users[0]  # 获取第一个user对象
    user_dict1 = model_to_dict(user)  # 将对象转化为字典
    return JsonResponse(user_dict1)  # 返回前端字典1234567891011

2.3 返回数据流

StreamingHttpResponse类被用来从Django响应一个流式对象到浏览器。如果生成的响应太长或者是占用的内存较大，这么做可能更有效率。 例如，它对于生成大型的CSV文件非常有用。
StreamingHttpResponse不是HttpResponse的衍生类（子类），因为它实现了完全不同的应用程序接口。但是，除了几个明显不同的地方，两者几乎完全相同。

2.4 返回文件

文件类型响应。通常用于给浏览器返回一个文件附件。
FileResponse是StreamingHttpResponse的衍生类，为二进制文件专门做了优化。
FileResponse需要通过二进制模式打开文件，如下:
 
from django.http import FileResponse
response = FileResponse(open(\’myfile.png\’, \’rb\’))12

2.3 返回静态html页面

html文件被称为视图模板。如果需要返回html模板页面，首先我们需要有一个html文件。我们需要在功能模块app1文件夹下新建templates文件夹，用于存放html模板页面。
我们在templates文件夹下创建一个insert.html模板。代码如下
 
<!DOCTYPE html>
<html lang=”en”>
<head>
    <meta charset=”UTF-8″>
    <title>用户登录</title>
</head>
<body>
    <form action=”/app1/insert/” method=”post”>
        <input type=”text” name=”username”/>
        <input type=”password” name=”password”/>
        <input type=”submit” value=”提交”>
    </form>
</body>
</html>1234567891011121314
有了html文件，我们在views.py文件内新建一个insertuser视图函数，返回这个模板页面。
 
from django.shortcuts import render_to_response,redirect
from .models import User,Diary
import time

def insertuser(request):
    return render_to_response(\’insert.html\’)  # 返回文件响应1234567

  其实，python只是加载html文件，读取内容后，将内容返回给前台。所以是不是html格式并不重要。我们完全可以使用txt格式存储。在views.py文件的函数中加载txt文件。


2.4 动态生成html页面

上面的模板文件只是静态的html文件。在views视图函数中是不能动态修改的。如果我们想根据数据库查询结果动态的修改模板页面，形成新的页面再返回给前端怎么办？
我们把views中的函数用于逻辑处理，把处理结果交给html模板对象，来渲染成最终形成的html页面。这个过程我们称为渲染视图。
我们在templates文件夹新建另一个html文件为showuser.html。内容如下
 
<!DOCTYPE html>
<html lang=”en”>
<head>
    <meta charset=”UTF-8″>
    <title>Title</title>
</head>
<body>
    <h1>信息展示</h1>
    <table>
    <tr>
        <th>用户名</th>
        <th>密码</th>
    </tr>
    {% for line in people_list %}
    <tr>
        <td>{{line.username}}</td>
        <td>{{line.password}}</td>
    </tr>
    {% endfor %}
    </table>
</body>
</html>12345678910111213141516171819202122
我们可以看到在html文件的代码中包含了部分python代码。至于则个动态模板的书写规则以及如果使用view视图函数传递的数据的，
我们在另一篇文章templates模板中再详解。
不过这里我们需要知道在views视图函数中如何向模板传递数据。
我们在views.py中实现findalluser函数，代码如下：
 
from django.shortcuts import render_to_response
from .models import User,Diary
# findalluser将数据库内存储的数据读出并展示出来。
def findalluser(request):
    allpeople = User.objects.all()  # 查询所有用户
    dict={
        \’people_list\’:allpeople
    }
    return render_to_response(“showuser.html”,dict)  # 返回文件响应，第二个参数必须为字典12345678910
视图函数将数据库内存储的数据读出并结合html文件渲染出最后的响应html源代码。这和jsp中的原理相同，python先将html文件的内容全部加载到内存中，
再根据python的语法和传来的数据库数据生成html文件中python代码部分产生的文本，再将最终生成的html源代码返回到前端。
注意：在向模板传递参数时必须以字典的形式传递。

  渲染的模板视图生成的是html页面，只能在浏览器中打开。移动互联网下的移动设备端是无法处理的。所以传输字典对象的形式更为流行。
 

三、render

上面学习了很多返回数据类型。在实际运用中，加载模板、传递参数，返回HttpResponse对象是一整套再常用不过的操作了，为了节省力气，Django提供了一个快捷方式：render函数，一步到位！

render方法可接收三个参数，一是request参数，二是待渲染的html模板文件,三是保存具体数据的字典参数。
它的作用就是将数据填充进模板文件，最后把结果返回给浏览器。与jinja2类似。
    render(request, template_name, context=None, content_type=None, status=None, using=None)[source]
例如：
def index(request):
    # 业务逻辑代码
    return render(request, “index.html”, {“name”: “monicx”, “hobby”: [“reading”, “blog”]})
结合一个给定的模板和一个给定的上下文字典，返回一个渲染后的HttpResponse对象。
必需参数：

request：视图函数处理的当前请求，封装了请求头的所有数据，其实就是视图参数request。
template_name：要使用的模板的完整名称或者模板名称的列表。如果是一个列表，将使用其中能够查找到的第一个模板。

可选参数：

context：添加到模板上下文的一个数据字典。默认是一个空字典。可以将认可需要提供给模板的数据以字典的格式添加进去。这里有个小技巧，使用Python内置的locals()方法，可以方便的将函数作用于内的所有变量一次性添加。
content_type：用于生成的文档的MIME类型。 默认为DEFAULT_CONTENT_TYPE设置的值。
status：响应的状态代码。 默认为200。
using：用于加载模板使用的模板引擎的NAME。

使用render可以同时处理请求对象request、html模板、数据库数据。在Django中可以调用render函数，也可以在模板对象上调用render函数。
1、调用全局render函数。看如下代码：
 
from django.shortcuts import render
from .models import User,Diary
# findalluser将数据库内存储的数据读出并展示出来。
def findalluser(request):
    allpeople = User.objects.all()  # 查询所有用户
    dict={
        \’people_list\’:allpeople
    }
    return render(request,\’showuser.html\’,dict)12345678910
render()函数的第一个位置参数是请求对象（就是view函数的第一个参数），第二个位置参数是模板。还可以有一个可选的第三参数，一个字典，包含需要传递给模板的数据。最后render函数返回一个经过字典数据渲染过的模板封装而成的HttpResponse对象。
2、在template模板对象上调用render函数。如下示例
 
from django.shortcuts import render,HttpResponse
def findalluser(request):
    allpeople = models.User.objects.all()  # 查询所有用户
    dict={
        \’people_list\’:allpeople
    }
    template = loader.get_template(\’showuser.html\’)  # 加载模板对象
    return HttpResponse(template.render(dict1, request))  # 渲染视图
 

四、redirect重定向

接受一个URL参数，表示让浏览器跳转去指定的URL.
例如：
def index(request):
    # 业务逻辑代码
    return redirect(“https://blog.csdn.net/miaoqinian”)

版权声明：本文为xibuhaohao原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/xibuhaohao/p/10192351.html