Django-C004-模板

梦里梦外; 2021-10-23 10:57 337阅读 0赞

# 此文章完成度【100%】留着以后忘记的回顾。多写多练多思考，我会努力写出有意思的demo，如果知识点有错误、误导，欢迎大家在评论处写下你的感想或者纠错。 #

# 【Django version】: 2.1 #

# 【pymysql version】：0.9.3 #

# 【python version】: 3.7 #

# 模板 #

--------------------

##  作为web框架，Django提供了模板，用于编写html代码，还可以嵌入模板代码更快捷、更方便的完成页面开发，在通过在视图中的渲染，将生成最终的HTML字符串返回给客户端，模板致力于表达外观，而不是程序逻辑，模板的设计实现了业务逻辑与显示内容的分离，一个视图可以使用任意的模板，一个模板可以供多个视图使用。 ##

## ##

### 模板包含两个部分： ###

*  ### 静态：html、css、js ###
 *  ### 动态：模版语言 ###

### Django处理模板分为两个阶段： ###

*  ### 加载：根据给定的路径找到模板文件，编译后保存在内存中 ###
 *  ### 渲染：使用上下文数据对模板插入值并返回生成的字符串 ###

### 为了减少加载和渲染，Django提供了简单函数render用于调用模板 ###

## Django模板语言，定义在django.template,创建完项目后，在项目文件下的settings.py文件中定义关于模板的配置 ##

TEMPLATES = [
        {
            'BACKEND': 'django.template.backends.django.DjangoTemplates',
            'DIRS': [],
            'APP_DIRS': True,
            'OPTIONS': {
                'context_processors': [
                    'django.template.context_processors.debug',
                    'django.template.context_processors.request',
                    'django.contrib.auth.context_processors.auth',
                    'django.contrib.messages.context_processors.messages',
                ],
            },
        },
    ]

DIRS定义一个目录列表，模板引擎按列表顺序搜索这些目录以便找到模板文件，通常是在项目的根目录下创建templates目录。

### 按照咱们的习惯，每当新开始的章节，当然是创建一个新的项目，温故而知新。 ###

### 1）创建项目test4 ###

django-admin startproject test4

### 2）进入项目目录，创建应用school ###

cd test4
    python manage.py startapp school

### 3) 在项目的settings.py文件中，添加应用 ###

INSTALLED_APPS = [
        'django.contrib.admin',
        'django.contrib.auth',
        'django.contrib.contenttypes',
        'django.contrib.sessions',
        'django.contrib.messages',
        'django.contrib.staticfiles',
        'school',  # 添加应用
    ]

### 4）在项目的settings.py文件中，更改使用的数据库引擎 ###

DATABASES = {
        'default': {
            'ENGINE': 'django.db.backends.mysql',
            'NAME': 't_school',
            'USER': 'root',
            'PASSWORD': 'toor',
            'HOST': 'localhost',
            'PORT': 3306,
        }
    }

### 5）在项目下的\_\_init\_\_.py文件中导入pymysql ###

import pymysql
    pymysql.install_as_MySQLdb()

### 6）在项目下的settings.py文件中添加模本文件夹 ###

TEMPLATES = [
        {
            'BACKEND': 'django.template.backends.django.DjangoTemplates',
            'DIRS': [os.path.join(BASE_DIR,'templates')],  # 添加模板文件夹路径
            'APP_DIRS': True,
            'OPTIONS': {
                'context_processors': [
                    'django.template.context_processors.debug',
                    'django.template.context_processors.request',
                    'django.contrib.auth.context_processors.auth',
                    'django.contrib.messages.context_processors.messages',
                ],
            },
        },
    ]

### 7）创建模板文件夹 ###

![1473186-20190627144446392-1809410331.png][]

### 8）配置项目下的urls.py指向我们应用的urls.py, 并且创建应用专属urls.py ###

项目下的urls.py

from django.contrib import admin
    from django.urls import path, include
    
    urlpatterns = [
        path('admin/', admin.site.urls),
        path('', include("school.urls")),
    ]

![1473186-20190627144920860-1192915120.png][]

应用下的urls.py

from django.urls import re_path
    from school import views
    
    urlpatterns = [
        re_path(r"^$", views.index),
    ]

![1473186-20190627145241627-493385876.png][]

### 9）在应用下的views.py，定义index视图 ###

![1473186-20190627150050436-1889691998.png][]

### 10）在templates的t\_school中创建index.html 模板文件 ###

![1473186-20190627145935457-1683956372.png][]

### 11）在school/models.py文件中，定义ClassInfoModel类 ###

![1473186-20190627151755241-1071069163.png][]

from django.db import models
    
    
    class ClassInfoModel(models.Model):
        """班级信息模型类"""
        name = models.CharField(max_length=20)
        class_date = models.DateField()
        class_size = models.IntegerField(default=0)
        reported_size = models.IntegerField(default=0)
        isDelete = models.BooleanField(default=False)

### 12）测试 ###

![1473186-20190627150157649-181751402.png][]

# 模板语言 #

--------------------

## 模版语言的四种类型：变量、标签、过滤器、注释 ##

## 模版变量 ##

### 模板班里那个的作用是计算并输出，变量名必须由字母、数字、下划线(但是不能作为开头)和点组成 ###

{
        { 变量 }}

### 当模版引擎遇到点如 c.name .这里的c是ClassInfoModel的对象，会按照以下顺序解析 ###

1.  ### 字典 c\['name'\] 方式解析 ###
2.  ### 先属性后方法，c当做对象，查找name属性，如果没有在查找name()方法 ###
3.  ### 如果个为c.0则解析为c\[0\] ###

如果对象不存在则插入空字符串，在模板调用方式时，不能传递参数

## 视图：views.py，创建pass\_on ##

def pass_on(request):
        po_dict = {
        'key' : 'po_dict_var'}
        c = ClassInfoModel.objects.get(id=1)
        context = {
        'po_dict': po_dict, 'c': c}
        return render(request, "t_school/pass_on.html", context)

## URL : urls.py ##

urlpatterns = [
        re_path(r"^$", views.index),
        re_path(r"^pass_on$", views.pass_on),
    ]

## 模板：templates>t\_school>pass\_on.html ##

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Document</title>
    </head>
    <body>
        dict = : {
         {po_dict.key}}<br>
        ClassInfoModel = : {
         {c.name}}<br>
    </body>
    </html>

## 展示效果 ##

![1473186-20190627161145674-36653463.png][]

# 标签 #

--------------------

# #

{% 代码段 %}

## for循环标签 ##

{%for item in 列表%}
    循环逻辑
    {
         {forloop.counter}}表示当前是第几次循环，从1开始
    {
         %empty%}
    列表为空或不存在时执行此逻辑
    {
         %endfor%}

## if判断标签 ##

{%if ...%}
    逻辑1
    {
         %elif ...%}
    逻辑2
    {
         %else%}
    逻辑3
    {
         %endif%}

## 比较运算符 ##

==　　# 注意：运算符左右两侧不能紧挨变量或常量，必须有空格。
    !=
    <
    >
    <=
    >=

## 布尔运算符 ##

and
    or
    not

## 视图：views.py 创建视图 use\_tag ##

def use_tag(request):
        context = {
        'class_list': ClassInfoModel.objects.all()}
        return render(request, 't_school/use_tag.html', context)

## URL: urls.py  ##

re_path(r"^use_tag$", views.use_tag),

## 模板：templates>t\_school>use\_tag.html ##

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Document</title>
    </head>
    <body>
        <ul>
            {%for class in class_list %}
                {%if class.id <= 3 %}
                    <li style="color:pink;">{
        { class.name }}</li>
                {%else%}
                    <li style="color:#666;">{
        { class.name }}</li>
                {%endif%}
            {%empty%}
                error： 没找到班级信息
            {%endfor%}
        </ul>
    </body>
    </html>

## 展示效果 ##

![1473186-20190627164653364-620046466.png][]

# 过滤器 #

--------------------

## 语法 ##

*  使用管道符 | 来应用过滤器，用于进行计算、转换操作、可以使用在变量、标签中
 *  如果过滤器需要参数，则使用冒号：传递参数

变量|过滤器:参数

### 长度length，返回字符串包含字符的个数，或列表、元祖、字典的元素个数 ###

### 默认值default，如果变量不存在时则返回默认值 ###

data|default:'默认值'

### 日期date, 用于对日期类型的值进行字符串格式化，常用的格式化标签 ###

*  Y表示年，格式为4位，y表示两位的年。
 *  m表示月，格式为01,02,12等。
 *  d表示日, 格式为01,02等。
 *  j表示日，格式为1,2等。
 *  H表示时，24进制，h表示12进制的时。
 *  i表示分，为0-59。
 *  s表示秒，为0-59。

alue|date:"Y年m月j日  H时i分s秒"

## 视图 ： views.py 定义视图use\_filter ##

def use_filter(request):
        context = {
        'class_list': ClassInfoModel.objects.all()}
        return render(request, 't_school/use_filter.html', context)

## URL: urls.py  ##

re_path(r"^use_filter$", views.use_filter),

## 模板：templates>t\_school>use\_filter.html ##

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Document</title>
    </head>
    <body>
        <ul>
            {%for class in class_list %}
                {%if class.id <= 3 %}
                    <li style="color:pink;">
                        {
         { class.name }}--->
                        {
         { class.class_date}}    
                    </li>
                {%else%}
                    <li style="color:#666;">
                        {
         { class.name }}--->
                        {
         { class.class_date|date:"Y-m-j"}}
                    </li>
                {%endif%}
            {%empty%}
                error： 没找到班级信息
            {%endfor%}
        </ul>
    </body>
    </html>

## 展示效果 ##

![1473186-20190627170020319-466122274.png][]

# 自定义过滤器 #

--------------------

## 过滤器就是Python中的函数，注册后就可以在模板中当做过滤器使用，下面以求余为例开发一个自定义过滤器mod ##

## 首先在应用中创建templatetags目录，创建\_\_init\_\_文件和filters.py文件 ##

![1473186-20190627170953391-1498726509.png][]

## 去settings里面的INSTALLED\_APPS中注册： ##

## 在filters.py中编写代码： ##

# 导入Library类
    from django.template import Library
    
    # 创建一个Library对象
    register = Library()
    
    # 使用装饰器进行注册
    @register.filter
    def mod(value):  # 定义求余函数，返回布尔值
        return value % 2 == 0

## 使用这个自定义的过滤器之前还需要在模板文件中导入，去模板文件中使用自定义的过滤器 ##

{%load filters%}
    
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Document</title>
    </head>
    <body>
        <ul>
            {%for class in class_list %}
                {%if class.id|mod %}
                    <li style="color:pink;">
                        {
         { class.name }}--->
                        {
         { class.class_date}}    
                    </li>
                {%else%}
                    <li style="color:#666;">
                        {
         { class.name }}--->
                        {
         { class.class_date|date:"Y-m-j"}}
                    </li>
                {%endif%}
            {%empty%}
                error： 没找到班级信息
            {%endfor%}
        </ul>
    </body>
    </html>

## 展示效果 ##

![1473186-20190627172634513-1770144415.png][]

## 其实自定义的过滤器还是可以指定参数的，接下来把上面的例子改进一下，不让固定只能取余2 ##

### 1）首先到filters.py中定义过滤器函数 ###

@register.filter
    def mod_num(value, num):  # 定义求余函数，返回布尔值
        return value % num == 0

### 2）去模板中使用 ###

{%load filters%}
    
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Document</title>
    </head>
    <body>
        <ul>
            {%for class in class_list %}
                {%if class.id|mod_num:3 %}
                    <li style="color:pink;">
                        {
         { class.name }}--->
                        {
         { class.class_date}}    
                    </li>
                {%else%}
                    <li style="color:#666666;">
                        {
         { class.name }}--->
                        {
         { class.class_date|date:"Y-m-j"}}
                    </li>
                {%endif%}
            {%empty%}
                error： 没找到班级信息
            {%endfor%}
        </ul>
    </body>
    </html>

## 效果展示 ##

![1473186-20190627173818440-1396210476.png][]

# 注释 #

--------------------

## 在模板中使用如下模板注释，这段代码不会被编译，不会输出到客户端；html注释只能注释html内容，不能注释模板语言  ##

### 1）单行注释 ###

{#...#}

### 2）多行注释 ###

{%comment%}
    ...
    {%endcomment%}

# 模板继承  #

--------------------

## 模板继承和类的继承含义是一样的，主要是为了提高代码的重用 ##

## 典型应用 : 网站头部、尾部 ##

## 父模板 ##

如果发现在多个模板中内容相同，那就应该把这段内容定义在父模板中。

标签block：用于在父模板中预留区域，留给紫墨般填充差异性的内容，名字不能相同，为了更好的可读性，建议给endblock 标签上写名字，这个名字与对应的block名字相同，父模板中也可以使用上下文中传递过来的来的数据

{%block 名称%}
    预留区域，可以编写默认内容，也可以没有默认内容
    {%endblock  名称%}

## 子模板 ##

标签extends: 继承写在模版文件的第一行

{% extends "父模板路径"%}

子模板不用填充父模板中的所有预留区域，如果子模板没有填充，则使用父模板定义的默认值。

填充父模板中指定名称的预留区域

{%block 名称%}
    实际填充内容
    {
         {block.super}}用于获取父模板中block的内容
    {%endblock 名称%}

## 视图 views.py 定义temp\_inherit. ##

def temp_inherit(request):
        context = {'title': '模板继承', 'class_list': ClassInfoModel.objects.all()}
        return render(request, 't_school/temp_inherit.html', context)

## URL urls.py ##

re_path(r"^temp_inherit$", views.temp_inherit),

## 模板 创建一个名为temp\_inherit\_base.html父模板，在创建一个temp\_inherit.html子模板 ##

## temp\_inherit\_base.html ##

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>{
        { title }}</title>
    </head>
    <body>
        <h1>网页头部</h1>
        <hr>
        {%block qu1%}
            这是区域一，默认值
        {%endblock qu1%}
        <hr>
        {%block qu2%}
        {%endblock qu2%}
        <hr>
        <h1>网页尾部</h1>
    </body>
    </html>

## temp\_inherit.html ##

{%extends 't_school/temp_inherit_base.html'%}
    
    <!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Document</title>
    </head>
    <body>
    
        {%block qu1%}
            {
         {block.super}}
            <br>
            这是区域一，添加的内容
        {%endblock qu1%}    
    
        {%block qu2%}
            <ul>
                {% for class in class_list%}
                <li>
                    {
         {class.name}}
                </li>
                {%endfor%}
            </ul>
        {%endblock qu2%}    
        
    </body>
    </html>

## 展示效果 ##

![1473186-20190627181914299-1291879771.png][]

# HTML转义 #

--------------------

##  模板对上下文传递的字符串进行输出时，会对以下字符自动转义。 ##

小于号< 转换为 <
    
    大于号> 转换为 >
    
    单引号' 转换为 '
    
    双引号" 转换为 "
    
    与符号& 转换为 &

## 视图 views.py 修改index视图的context ##

def index(request):
        context = {
        'h1': '<h1> index ok </h1>'}
        return render(request, "t_school/index.html", context)

访问127.0.0.1:8000

![1473186-20190627182708126-1308449542.png][]

转义后标记代码不会被直接解释执行，而是被直接呈现，防止客户端通过嵌入js代码攻击网站.

过滤器escape可以实现对变量的html转义，默认模板就会转义，一般省略。

{
        {数据|escape}}

## 关闭转义 ##

过滤器safe：禁用转义，告诉模板这个变量是安全的，可以解释执行。

{
        {数据|safe}}

## 模板 修改index.html ##

![1473186-20190627183433028-960124603.png][]

##  autoescape标签：设置一段代码都禁用转义，接受on、off参数。 ##

{%autoescape off%}
    ...
    {%endautoescape%}

## 模板修改index.html ##

![1473186-20190627183933478-851786745.png][]

# 字符串字面值 #

对于在模板中硬编码的html字符串，不会转义。如果希望出现转义的效果，则需要手动编码转义。

## 模板修改index.html文件 ##

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Document</title>
    </head>
    <body>
    自动转义：{
         {h1}}
    <HR style="FILTER: alpha(opacity=100,finishopacity=0,style=2)" width="100%" color=#987cb9 SIZE=10>
    过滤器safe关闭转义：{
         {h1|safe}}
    <HR style="FILTER: alpha(opacity=100,finishopacity=0,style=2)" width="100%" color=#987cb9 SIZE=10>
    标签autoescape关闭转义：
    {%autoescape off%}
    {
         {h1}}
    {%endautoescape%}
    <HR style="FILTER: alpha(opacity=100,finishopacity=0,style=2)" width="100%" color=#987cb9 SIZE=10>
    模板硬编码不转义：{
         {data|default:'<b>hello</b>'}}
    <HR style="FILTER: alpha(opacity=100,finishopacity=0,style=2)" width="100%" color=#987cb9 SIZE=10>
    模板硬编码手动转义：{
         {data|default:"<b>123</b>"}}
    </body>
    </html>

# CSRF #

--------------------

### CSRF（Cross Site Request Forgery）跨站请求伪造。CSRF指攻击者盗用了你的身份，以你的名义发送恶意请求。CSRF能够做的事情包括：以你名义发送邮件，发送消息，盗取你的账号，甚至于购买商品，虚拟货币转账，个人隐私泄露以及财产安全。 ###

### CSRF示意图 ###

![1473186-20190627213103980-691897917.png][]

如果想防止CSRF，首先是重要的信息传递都采用POST方式而不是GET方式，接下来就说POST请求的攻击方式以及在Django中的避免。

#  视图：views.py 创建视图login、login\_check、post、post\_action #

def login(request):
        return render(request, 't_school/login.html')
    
    def login_check(request):
        username = request.POST.get('username')  # 获取用户名
        password = request.POST.get('password')  # 获取密码
    
        # 校验
        if username == 'circle' and password == '123':
            request.session['username'] = username
            request.session['isLogin'] = True 
            return redirect('/post')
        else:
            return redirect('/login')
    
    def post(request):
        return render(request, 't_school/post.html')
    
    def post_action(request):
        if request.session['isLogin']:
            username = request.session['username']
            title = request.POST.get('title')  # 获取标题
            content = request.POST.get('content')  # 获取内容
            return HttpResponse(username + '发了一篇%s : %s' % (title, content))
        else:
            return HttpResponse('失败')

##  URL : urls.py ##

re_path(r"^login$", views.login),
        re_path(r"^login_check$", views.login_check),
        re_path(r"^post$", views.post),
        re_path(r"^post_action$", views.post_action),

## 模板：在templates/school中创建login.html 和 post.html ##

### login.html ###

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Document</title>
    </head>
    <body>
        <form method="post" action="/login_check">
            username:<input type="text" name="username"><br>
            password:<input type="text" name="password"><br>
            <input type="submit" value="提交">
        </form>
    </body>
    </html>

### post.html ###

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>发帖页</title>
    </head>
    <body>
    <form method="post" action="/post_action">
        标题:<input type="text" name="title"/><br/>
        内容:<textarea name="content"></textarea>
        <input type="submit" value="发帖"/>
    </form>
    </body>
    </html>

## 运行服务，username : circle password : 123 就可以后续的操作 ##

### login.html ###

![1473186-20190628105044210-1521404425.png][]

### post.html ###

![1473186-20190628105147151-1639096649.png][]

### post\_action ###

![1473186-20190628105210986-748487831.png][]

## 这些都是正常的操作，但是如果直接输入127.0.0.1:8000/post.html 也是可以的，所以这个就是有问题的,在生产环境中也是不允许的，所以我们需要验证post.html 是否已经登录 ##

## 需要修改视图的post函数 ##

def post(request):
        if request.session.has_key('isLogin'):
            return render(request, 't_school/post.html')
        else:
            return redirect('/login')

## 验证效果，但是我们需要清除浏览器中的Cookie否则你的登录状态是登录过的 ##

![1473186-20190628110206152-1588371304.png][]

## 当你再次访问127.0.0.1:8000/post.html，会直接跳转到login这个页面，问题来了，如果重复的页面都需要使用这个访问限制。难道我们需要在每一个函数中添加一条判断语句吗？当然不用，我们可以用到python中的装饰器 ##

## 视图中定义一个装饰器 ##

# 定义一个登录的装饰器，用来验证是否这个页面需要先登录在访问
    def login_required(view_func):
        def wrapper(request, *args, **kwargs):
            if request.session.has_key('isLogin'):
                return view_func(request, *args, **kwargs)
            else:
                return redirect('/login')
        return wrapper

@login_required
    def post(request):
        return render(request, 't_school/post.html')
    
    
    @login_required
    def post_action(request):
        if request.session['isLogin']:
            username = request.session['username']
            title = request.POST.get('title')  # 获取标题
            content = request.POST.get('content')  # 获取内容
            return HttpResponse(username + '发了一篇%s : %s' % (title, content))
        else:
            return HttpResponse('失败')

## 但是到底什么是csrf，当黑客制作了一个钓鱼网站，当你在没有删除Cookie和你登录状态的时候，你通过这个浏览器访问了他的钓鱼网站B，但是他的站点设置一些对你操作的A网站里面的信息进行修改，他就可以跳过登录，直接操作A网站 ##

## 那么咱们自己的网站如果做到防护呢，在Django中有一个中间件就是CSRF ##

MIDDLEWARE = [
        'django.middleware.security.SecurityMiddleware',
        'django.contrib.sessions.middleware.SessionMiddleware',
        'django.middleware.common.CommonMiddleware',
        'django.middleware.csrf.CsrfViewMiddleware',  # 防止CSRF的中间件
        'django.contrib.auth.middleware.AuthenticationMiddleware',
        'django.contrib.messages.middleware.MessageMiddleware',
        'django.middleware.clickjacking.XFrameOptionsMiddleware',
    ]

## 这个中间件默认是开启，但是我们自己网站需要用到的post提交也会被阻止，这里就需要在你的表单提交post数据的时候，添加\{% csrf\_token %\}标签 ##

## login.html中添加 ##

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Document</title>
    </head>
    <body>
        <form method="post" action="/login_check">
            {% csrf_token %}
            username:<input type="text" name="username"><br>
            password:<input type="text" name="password"><br>
            <input type="submit" value="提交">
        </form>
    </body>
    </html>

## post.html中添加 ##

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>发帖页</title>
    </head>
    <body>
    <form method="post" action="/post_action">
        {% csrf_token%}
        标题:<input type="text" name="title"/><br/>
        内容:<textarea name="content"></textarea>
        <input type="submit" value="发帖"/>
    </form>
    </body>
    </html>

### 这里，就可以成功完成CSRF防护 ###

### **防护原理** ###

1.  ### 渲染模板文件时在页面生成一个名字叫做csrfmiddlewaretoken的隐藏域。 ###
2.  ### 服务器交给浏览器保存一个名字为csrftoken的cookie信息。 ###
3.  ### 提交表单时，两个值都会发给服务器，服务器进行比对，如果一样，则csrf验证通过，否则失败。 ###

说明：当启用中间件并加入标签csrf\_token后，会向客户端浏览器中写入一条Cookie信息，这条信息的值与隐藏域input元素的value属性是一致的，提交到服务器后会先由csrf中间件进行验证，如果对比失败则返回403页面，而不会进行后续的处理。

# 验证码 #

--------------------

在用户注册、登录页面，为了防止暴力请求，可以加入验证码功能，如果验证码错误，则不需要继续处理，可以减轻业务服务器、数据库服务器的压力。

## 实现验证码 ##

### 安装pillow ###

pip install Pillow

点击查看[PIL模块API][PIL_API]，以下代码中用到了Image、ImageDraw、ImageFont对象及方法。

## 视图 views.py 创建视图verify\_code ##

*  提示1：随机生成字符串后存入session中，用于后续判断。
 *  提示2：视图返回mime-type为image/png。

from PIL import Image, ImageDraw, ImageFont
    from django.utils.six import BytesIO
    
    def verify_code(request):
        #引入随机函数模块
        import random
        #定义变量，用于画面的背景色、宽、高
        bgcolor = (random.randrange(100), random.randrange(
            20, 100), 255)
        width = 100
        height = 35
        #创建画面对象
        im = Image.new('RGB', (width, height), bgcolor)
        #创建画笔对象
        draw = ImageDraw.Draw(im)
        #调用画笔的point()函数绘制噪点
        for i in range(0, 100):
            xy = (random.randrange(0, width), random.randrange(0, height))
            fill = (random.randrange(0, 255), 255, random.randrange(0, 255))
            draw.point(xy, fill=fill)
        #定义验证码的备选值
        str1 = 'ABCD123EFGHIJK456LMNOPQRS789TUVWXYZ0'
        #随机选取4个值作为验证码
        rand_str = ''
        for i in range(0, 4):
            rand_str += str1[random.randrange(0, len(str1))]
        #构造字体对象  windows下的字体路径'C:\\Windows\\Fonts\\arial.ttf' 26是字体大小
        font = ImageFont.truetype('C:\\Windows\\Fonts\\arial.ttf', 26)
        #构造字体颜色
        fontcolor = (255, random.randrange(0, 255), random.randrange(0, 255))
        #绘制4个字
        draw.text((5, 2), rand_str[0], font=font, fill=fontcolor)
        draw.text((25, 2), rand_str[1], font=font, fill=fontcolor)
        draw.text((50, 2), rand_str[2], font=font, fill=fontcolor)
        draw.text((75, 2), rand_str[3], font=font, fill=fontcolor)
        #释放画笔
        del draw
        #存入session，用于做进一步验证
        request.session['verifycode'] = rand_str
        #内存文件操作
        buf = BytesIO()
        #将图片保存在内存中，文件类型为png
        im.save(buf, 'png')
        #将内存中的图片数据返回给客户端，MIME类型为图片png
        return HttpResponse(buf.getvalue(), 'image/png')

## 配置URL urls.py ##

re_path(r'^verify_code$', views.verify_code),

## 访问[1][]27.0.0.1:8000/verify\_code ##

![1473186-20190628123810933-504353406.png][]

## 在login页面中调用verify\_code ##

## 在templates中找到login.html ##

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>Document</title>
    </head>
    <body>
        <form method="post" action="/login_check">
            {% csrf_token %}
            username:<input type="text" name="username"><br>
            password:<input type="password" name="password"><br>
            <img src="/verify_code"><input type="text" name="verify_code"><br>
            <input type="submit" value="提交">
        </form>
    </body>
    </html>

## 在视图views.py的login\_check中添加验证 ##

def login_check(request):
        username = request.POST.get('username')  # 获取用户名
        password = request.POST.get('password')  # 获取密码
        verifycode_input = request.POST.get('verify_code')  # 获取验证码
        verifycode_session = request.session['verifycode']  # 获取session中存储的验证码
    
        # 校验验证码
        if verifycode_input != verifycode_session:
            return redirect('/login')
    
        # 校验用户名密码是否正确
        if username == 'circle' and password == '123':
            request.session['username'] = username
            request.session['isLogin'] = True 
            return redirect('/post')
        else:
            return redirect('/login')

## 访问127.0.0.1:8000/login，如果验证码输入错误会重新返回到login这个页面 ##

![1473186-20190628124859133-694048480.png][]

# 反向解析 #

--------------------

## 如果在视图，模板中使用硬编码连接(也就说把地址写死)，在url配置发生改变时，需要变更的代码会非常多，这样导致我们的代码结构不是很容易维护，使用反向解析可以提高我们代码的扩展性和可维护性。 ##

### 第一步：在项目中urls.py中的include添加namespace ###

path('', include("school.urls", namespace='school')),

### 结果悲剧发生，报错信息如下： ###

django.core.exceptions.ImproperlyConfigured:
    Specifying a namespace in include() without providing an app_name is not supported.
    Set the app_name attribute in the included module,
    or pass a 2-tuple containing the list of patterns and app_name instead.

# 翻译过来大概意思

在include()指定一个 namespace必须提供app_name，在include模块中设置一个app_name属性，

或者传递一个包含规则和app_name的2个元素的元祖

### 修改结果为： ###

from django.contrib import admin
    from django.urls import path, include
    
    
    school_app_patterns = ("school.urls",'school')
    
    urlpatterns = [
        path('admin/', admin.site.urls),
        # path('', include("school.urls", namespace='school')),
        path('', include(school_app_patterns, namespace='school')),
    ]

## 第二步：在应用下的urls.py中为url定义name属性 ##

re_path(r"^$", views.index, name='index'),

## 视图 views.py 定义reverse\_url ##

def reverse_url(request):
        return render(request, 't_school/reverse_url.html')

## URL urls.py 添加 url ##

re_path(r'^reverse_url$', views.reverse_url),

## Templates 创建reverse\_url.html ##

## 访问127.0.0.1:8000/reverse\_url，查看网页源码，会发现反向链接自己动态的生成了url，这里如果我们更改一下urls.py中的正则，对比一下普通和反向的区别 ##

![1473186-20190628172335607-624620644.png][]

![1473186-20190628172411081-622236879.png][]

# re_path(r"^$", views.index, name='index'),
    re_path(r"^index$", views.index, name='index'),

![1473186-20190628172731101-445589173.png][]

### 这里我们可以看出反向的链接自动生成了，更改配置后的路径 ###

## URL的参数 ##

### 有些url配置项正则表达式中是有参数的，接下来讲解如何传递参数。 ###

## 应用下的urls.py 添加url ##

re_path(r'^reverse_url_args/(\d+)/(\d+)$', views.reverse_url_args, name='reverse_url_args'),

## 视图 定义reverse\_url\_args ##

def reverse_url_args(request, a, b):
        return HttpResponse(a + ":" + b)

## Templates 下修改reverse\_url.html ##

<!DOCTYPE html>
    <html lang="en">
    <head>
        <meta charset="UTF-8">
        <title>反向解析</title>
    </head>
    <body>
        普通链接<a href="/">首页</a><br>
        反向链接<a href="{% url 'school:index' %}">首页</a><br>
    
        普通链接<a href="/reverse_url_args/2/3">/views.reverse_url_args/2/3</a><br>
        反向链接<a href="{% url 'school:reverse_url_args' 2 3 %}">/views.reverse_url_args/2/3</a><br>
    </body>
    </html>

{% url 'school:reverse_url_args' 2 3 %}
    这里school是namespace中的值
    这里reverse_url_args是URL中name的值
    这里 'school:reverse_url_args'之后加上空格加上第一个参数2，在加上空格加上第二个参数3

## 访问127.0.0.1:8000/reverse\_url  ##

![1473186-20190628174634859-1943590159.png][]

查看源码同样反向链接中的href也是动态生成的

![1473186-20190628174651159-2015357913.png][]

## URL的关键字参数 ##

## 首先在urls.py 中添加带有关键字参数的路径 ##

re_path(
    　　r'^reverse_url_kwargs/(?P<username>\w+)$',
       views.reverse_url_kwargs,
       name='reverse_url_kwargs'),

## 视图 定义reverse\_url\_kwargs  ##

def reverse_url_kwargs(request, username):
        return HttpResponse(username)

## Templates中添加刚才的路径a标签， ##

普通链接<a href="/reverse_url_kwargs/circle">/views.reverse_url_args/2/3</a><br>
        反向链接<a href="{% url 'school:reverse_url_kwargs' username='circle' %}">/views.reverse_url_args/2/3</a><br>

## 访问127.0.0.1:8000/reverse\_url ##

![1473186-20190628180402782-1891634162.png][]

![1473186-20190628180409421-1032300152.png][]

## 1.视图里使用反向解析 ##

## 视图views.py中定义reverse\_redirect ##

from django.urls import reverse
    def reverse_redirect(request):
        # 重定向到index
        # 写死路径的方式
        # return redirect('/index')
    
        # 使用反向解析
        url = reverse('school:index')
        return redirect(url)

## 应用下的urls.py 中配置reverse\_redirect ##

re_path(r'^reverse_redirect$', views.reverse_redirect)

## 访问127.0.0.1:8000/reverse\_redirect，会直接返回index页面 ##

## 2.视图里使用反向解析带有位置参数的url ##

## 视图中修改reverse\_redirect ##

def reverse_redirect(request):
        # 重定向到reverse_url_args
        url = reverse('school:reverse_url_args', args=(2,3))
        return redirect(url)

## 访问127.0.0.1:8000/reverse\_redirect，会直接返回reverse\_url\_args ##

## 页面 ##

![1473186-20190628182256678-1365865813.png][]

## 3.视图里使用反向解析带有关键字参数的url ##

## 视图中修改reverse\_redirect ##

from django.urls import reverse
    def reverse_redirect(request):
        # 重定向到reverse_url_kwargs
        url = reverse('school:reverse_url_kwargs', kwargs={
        'username' : 'circle'})
        return redirect(url)

## 访问127.0.0.1:8000/reverse\_redirect，会直接返回reverse\_url\_kwargs ##

## 页面 ##

![1473186-20190628182548075-1643989282.png][]

#  -The End- #

转载于:https://www.cnblogs.com/Hannibal-2018/p/11094368.html

[1473186-20190627144446392-1809410331.png]: /images/20211023/bfe49ae272ab4d51859e68708f23b0c3.png
[1473186-20190627144920860-1192915120.png]: /images/20211023/f774eb622ec546d88eac22efe0e23ad5.png
[1473186-20190627145241627-493385876.png]: /images/20211023/e0f8cfc75b7f4e29b07fbfbeb47ead3a.png
[1473186-20190627150050436-1889691998.png]: /images/20211023/cd21f9a55bc54a73aa4a60435040882f.png
[1473186-20190627145935457-1683956372.png]: /images/20211023/df9d4867dfd2419aaa4f2d989efdcaac.png
[1473186-20190627151755241-1071069163.png]: /images/20211023/9a861845942247a786d6dfdab6179997.png
[1473186-20190627150157649-181751402.png]: /images/20211023/5910d39f40884c3693d305a796213653.png
[1473186-20190627161145674-36653463.png]: /images/20211023/1cb28495156d4da2905d61e898d07f53.png
[1473186-20190627164653364-620046466.png]: /images/20211023/e08d4979c5974c42b5e6dee9d9d34e99.png
[1473186-20190627170020319-466122274.png]: /images/20211023/7ee1fee5d07a4d11849d61c4c19f1017.png
[1473186-20190627170953391-1498726509.png]: /images/20211023/4a878e1c18dd411280d830be6dbf199d.png
[1473186-20190627172634513-1770144415.png]: /images/20211023/7ab84e2a6a9b4725a2c5e1f70b68211e.png
[1473186-20190627173818440-1396210476.png]: /images/20211023/15a361059c0f4988883ad8d368635108.png
[1473186-20190627181914299-1291879771.png]: /images/20211023/6a12f7aabcde4d94b2afe881628bfc65.png
[1473186-20190627182708126-1308449542.png]: /images/20211023/f7e1425ef189424db5fd54c436b565a2.png
[1473186-20190627183433028-960124603.png]: /images/20211023/4a317ba3951144ccbbd359ae1a79efa5.png
[1473186-20190627183933478-851786745.png]: /images/20211023/da3f708a135f4c8c9561223468f3d8d5.png
[1473186-20190627213103980-691897917.png]: /images/20211023/3e609b148da14e87847bbfdfeda74efe.png
[1473186-20190628105044210-1521404425.png]: /images/20211023/fbebe2d0a3974076b702bcbd23d3fcb6.png
[1473186-20190628105147151-1639096649.png]: /images/20211023/db51bd6a08544b5cbd407069bd752511.png
[1473186-20190628105210986-748487831.png]: /images/20211023/5765a252a49a46c3ade95ed1956eb698.png
[1473186-20190628110206152-1588371304.png]: /images/20211023/b6de860110f04425a3e472b2e0f63fd6.png
[PIL_API]: https://pillow.readthedocs.io/en/stable/
[1]: http://127.0.0.1:8000/verify_code
[1473186-20190628123810933-504353406.png]: /images/20211023/a8a0daa1aa414a61bd9e96993bf38b95.png
[1473186-20190628124859133-694048480.png]: /images/20211023/4ec642dfcd8b422e8c92a9cc62a99f0c.png
[1473186-20190628172335607-624620644.png]: /images/20211023/d97de099d6b045de8c73daf28a408f83.png
[1473186-20190628172411081-622236879.png]: /images/20211023/d5692672d9e04d05bf7c51b092930b7a.png
[1473186-20190628172731101-445589173.png]: /images/20211023/d21617754afb48d6ae587ea65e5e695e.png
[1473186-20190628174634859-1943590159.png]: /images/20211023/160a141980fe4cf3b633bf7e2fddcc5b.png
[1473186-20190628174651159-2015357913.png]: /images/20211023/34cafd4d8a644382bfaf47198092d196.png
[1473186-20190628180402782-1891634162.png]: /images/20211023/d02f45bb5ec04a6fadc8d5a2bf5ef3f0.png
[1473186-20190628180409421-1032300152.png]: /images/20211023/b8cd70c437504d6eb70d2758ef30df22.png
[1473186-20190628182256678-1365865813.png]: /images/20211023/c89e515b50e14241884869ec30dd8ba2.png
[1473186-20190628182548075-1643989282.png]: /images/20211023/a291a4aae7db4f2e968143bd2c63bb40.png