标签：python   django   

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的时候再学习。

请求的其他信息

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

所有的信息都封装在了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"

5. 页面文件中加载你的文件{% load myfun %}。放在顶部就好了。只要在你使用前加载加可以，不一定要在上面。如果有extends（{% extends ‘master.html‘ %}），放在extends的下面。
6. 使用你的函数 {% 函数名 参数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开发人员工具在网络里查看到：

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

Python自动化开发学习21-Django

标签：python   django   

原文地址：http://blog.51cto.com/steed/2095278