补充知识-路由系统(URL)

URL传递额外的参数

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

from django.urls import path
from app01 import views

urlpatterns = [
    path('extra-options/', views.extra_options, {'foo': 'bar'}),
]

处理函数views.py

from django.shortcuts import HttpResponse

def extra_options(request, foo):
    return HttpResponse(foo)

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

# main.py
from django.urls import include, path

urlpatterns = [
    path('blog/', include('inner'), {'blog_id': 3}),
]

# inner.py
from django.urls import path
from mysite import views

urlpatterns = [
    path('archive/', views.archive),
    path('about/', views.about),
]

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

# main.py
from django.urls import include, path

urlpatterns = [
    path('blog/', include('inner')),
]

# inner.py
from django.urls import path
from mysite import views

urlpatterns = [
    path('archive/', views.archive, {'blog_id': 3}),
    path('about/', views.about, {'blog_id': 3}),
]

命名空间

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

# urls.py
from django.urls import path, include

urlpatterns = [
    path('author-app01/', include('app01.urls', namespace='author-app01')),
    path('publisher-app01/', include('app01.urls', namespace='publisher-app01')),
]

# app01\urls.py
from django.urls import path
from app01 import views

app_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

<div>{% url 'app01:template' %}</div>

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

补充知识-视图(View)

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

请求的其他信息

用户发来请求的时候,不仅有数据,还有请求头。比如调出控制台可以有下面这些信息。这些信息也都是客户端发出来的。
Python自动化开发学习21-Django

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

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

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

<class 'django.core.handlers.wsgi.WSGIRequest'>

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

# 打印结果:django.core.handlers.wsgi.WSGIRequest
from django.core.handlers.wsgi import WSGIRequest
def 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.WSGIRequest
from django.core.handlers.wsgi import WSGIRequest
def 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:

<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <style>
        body{
            margin: 0;
        }
        .pg-header{
            height: 48px;
            background-color: red;
        }
        .pg-content .menu{
            position: absolute;
            top: 48px;
            left: 0;
            width: 200px;
            background-color: blue;
            color: white;
        }
        .pg-content .content{
            position: absolute;
            top: 48px;
            right: 0;
            left: 200px;
            background-color: yellow;
            /*overflow: auto;*/
            /*bottom: 0;*/
        }
    </style>
    {% block css %} {% endblock %}
</head>
<body>
<div class="pg-header"></div>
<div class="pg-content">
    <div class="menu">
        <script>
            for (var i=0; i<10; i++){
                document.writeln("<p>菜单</p>")
            }
        </script>
    </div>
    {% block content %}
    <div class="content">
        <script>
            for (var i=0; i<100; i++){
                document.writeln("<p>test</p>")
            }
        </script>
    </div>
    {% endblock %}
</div>
{% block js %} {% endblock %}
</body>

也面里加了几个模板语言的block标签,这个并比影响这个页面的访问。去写好对应关系和处理函数后这个页面就能正常访问了。
现在又有另外几个页面,页面的头部以及左侧菜单都是一样的,就不需要每个页面都写了。可以继承这个页面仅仅替换掉需要替换的部分,也就是content的内容。这里已经把content的内容用 {% block content %} {% endblock %} 包起来了。
新的页面tpl1.html,首先要声明继承哪个页面,然后把要替换的内容用相同名字的block标签包起来:

{#声明继承一个页面#}
{% extends 'master.html' %}

{#追加css的内容#}
{% block css %}
    <style>
        .pg-content .tpl1{
            position: absolute;
            top: 48px;
            right: 0;
            left: 200px;
            background-color: brown;
            color: white;
        }
    </style>
{% endblock %}

{#替换掉content的内容#}
{% block content %}
    <div class="tpl1">
        <span>替换掉原来的内容</span>
    </div>
{% endblock %}

{#追加js的内容#}
{% block js %}
    <script>
        alert('测试js')
    </script>
{% endblock %}

如上面的例子中那样,把需要替换的一个或多个部分用block包起来。
注意css(style标签)和js(script标签),一般也都会需要追加css样式和js。css就接在模板的css后面写,js就还是写在最后的位置,如果有jQuery,必须要在导入jQuery静态文件的后面。
只能继承一个模板,不能继承多个。

模板的导入-include

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

<h1>这是一个小组件</h1>
<h2>没有什么内容</h2>

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

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
{% include 'tag.html' %}
{% include 'tag.html' %}
{% include 'tag.html' %}
</body>
</html>

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

内置函数

在页面里使用双大括号 {{ value }} 取值的时候,还可以加上管道符,对结果进行处理后在输出。
比如输出一个日期,首先得先有一个日期对象输出到页面:

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

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

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

其他的方法还有
{{ str|truncatechars:'10' }} :只输出10个字符,实际是只截取了前面7个字符,之后跟3个点(...)
使用内置函数不是重点,重点是可以自定义函数

自定义函数

要自定义函数,按照下面的步骤操作:

  1. 在APP下,创建templatetags目录,目录名字很重要不能错。
  2. 创建任意 .py 文件,这里文件名随意,比如:myfun.py。
  3. 文件里创建一个template.Library()对象,名字是register。这里的对象名字必须是register。
  4. 然后写自己的函数,但是都用@register.simple_tag这个装饰器装饰好:
from django import template

register = template.Library()

@register.simple_tag
def my_fun1(a1, a2, a3):
    return "%s-%s-%s" % (a1, a2, a3)

@register.simple_tag
def my_fun2():
    return "my_fun2"
  1. 页面文件中加载你的文件{% load myfun %}。放在顶部就好了。只要在你使用前加载加可以,不一定要在上面。如果有extends({% extends 'master.html' %}),放在extends的下面。
  2. 使用你的函数 {% 函数名 参数1 参数2 %}
{% load myfun %}
<h3>{% my_fun1 'A' 'B' 'C' %}</h3>
<h3>{% my_fun2 %}</h3>

上面的是simple_tag,使用装饰器 @register.simple_tag
还有一种filter,只要换成这个装饰器 @register.filter

from django import template

register = template.Library()

@register.simple_tag
def my_fun3(arg1, arg2):
    return "%s: %s" % (arg1, arg2)

@register.filter
def my_fun4(arg1, arg2):
    return "%s: %s" % (arg1, arg2)

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

<h3>{% my_fun3 'abc' '123' %}</h3>
<h3>{{ 'abc'|my_fun4:'123' }}</h3>

如果一定要用filter,并且还要传入多个参数,只能自己处理了,比如 {{ 'abc'|my_fun4:'123,456,789' }} 这样还是传2个参数,在我们自己的函数里做分割处理。
只传入一个参数也是可以的,第二个不写就好了。但是不能没参数。像 {{ my_fun }} 这样的用法是获取通过 return render() 给的字典里查找这个key来获取值。
单独使用,明显是simple_tag更方便,参数没有限制。
但是filter能够作为if的条件:

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

上面传参都是加了引号,表示传入的是字符串。不加引号,就是直接传入数字,类型是int。
也可以传入变量或者嵌套使用,比如处理函数最后这样返回 return render(request, 'my-fun.html', {'str': "987"})

<h3>{{ 'abc'|my_fun4:'def'|my_fun4:'456' }}</h3>
<h3>{{ 'xyz'|my_fun4:str }}</h3>

示例-分页

先把页面搞出来,比如要显示100条数据,现在是一次全部显示出来。
处理函数,views.py

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

页面,show-list.html

<ul>
    {% for item in li %}
        <li>{{ item }}</li>
    {% endfor %}
</ul>

把分页的效果弄出来,修改处理函数,一次只返回页面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 = """
    <a href='/show-list/?p=1'>1</a>
    <a href='/show-list/?p=2'>2</a>
    <a href='/show-list/?p=3'>3</a>
    <a href='/show-list/?p=4'>4</a>
    <a href='/show-list/?p=5'>5</a>
    """
    # 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连接的内容:

<body>
<ul>
    {% for item in li %}
        <li>{{ item }}</li>
    {% endfor %}
</ul>
{{ page_str }}
{#{{ page_str|safe }}#}
</body>

这里是有问题的,这里的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_safe
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]
    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("<a style='margin: 0 3px'' href='/show-list/?p=%s'>%s</a>" % (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_safe

LIST = 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("<a style='margin: 0 3px'' href='/show-list/?p=%s'>%s</a>" % (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_safe

LIST = 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("<a style='margin: 0 3px'' href='javascript:viod(0);'>上一页</a>")
    else:
        page_list.append("<a style='margin: 0 3px'' href='/show-list/?p=%s'>上一页</a>" % (current_page-1))
    for i in range(start_index, end_index+1):
        page_list.append("<a style='margin: 0 3px'' href='/show-list/?p=%s'>%s</a>" % (i, i))
    if current_page == count:
        page_list.append("<a style='margin: 0 3px'' href='javascript:viod(0);'>下一页</a>")
    else:
        page_list.append("<a style='margin: 0 3px'' href='/show-list/?p=%s'>下一页</a>" % (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_safe

class 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("<a style='margin: 0 3px'' href='javascript:viod(0);'>上一页</a>")
        else:
            page_list.append("<a style='margin: 0 3px'' href='%s?p=%s'>上一页</a>" % (base_url, self.current_page-1))
        for i in range(start_index, end_index+1):
            page_list.append("<a style='margin: 0 3px'' href='%s?p=%s'>%s</a>" % (base_url, i, i))
        if self.current_page == self.total_count:
            page_list.append("<a style='margin: 0 3px'' href='javascript:viod(0);'>下一页</a>")
        else:
            page_list.append("<a style='margin: 0 3px'' href='%s?p=%s'>下一页</a>" % (base_url, self.current_page+1))
        page_str = ''.join(page_list)
        return mark_safe(page_str)

# 处理函数 views.py 中的内容
LIST = range(1000)  # 测试数据就不走数据库了
from utils import pagination
def 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),

页面简单一点

<!-- 登录页面,login.html -->
<form action="/login/" method="POST">
    <p><input type="text" name="username" placeholder="用户名"></p>
    <p><input type="password" name="password" placeholder="密码"></p>
    <p><input type="submit" value="登录"></p>
</form>

<!-- 欢迎页面,welcome.html -->
<h1>Welcome, {{ username }}</h1>

处理函数:

# 测试数据不走数据库了
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开发人员工具在网络里查看到:
Python自动化开发学习21-Django

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 id="page-size" onchange="changPageSize(this)">
    <option value=10>10</option>
    <option value=20>20</option>
    <option value=30>30</option>
    <option value=50>50</option>
</select>
<script src="/static/js/jquery-1.12.4.js"></script>
<script src="/static/js/jquery.cookie.js"></script>
<script>
    $(function () {
        // 当页面框架加载完成后,要获取一个cookie的值,设置select框的默认选项
        var per_page_count = $.cookie('per_page_count');  // 获取cookie值
        per_page_count && $('#page-size').val(per_page_count);  // 设置select的选项,获取不到这个cookie就不设置了
    });
    function changPageSize(ths) {
        var per_page_count = $(ths).val();
        $.cookie('per_page_count', per_page_count, {'path': '/show-list/'});
        location.reload()
    }
</script>

上面给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

@auth
def 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 views
from django.utils.decorators import method_decorator

class 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 views
from django.utils.decorators import method_decorator

class 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 views
from 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