Python自动化开发学习21-Django

阅读量：6857 次

发布时间：2019-06-26

本文共 21077 字，大约阅读时间需要 70 分钟。

补充知识-路由系统（URL）

URL传递额外的参数

在url.py里，除了默认会传一个request给处理函数，还可以传递额外的参数，把一个字典作为第三个参数传入，之后就可以在处理函数里取到对应的值：

from django.urls import pathfrom app01 import viewsurlpatterns = [    path('extra-options/', views.extra_options, {'foo': 'bar'}),]

处理函数views.py

from django.shortcuts import HttpResponsedef extra_options(request, foo):    return HttpResponse(foo)

对于include()的情况，可以写在最外层，也可以在里层分别写一个：

# main.pyfrom django.urls import include, pathurlpatterns = [    path('blog/', include('inner'), {'blog_id': 3}),]# inner.pyfrom django.urls import pathfrom mysite import viewsurlpatterns = [    path('archive/', views.archive),    path('about/', views.about),]

这个的效果和上面的一样：

# main.pyfrom django.urls import include, pathurlpatterns = [    path('blog/', include('inner')),]# inner.pyfrom django.urls import pathfrom mysite import viewsurlpatterns = [    path('archive/', views.archive, {'blog_id': 3}),    path('about/', views.about, {'blog_id': 3}),]

命名空间

做路由分发的时候，可以把两条路由指向同一个app，像这样：

# urls.pyfrom django.urls import path, includeurlpatterns = [    path('author-app01/', include('app01.urls', namespace='author-app01')),    path('publisher-app01/', include('app01.urls', namespace='publisher-app01')),]# app01\urls.pyfrom django.urls import pathfrom app01 import viewsapp_name = 'app01'urlpatterns =[    path('view/', views.view, name='view'),    path('template/', views.template, name='template'),]

这里的 include() 里多了一个参数 namespace 。现在 http://127.0.0.1:8000/author-app01/view/ 和 http://127.0.0.1:8000/publisher-app01/view/ 访问的是同一个页面，我们需要根据 namespace 区分这个请求具体是通过那个路由发过来的。下面是在处理函数 views.py 以及html页面文件 template.html 获取到路由的方法：

def view(request):    v = reverse('app01:view')  # 这个v就是请求的路由    return HttpResponse(v)def template(request):    # 返回一个页面，在页面里通过模板语言获取到路由信息    return render(request, 'template.html')

template.html


    
     {% url 'app01:template' %}

知识点就是这样，没讲应用场景

补充知识-视图（View）

视图里还有一个装饰器，应用场景比如是用户认证，某些页面一定要用户登录成功后才能访问。这部分内容会在将cookie和session的时候再学习。

请求的其他信息

用户发来请求的时候，不仅有数据，还有请求头。比如调出控制台可以有下面这些信息。这些信息也都是客户端发出来的。

所有的信息都封装在了request这个对象里，现在就把他们找出来。先用下面的处理函数打印出request这个对象：

def get_request(request):    print(type(request))    return HttpResponse("OK")

打印出来的结果如下，可以看到这个确实是个类。

现在就去看看这个类的源码，是一个wsgi.py里的类，类名是WSGIRequest。可以用PyCharm方便的找到这个文件并且定位到这个类。像下面这样先导入这个模块，按住Shift点击WSGIRequest，就可以跳转过去。

# 打印结果：django.core.handlers.wsgi.WSGIRequestfrom django.core.handlers.wsgi import WSGIRequestdef get_request(request):    print(type(request))    return HttpResponse("OK")

部分源码，只有开头的构造函数：

class WSGIRequest(HttpRequest):    def __init__(self, environ):        script_name = get_script_name(environ)        path_info = get_path_info(environ)        if not path_info:            # Sometimes PATH_INFO exists, but is empty (e.g. accessing            # the SCRIPT_NAME URL without a trailing slash). We really need to            # operate as if they'd requested '/'. Not amazingly nice to force            # the path like this, but should be harmless.            path_info = '/'        self.environ = environ        self.path_info = path_info        # be careful to only replace the first slash in the path because of        # http://test/something and http://test//something being different as        # stated in http://www.ietf.org/rfc/rfc2396.txt        self.path = '%s/%s' % (script_name.rstrip('/'),                               path_info.replace('/', '', 1))        self.META = environ        self.META['PATH_INFO'] = path_info        self.META['SCRIPT_NAME'] = script_name        self.method = environ['REQUEST_METHOD'].upper()        self.content_type, self.content_params = cgi.parse_header(environ.get('CONTENT_TYPE', ''))        if 'charset' in self.content_params:            try:                codecs.lookup(self.content_params['charset'])            except LookupError:                pass            else:                self.encoding = self.content_params['charset']        self._post_parse_error = False        try:            content_length = int(environ.get('CONTENT_LENGTH'))        except (ValueError, TypeError):            content_length = 0        self._stream = LimitedStream(self.environ['wsgi.input'], content_length)        self._read_started = False        self.resolver_match = None

构造函数里传入了一个environ参数，信息都在这个里面。构造函数里有一句 self.environ = environ 。所以这个值也传到实例化的对象里了，用下面的方法可以打印出来看看：

# 打印结果：django.core.handlers.wsgi.WSGIRequestfrom django.core.handlers.wsgi import WSGIRequestdef get_request(request):    # print(type(request))    # print(request.environ)    for k, v in request.environ.items():        print("%s: %s" % (k, v))    return HttpResponse("OK")

这里封装了所有的用户请求信息，都是原生的数据。其中一部分常用的，Django已经帮我们处理好了，比如下面的3个：

request.POST

request.GET

request.COOKIES

剩下的如果要用就要自己提取处理了。比如打印出的结构中有一条是显示用户访问使用的终端的信息的：

HTTP_USER_AGENT: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.36 Edge/16.16299

通过这个信息可以知道用户是用什么终端发来的请求，可以知道用户用的是iPhong还是用安卓系统。还可以判断用户是手机端就发回给一个手机端的页面。如果是PC端就返回一个PC端的页面。这是一个字典，用 request.environ['HTTP_USER_AGENT'] 就可以获取到这个信息了。

补充知识-模板（Templates ）

模板的继承-extends

首先先写一个完整的html页面，master.html：

    
        Title        {% block css %} {% endblock %}
    
        
             
          
     
    {% block content %}    
             
          
     
    {% endblock %}
    
{% block js %} {% endblock %}

也面里加了几个模板语言的block标签，这个并比影响这个页面的访问。去写好对应关系和处理函数后这个页面就能正常访问了。

现在又有另外几个页面，页面的头部以及左侧菜单都是一样的，就不需要每个页面都写了。可以继承这个页面仅仅替换掉需要替换的部分，也就是content的内容。这里已经把content的内容用 {% block content %} {% endblock %} 包起来了。

新的页面tpl1.html，首先要声明继承哪个页面，然后把要替换的内容用相同名字的block标签包起来：

{#声明继承一个页面#}{% extends 'master.html' %}{#追加css的内容#}{% block css %}    {% endblock %}{#替换掉content的内容#}{% block content %}    
            
     替换掉原来的内容    
    
{% endblock %}{#追加js的内容#}{% block js %}    {% endblock %}

如上面的例子中那样，把需要替换的一个或多个部分用block包起来。

注意css（style标签）和js（script标签），一般也都会需要追加css样式和js。css就接在模板的css后面写，js就还是写在最后的位置，如果有jQuery，必须要在导入jQuery静态文件的后面。

只能继承一个模板，不能继承多个。

模板的导入-include

这次写一个组件的html代码tag.html，比如这样：

这是一个小组件
没有什么内容

然后在去写完成的页面，在页面里用模板语言的include标签导入这个组件：

    
        Title{% include 'tag.html' %}{% include 'tag.html' %}{% include 'tag.html' %}

上面的例子中看到了，模板的导入可以导入多次的。实际的应用中可能会结合模板语言的for循环，每条数据都通过这个组件渲染然后输出到页面。

内置函数

在页面里使用双大括号 {

{ value }} 取值的时候，还可以加上管道符，对结果进行处理后在输出。

比如输出一个日期，首先得先有一个日期对象输出到页面：

def get_data(request):    import datetime    now = datetime.datetime.now()    print(now)    return render(request, 'get-data.html', {'now': now})

然后页面里使用模板语言可以对日期的格式进行设置：

默认的日期格式：{
   { now }}
模板语句加工后：{
   { now|date:"Y-m-d H:i:s" }}

其他的方法还有

{ 
     { str|truncatechars:'10' }}

：只输出10个字符，实际是只截取了前面7个字符，之后跟3个点（...）

使用内置函数不是重点，重点是可以自定义函数

自定义函数

要自定义函数，按照下面的步骤操作：

在APP下，创建templatetags目录，目录名字很重要不能错。

创建任意 .py 文件，这里文件名随意，比如：myfun.py。

文件里创建一个template.Library()对象，名字是register。这里的对象名字必须是register。

然后写自己的函数，但是都用@register.simple_tag这个装饰器装饰好：

from django import templateregister = template.Library()@register.simple_tagdef my_fun1(a1, a2, a3):    return "%s-%s-%s" % (a1, a2, a3)@register.simple_tagdef my_fun2():    return "my_fun2"

页面文件中加载你的文件{% load myfun %}。放在顶部就好了。只要在你使用前加载加可以，不一定要在上面。如果有extends（{% extends 'master.html' %}），放在extends的下面。

使用你的函数 {% 函数名参数1 参数2 %}

{% load myfun %}{% my_fun1 'A' 'B' 'C' %}
{% my_fun2 %}

上面的是simple_tag，使用装饰器 @register.simple_tag

还有一种filter，只要换成这个装饰器 @register.filter

from django import templateregister = template.Library()@register.simple_tagdef my_fun3(arg1, arg2):    return "%s: %s" % (arg1, arg2)@register.filterdef my_fun4(arg1, arg2):    return "%s: %s" % (arg1, arg2)

之后在页面里使用的时候，传参的方式也是不同的，并且filter最多只能传入2个参数，并且中间连空格都不能有：

{% my_fun3 'abc' '123' %}
{
   { 'abc'|my_fun4:'123' }}

如果一定要用filter，并且还要传入多个参数，只能自己处理了，比如 {

{ 'abc'|my_fun4:'123,456,789' }} 这样还是传2个参数，在我们自己的函数里做分割处理。

只传入一个参数也是可以的，第二个不写就好了。但是不能没参数。像

{ 
     { my_fun }}

这样的用法是获取通过 return render() 给的字典里查找这个key来获取值。

单独使用，明显是simple_tag更方便，参数没有限制。

但是filter能够作为if的条件：

{% if 'abc'|my_fun4:'123' == 'abc: 123' %}    filter能够作为if的条件
{% endif %}

上面传参都是加了引号，表示传入的是字符串。不加引号，就是直接传入数字，类型是int。

也可以传入变量或者嵌套使用，比如处理函数最后这样返回 return render(request, 'my-fun.html', {'str': "987"})

{
   { 'abc'|my_fun4:'def'|my_fun4:'456' }}
{
   { 'xyz'|my_fun4:str }}

示例-分页

先把页面搞出来，比如要显示100条数据，现在是一次全部显示出来。

处理函数，views.py

LIST = range(100)  # 测试数据就不走数据库了def show_list(request):    return render(request, 'show-list.html', {'li': li})

页面，show-list.html


    
         {% for item in li %}        
     {
   { item }}
    {% endfor %}

把分页的效果弄出来，修改处理函数，一次只返回页面10条数据，通过get请求返回对应的页数，默认返回第一页。

LIST = range(100)  # 测试数据就不走数据库了def show_list(request):    current_page = request.GET.get('p', 1)  # 设一个默认值，如果不提交p，默认就是1    current_page = int(current_page)  # 通过get获取到的是字符串，转成数字    start = (current_page-1)*10    end = current_page*10    li = LIST[start:end]    page_str = """    1    2    3    4    5    """    # from django.utils.safestring import mark_safe    # page_str = mark_safe(page_str)    return render(request, 'show-list.html', {'li': li, 'page_str': page_str})

页面也加上选择页数的a连接的内容：


    
         {% for item in li %}        
     {
   { item }}
    {% endfor %}
    
{
   { page_str }}{#{
   { page_str|safe }}#}

这里是有问题的，这里的a连接的html代码是处理函数传过来了，之后在页面里再用模板语言把内容加载进来。这里会有个XSS***的问题。

XSS***，大致就是你提供一个输入框给用户输入内容，然后可以把用户输入的内容在页面中显示出来，比如说论坛、评论。那么用户可以在这里输入源码，比如js脚本，然后你的后台直接不做处理就把代码返回给前端，那么前端就可能执行这段代码了。

所以默认模板语言认为加载的内容都是不安全的，所以都作为字符串加载。有2中方法可以声明这段内容是安全的，那么就能正常的在前端按照我们写的标签的样子展示出来。

方法一：在处理函数里使用 mark_safe(page_str) 来转一下，使用前先导入模块 from django.utils.safestring import mark_safe

方法二：在前端的模板语言里，在字符串后面使用管道符调用一个内置的filter方法，{
{ page_str|safe }}

两种方法可以任选一种使用，在例子里都注释掉了，现在可以放开其中一种方法。两个方法一起用试下来也不会报错

根据数据的数量，自动计算一共有多少页，

from django.utils.safestring import mark_safeLIST = range(100)  # 测试数据就不走数据库了def show_list(request):    current_page = request.GET.get('p', 1)  # 设一个默认值，如果不提交p，默认就是1    current_page = int(current_page)  # 通过get获取到的是字符串，转成数字    start = (current_page-1)*10    end = current_page*10    li = LIST[start:end]    count, remainder = divmod(len(LIST), 10)  # 取除后的整数和余数    count = count+1 if remainder else count  # 如果除后有余数，结果就加一    page_list = []    for i in range(1, count+1):        page_list.append("%s" % (i, i))    page_str = ''.join(page_list)    page_str = mark_safe(page_str)    return render(request, 'show-list.html', {'li': li, 'page_str': page_str})

如果不是100条数据，而是1000条甚至更多，那么下面的页码也会很多。实际应用中，一般值显示当前页以及前面后后面多少页，而不是所有的页码。简单优化一下：

from django.utils.safestring import mark_safeLIST = range(1100)  # 测试数据就不走数据库了def show_list(request):    current_page = request.GET.get('p', 1)  # 设一个默认值，如果不提交p，默认就是1    current_page = int(current_page)  # 通过get获取到的是字符串，转成数字    per_page_count = 15  # 每页显示多少条记录，也是可以设置成通过get来提交的    start = (current_page-1)*per_page_count    end = current_page*per_page_count    li = LIST[start:end]     count, remainder = divmod(len(LIST), per_page_count)  # 取除后的整数和余数    count = count+1 if remainder else count  # 如果除后有余数，结果就加一    start_index = 1 if current_page < 6 else current_page-5    end_index = count if current_page+5 > count else current_page+5    page_list = []    for i in range(start_index, end_index+1):        page_list.append("%s" % (i, i))    page_str = ''.join(page_list)    page_str = mark_safe(page_str)    return render(request, 'show-list.html', {'li': li, 'page_str': page_str})

另外上面还把每页显示多少条记录也作为一个变量，并且可以通过get请求提交。

这里固定显示11页，这个也可以作为一个标量，不写死，方便调整

还可以进一步优化，比如前面加一个上一页，后面加一个下一页，还要直接去第一页和最后一页。还可以搞个input框，直接输入页码，跳转的那一页。

下面是部分优化的版本，有上一页和下一页，固定显示11页（可用变量调整）内容：

from django.utils.safestring import mark_safeLIST = range(1000)  # 测试数据就不走数据库了def show_list(request):    current_page = request.GET.get('p', 1)  # 设一个默认值，如果不提交p，默认就是1    current_page = int(current_page)  # 通过get获取到的是字符串，转成数字    per_page_count = 15  # 每页显示多少条记录，也是可以设置成通过get来提交的    page_num = 11  # 每页显示11条记录，可修改    page_num_before = (page_num-1)//2  # 算出来前面放几页    page_num_after = page_num-1-page_num_before  # 后面放几页    start = (current_page-1)*per_page_count    end = current_page*per_page_count    li = LIST[start:end]    count, remainder = divmod(len(LIST), per_page_count)  # 取除后的整数和余数    count = count+1 if remainder else count  # 如果除后有余数，结果就加一    if count <= page_num: page_num = count    if current_page <= page_num_before:        start_index, end_index = 1, page_num    elif current_page + page_num_after >= count:        start_index, end_index = count-page_num+1, count    else:        start_index = current_page - page_num_before        end_index = start_index + page_num - 1    page_list = list()    if current_page == 1:        page_list.append("上一页")    else:        page_list.append("上一页" % (current_page-1))    for i in range(start_index, end_index+1):        page_list.append("%s" % (i, i))    if current_page == count:        page_list.append("下一页")    else:        page_list.append("下一页" % (current_page+1))    page_str = ''.join(page_list)    page_str = mark_safe(page_str)    return render(request, 'show-list.html', {'li': li, 'page_str': page_str})

自定义功能模块

上面的分页功能代码比较多（还可以继续优化），而且别的页面里也会需要用到分页的功能。把分页的功能单独提取出来，封装到一个单独的类里，做成一个功能模块。这种功能模块也集中存放在一个文件夹里，在项目目录下创建utils文件夹，再创建一个py文件pagination.py作为模块。要用的时候，处理函数里只需要实例化这个类，调用类中的方法就可以了：

# 功能模块 utils/pagination.py 中的内容from django.utils.safestring import mark_safeclass Page:    def __init__(self, current_page, data_count, per_page_count=10, page_num=11):        self.current_page = current_page        self.data_count = data_count        self.per_page_count = per_page_count        self.page_num = self.total_count if self.total_count <= page_num else page_num        self.page_num_before = (self.page_num-1)//2        self.page_num_after = self.page_num - 1 - self.page_num_before    @property    def start(self):        return (self.current_page-1) * self.per_page_count    @property    def end(self):        return self.current_page * self.per_page_count    @property    def total_count(self):        count, remainder = divmod(self.data_count, self.per_page_count)        return count + 1 if remainder else count    def page_str(self, base_url):        if self.current_page <= self.page_num_before:            start_index, end_index = 1, self.page_num        elif self.current_page + self.page_num_after >= self.total_count:            start_index, end_index = self.total_count - self.page_num + 1, self.total_count        else:            start_index = self.current_page - self.page_num_before            end_index = start_index + self.page_num - 1        page_list = list()        if self.current_page == 1:            page_list.append("上一页")        else:            page_list.append("上一页" % (base_url, self.current_page-1))        for i in range(start_index, end_index+1):            page_list.append("%s" % (base_url, i, i))        if self.current_page == self.total_count:            page_list.append("下一页")        else:            page_list.append("下一页" % (base_url, self.current_page+1))        page_str = ''.join(page_list)        return mark_safe(page_str)# 处理函数 views.py 中的内容LIST = range(1000)  # 测试数据就不走数据库了from utils import paginationdef show_list(request):    current_page = request.GET.get('p', 1)  # 设一个默认值，如果不提交p，默认就是1    current_page = int(current_page)  # 通过get获取到的是字符串，转成数字    page_obj = pagination.Page(current_page, len(LIST))    li = LIST[page_obj.start:page_obj.end]    page_str = page_obj.page_str('/show-list/')    return render(request, 'show-list.html', {'li': li, 'page_str': page_str})

Cookie

Cookie是存放在客户端浏览器上的，以key, value 的形式保存

示例-登录

这个例子中，先通过登录页面将登录成功的用户名发送给客户端保存到cookie中。然后在欢迎页面请求客户的的cookie拿到客户端登录成功的用户名。

先把如下的2个页面做出来，login登录页面，登录成功后跳转到welcome。这次如果未登录成功想要直接访问welcome是不可以的，会跳转到login页面，要求登录。

path('login/', views.login),    path('welcome/', views.welcome),

页面简单一点


    
        
     
    
     
    
     
    
    Welcome, {
   { username }}

处理函数：

# 测试数据不走数据库了user_info = {    'user': {'password': 'user123'},    'test': {'password': 'test123'},}def login(request):    if request.method == 'GET':        return render(request, 'login.html')    if request.method == 'POST':        usr = request.POST.get('username')        pwd = request.POST.get('password')        dic = user_info.get(usr)        if not dic:            return render(request, 'login.html', {'error_msg': "用户不存在"})        if dic['password'] == pwd:            # return redirect('/welcome/')            # 先不返回对象，把对象拿到，加上cookie的内容之后再返回给客户端            res = redirect('/welcome/')  # 这个是原本返回给客户端对对象            res.set_cookie('username', usr)  # 给返回的对象加上cookie的内容            return res        else:            return render(request, 'login.html', {'error_msg': "用户名或密码错误"})def welcome(request):    print(type(request.COOKIES), request.COOKIES)  # 这就是一个字典    user = request.COOKIES.get('username')  # 这步是像客户端发请求，要求获取这个值    if not user:        return redirect('/login/')    return render(request, 'welcome.html', {'username': user})

尝试直接访问welcome，还是会跳转到login。只有登录成功后才会显示欢迎页面。这里的用户名是向客户端的浏览器请求获取到的。可以打开浏览器的F12开发人员工具在网络里查看到：

Cookie的语法

获取Cookie

request.COOKIES.get('key') 或 request.COOKIES['key'] ：这就是个字典，获取值使用字典的操作

设置Cookie

设置就是在把对象返回给客户端之前，先拿到这个对象：rep = render(request, ...) 或 rep = return HttpResponse(...) ，

拿到之后设置：rep.set_cookie(key,value) 参数不止这两个，所有参数如下：

key ：键

value='' ：值

max_age=None ：超时时间，单位是秒。不设置就是浏览器关闭就马上失效

expires=None ：超时时间节点，设置一个具体的日期。rep.set_cookie(key, value, expires=datetime.datetime.strptime('2018-4-11 11:23:00', '%Y-%m-%d %H:%M:%S')) ，记得先 import datetime 模块

path='/' ：Cookie生效的路径，/ 表示根路径，根路径的cookie可以被任何url的页面访问

domain=None ：Cookie生效的域名

secure=False ：https传输，如果网站是https的，写cookie的时候把这个参数设置为True

httponly=Fals ：只能http协议传输，无法被JavaScript获取（不是绝对，底层抓包可以获取到也可以被覆盖）。document.cookie 获取不到设置了这个参数的cookie。

如果要注销，清除cookie，那么就 rep.set_cookie(key) ，给你的key设置个空值，并且超时时间设置为马上失效。

客户端操作Cookie

document.cookie ：获取到cookie，返回的是字符串 "key1=value1; key2=value2"

document.cookie = "key=value;" ：添加一个cookie的键值，其他参数也能加，不过说是很麻烦，就没讲。

jQuery有一个插件，叫jQuery.cookie，可以方便的操作cookie。要使用就先去把js文件加载到你的页面：

$.cookie(key) ：获取值

$.cookie(key, vaule) ：设置值

$.cookie(key, vaule, {options}) ：其他参数都以字典的形式写在第三个参数里

分页-定制每页显示的数量

利用cookie，在上前面的分页的例子的基础上，增加一个功能，用户可以定制每页显示多少条数据。Web界面上值需要追加一个select框，然后绑定事件：

上面给select框绑定了一个事件，当选项改变时，会获取当前select的值，然后将这个值传给cookie。这里限定了生效的路径，只有这个页面按这个cookie的值显示数据的数量，如果还有别的页面取不到这个值。貌似没什么卵用，别的页面如果有同样需求，再开一个cookie的key记录就好了，而且你加了不同的path参数，修改的应该还是用个key的内容

上面还有一段当页面加载完成后要执行的代码，没有这个会有点小问题，就是你的select选项永远是10，但是你的页面设置中cookie里取到的可能是20。就是select选项没有同步，并且会造成你无法把显示数量设置成10。

接下来去处理函数出稍加修改：

def show_list(request):def show_list(request):    # 增加内容：获取cookie的值    per_page_count = request.COOKIES.get('per_page_count', '10')  # 获取cookie的值    per_page_count = int(per_page_count)  # 获取到的永远是字符串，转为整数    # print(type(per_page_count), per_page_count)    current_page = request.GET.get('p', 1)    current_page = int(current_page)    # 实例化类的时候传入获取的值    page_obj = pagination.Page(current_page, len(LIST), per_page_count)    li = LIST[page_obj.start:page_obj.end]    page_str = page_obj.page_str('/show-list/')    return render(request, 'show-list.html', {'li': li, 'page_str': page_str})

用下来发现还有点用户体验的小问题，这个得去修改类了，不过这不是重点。重点就是学习掌握cookie的操作。

加密的Cookie

就是带签名的cookie。之前使用的cookie都是明文保存在客户端的，还可以对cookie加密。

request.get_signed_cookie(key, default=RAISE_ERROR, salt='', max_age=None) ：获取加密cookie，max_age是后台控制过期时间

rep.set_signed_cookie(key, value, salt='', **kwargs) ：设置加密cookie

用的时候基本就是换个方法的名字，参数里多加一个salt的关键参数。

装饰器

上面登录的例子中已经完成了登录验证的功能。实际应用中，很多页面都需要登录验证，这就需要把验证的功能独立出来并且做成装饰器。之后只要把其它处理函数装饰上即可。

FBV的装饰器

上面登录例子中的welcome函数自带了登录验证。现在welcome函数只需要完成显示页面的功能，验证的功能交给装饰器：

def auth(func):    def inner(request, *args, **kwargs):        # 装饰的内容，验证用户是否已经登录        user = request.COOKIES.get('username')        if not user:            return redirect('/login/')        # 装饰的内容结束，下面调用执行被装饰的函数        return func(request, *args, **kwargs)    return inner@authdef welcome(request):    # 下面就是原来验证的功能了，现在交给装饰器    # user = request.COOKIES.get('username')    # if not user:    #     return redirect('/login/')    # 虽然装饰器登录验证的时候已经获取到user的值了，可以传过来    # 这里不考虑装饰器，自己独立的完成处理函数的功能：获取user，在页面显示出来    user = request.COOKIES.get('username')    return render(request, 'welcome.html', {'username': user})

CBV的装饰器

CBV的装饰器有2中情况。一种是只装饰一个或部分方法，一种是装饰整个类中的方法。装饰器还是上面的装饰器。

单独装饰一个方法

from django import viewsfrom django.utils.decorators import method_decoratorclass Order(views.View):    @method_decorator(auth)    def get(self, request):        user = request.COOKIES.get('username')        return render(request, 'welcome.html', {'username': user})    def post(self, request):        pass

装饰类中的所有方法

这里利用dispatch方法是在执行其他方法前执行。我们装饰了dispatch方法，就阿是装饰了其他方法

from django import viewsfrom django.utils.decorators import method_decoratorclass Order(views.View):    @method_decorator(auth)    def dispatch(self, request, *args, **kwargs):        """简单的继承并重构这个方法，然后什么都不改变，就为了加上装饰器"""        return super(Order, self).dispatch(request, *args, **kwargs)    def get(self, request):        user = request.COOKIES.get('username')        return render(request, 'welcome.html', {'username': user})    def post(self, request):        pass

装饰整个类

装饰的还是dispatch方法，把装饰器写在类上面

from django import viewsfrom django.utils.decorators import method_decorator@method_decorator(auth, name='dispatch')class Order(views.View):    def get(self, request):        user = request.COOKIES.get('username')        return render(request, 'welcome.html', {'username': user})    def post(self, request):        pass

转载于:https://blog.51cto.com/steed/2095278

你可能感兴趣的文章

【linux】ubuntu11.10下各种问题以及解决方案

Docker学习笔记二：Docker常用命令及提升拉取镜像的速度

查看>>

Python操作Oracle

查看>>