Django框架之模板层
一、模板简介
浏览器发送的请求信息会转发给视图函数进行处理，而视图函数在经理一系列处理后必须要有返回信息给浏览器，如果我们要返回 html 标签、 css 等数据给浏览器进行渲染，所以我们可以在视图函数中这么做
def current_datetime(request):
now = datetime.datetime.now()
html = "<html><body>It is now %s.</body></html>" % now
return HttpResponse(html)
上例所示，我们直接将 HTML 代码放到视图函数里，然后进行返回，这可以使我们很直观地看清楚浏览器从发送请求到前端界面内容的这个过程中视图函数的基本工作原理，但是这种前端代码与后端代码耦合在一起开发，存在以下问题
1、程序的可维护性与可扩展性问题
前端界面一旦需要重新设计、修改，则必须对后端的Python代码进行相应的修改。 然而前端界面的修改往往比后端 Python 代码的修改要频繁得多，因此如果可以在不进行 Python 代码修改的情况下变更前端界面的设计，那将会方便得多。
2、开发效率问题
Python 代码编写和 HTML 设计是两项不同的工作，大多数专业的网站开发环境都将它们分配给不同的人员（甚至不同部门）来完成。 专门的程序员去编写 Python代码、专门的设计人员去制作模板，这两项工作同时进行，效率才是最高的。
基于上述原因，将前端页面和Python的代码分离是一种不错的开发模式。为此Django专门提供了模板系统（Template System，即模板层）来实现这种模式
Django的模板 = HTML代码 + 模板语法
存放于 templates 目录下的 html 文件称之为模板文件，如果我们想要返回的 Html 页面中的数据是动态的，那么必须在 html 页面中嵌入变量，这便使用到了 Django 的模板语法
二、模板语法之变量
1. 变量的基本使用
如果 html 代码中的数据不是固定死的，而是动态变化的，则必须在 html 中嵌入变量，为此，模板语法提供了变量的概念，允许我们在 html 代码嵌入变量，我们只需要在视图函数中用 render 方法为 html 文件中指定的变量赋值即可
<!-- test.html文件 -->
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<link href="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.4.1/css/bootstrap.min.css" rel="stylesheet">
<script src="https://cdn.bootcdn.net/ajax/libs/twitter-bootstrap/3.4.1/js/bootstrap.min.js"></script>
<script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.4.1/jquery.min.js"></script>
</head>
<body>
<p>{{ msg }}</p>
<p>{{ dic }}</p>
<p>{{ obj }}</p>
<p>{{ time }}</p>
</body>
</html>
我们需要在视图函数中为模板 test.html 的变量名 msg、dic、obj、obj_li 赋值
""" views.py文件 """
from django.shortcuts import render
# Create your views here.
def test(request):
# 传给模板的变量值可以是任意 Python 类型
msg = "hello world"
dic = {"name":"Jason","age":18}
class Person(object):
def __init__(self,name,age):
self.name = name
self.age = age
obj = Person("Jason",18)
li = [1,'aaa',obj]
# 传值的第一种方法
return render(request,'test.html',{'msg':msg,"dic":dic,"obj":obj,'li':li})
# 传值的第二种方法
return render(request,"test.html",locals())
2. 深度查询之句点符的使用
当视图函数传给模板的值包含多个元素时，若想取出其中的单个元素，就必须使用句点符
句点符既可以引用容器类型的元素，也可以引用对象的方法
<!-- test.html文件 -->
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<!--调用字符串对象的upper方法，注意不要加括号-->
<p>{{ msg.upper }}</p>
<!--取字典中k1对应的值-->
<p>{{ dic.k1 }}</p>
<!--取对象的name属性-->
<p>{{ obj.name }}</p>
<!--取列表的第2个元素,然后变成大写-->
<p>{{ li.1.upper }}</p>
<!--取列表的第3个元素，并取该元素的age属性-->
<p>{{ li.2.age }}</p>
</body>
</html>
3. 过滤器
过滤器类似于 Python 的内置函数，用来把视图传入的变量值加以修饰后再显示，具体语法如下
# 前端
{{ 变量名|过滤器名:传给过滤器的参数 }}
# 后端
''' 常用内置过滤器 '''
#1、default
#作用：如果一个变量值是False或者为空，使用default后指定的默认值，否则，使用变量本身的值，如果value=’‘则输出“nothing”
{{ value|default:"nothing" }}
#2、length
#作用：返回值的长度。它对字符串、列表、字典等容器类型都起作用，如果value是 ['a', 'b', 'c', 'd']，那么输出是4
{{ value|length }}
#3、filesizeformat
#作用：将值的格式化为一个"人类可读的"文件尺寸(如13KB、4.1 MB、102bytes等等），如果 value 是 12312312321，输出将会是 11.5 GB
{{ value|filesizeformat }}
#4、date
#作用：将日期按照指定的格式输出，如果value=datetime.datetime.now(),按照格式Y-m-d则输出2019-02-02
{{ value|date:"Y-m-d" }}
#5、slice
#作用：对输出的字符串进行切片操作，顾头不顾尾,如果value=“egon“，则输出"eg"
{{ value|slice:"0:2" }}
#6、truncatechars
#作用：如果字符串字符多于指定的字符数量，那么会被截断。截断的字符串将以可翻译的省略号序列（“...”）结尾，如果value=”hello world egon 嘎嘎“，则输出"hello...",注意8个字符也包含末尾的3个点
{{ value|truncatechars:8 }}
#7、truncatewords
#作用：同truncatechars，但truncatewords是按照单词截断，注意末尾的3个点不算作单词，如果value=”hello world egon 嘎嘎“，则输出"hello world ..."
{{ value|truncatewords:2 }}
#8、safe
#作用：出于安全考虑，Django的模板会对HTML标签、JS等语法标签进行自动转义,例如value="<script>alert(123)</script>"，模板变量{{ value }}会被渲染成<script>alert(123)</script>交给浏览器后会被解析成普通字符”<script>alert(123)</script>“，失去了js代码的语法意义，但如果我们就想让模板变量{{ value }}被渲染的结果又语法意义，那么就用到了过滤器safe，比如value='<a href="https://www.baidu.com">点我啊</a>'，在被safe过滤器处理后就成为了真正的超链接，不加safe过滤器则会当做普通字符显示’<a href="https://www.baidu.com">点我啊</a>‘
{{ value|safe }}
三、模板语法之标签
标签是为了在模板中完成一些特殊功能，语法为{% 标签名 %}，一些标签还需要搭配结束标签{% endtag %}
1. 常用标签之 for 标签
#1、遍历每一个元素：
{% for person in person_list %}
<p>{{ person.name }}</p>
{% endfor %}
#2、可以利用{% for obj in list reversed %}反向循环。
#3、遍历一个字典：
{% for key,val in dic.items %}
<p>{{ key }}:{{ val }}</p>
{% endfor %}
#4、循环序号可以通过{{ forloop }}显示
forloop.counter 当前循环的索引值（从1开始）
forloop.counter0 当前循环的索引值（从0开始）
forloop.revcounter 当前循环的倒序索引值（从1开始）
forloop.revcounter0 当前循环的倒序索引值（从0开始）
forloop.first 当前循环是第一次循环则返回True，否则返回False
forloop.last 当前循环是最后一次循环则返回True，否则返回False
forloop.parentloop 本层循环的外层循环
#5、for标签可以带有一个可选的{% empty %} 从句，在变量person_list为空或者没有被找到时，则执行empty子句
{% for person in person_list %}
<p>{{ person.name }}</p>
{% empty %}
<p>sorry,no person here</p>
{% endfor %}
2. 常用标签之 if 标签
# 1、注意：
{% if 条件 %}条件为真时if的子句才会生效，条件也可以是一个变量，if会对变量进行求值，在变量值为空、或者视图没有为其传值的情况下均为False
# 2、具体语法
{% if num > 100 or num < 0 %}
<p>无效</p>
{% elif num > 80 and num < 100 %}
<p>优秀</p>
{% else %}
<p>凑活吧</p>
{% endif %}
#3、if语句支持 and 、or、==、>、<、!=、<=、>=、in、not in、is、is not判断。
3. 常用标签之 with 标签
# with标签用来为一个复杂的变量名起别名,如果变量的值来自于数据库，在起别名后只需要使用别名即可，无需每次都向数据库发送请求来重新获取变量的值
{% with li.1.upper as v %}
{{ v }}
{% endwith %}
4. 常用标签之 csrf_token 标签
# 当用 form 表单提交 POST 请求时必须加上标签 {% csrf_token%}，该标签用于防止跨站伪造请求
<form action="" method="POST">
{% csrf_token %}
<p>用户名：<input type="text" name="name"></p>
<p>密码：<input type="password" name="pwd"></p>
<p><input type="submit" value="提交"></p>
</form>
# 具体工作原理为：
# 1、在 GET 请求到 form 表单时，标签 {% csrf_token%} 会被渲染成一个隐藏的 input 标签，该标签包含了由服务端生成的一串随机字符串,如 <input type="hidden" name="csrfmiddlewaretoken" value="dmje28mFo...OvnZ5">
# 2、在使用 form 表单提交 POST 请求时，会提交上述随机字符串，服务端在接收到该 POST 请求时会对比该随机字符串，对比成功则处理该 POST 请求，否则拒绝，以此来确定客户端的身份
四、自定义过滤器和标签
当内置的过滤器或标签无法满足我们需求时，我们可以自定义，具体的操作步骤如下
1） 在 settings.py 中添加
在 settings 中的 INSTALLED_APPS 添加当前 app 的名字，不然 Django 无法找到自定义的过滤器或标签
# 在settings.py中找到该列表，然后加以配置
INSTALLED_APPS = [
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'app01.apps.App01Config',
'app01', # 添加当前app的名字
]
2） 创建 templatetags 文件
在文件夹 app01 中创建子文件夹 templatetags（文件夹名只能是 templatetags）
3） 新建 py 文件
在 templatetags 新建任意 .py文件，如：my_tags.py，在该文件中自定义过滤器或标签，文件内容如下
from django import template
register = template.Library() # 注意变量名必须为register,不可改变
#1、自定义过滤器
@register.filter
def my_multi_filter(v1 ,v2): # 自定义的过滤器只能定义最多两个参数，针对{{ value1 | filter_multi:value2 }}，参数传递为v1=value1,v2=value2
return v1 * v2
#2、自定义标签
@register.simple_tag
def my_multi_tag(v1, v2): # 自定义的标签可以定义多个参数
return v1 * v2
#3、自定义标签扩展之mark_safe
# 注释：我们可以用内置的标签safe来让标签内容有语法意义，如果我们想让自定义标签处理的结果也有语法意义，则不能使用内置标签safe了，需要使用mark_safe，可以实现与内置标签safe同样的功能
from django.utils.safestring import mark_safe
@register.simple_tag
def my_input_tag(id, name):
res = "<input type='text' id='%s' name='%s' />" % (id, name)
return mark_safe(res)
4） 重启 Django
自定义过滤器或标签必须重新启动 Django 方可生效
5） 自定义过滤器或标签的使用
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<!--必须先加载存有自定义过滤器和标签的文件-->
{% load my_tags %}
<!--salary的值为10，经过滤器my_multi_filter的处理结果为120-->
{{ salary|my_multi_filter:12 }}
<!--结果为2-->
{% my_multi_tag 1 2 %}
<!--
结果为一个input标签，该表的属性id="inp1" name="username"
注意：input的属性值均为字符串类型，所以my_input_tag后的两个值均为字符串类型
-->
{% my_input_tag "inp1" "username" %}
</body>
</html>
6） 对比自定义标签与自定义过滤器
#1、自定义过滤器只能传两个参数，而自定义标签却可以传多个参数
#2、过滤器可以用于if判断，而标签不能
{% if salary|my_multi_filter:12 > 200 %}
<p>优秀</p>
{% else %}
<p>垃圾</p>
{% endif %}
五、模板的导入和继承
在实际开发中，模板文件彼此之间可能有大量冗余代码，为此 Django 提供了专门的语法来解决这个问题，主要围绕三种标签的使用：include、extends、block
1） 模板的导入之 include 标签
<!-- 作用：在一个模板文件中，引入/重用另外一个模板文件的内容 -->
{% include '模版名称' %}
可以把广告栏写到专门的文件里 advertise.html
<div class="adv">
<div class="panel panel-default">
<div class="panel-heading">
<h3 class="panel-title">Panel title</h3>
</div>
<div class="panel-body">
Panel content
</div>
</div>
<div class="panel panel-danger">
<div class="panel-heading">
<h3 class="panel-title">Panel title</h3>
</div>
<div class="panel-body">
Panel content
</div>
</div>
<div class="panel panel-warning">
<div class="panel-heading">
<h3 class="panel-title">Panel title</h3>
</div>
<div class="panel-body">
Panel content
</div>
</div>
</div>
然后在 base.html 文件中用 include 标签引入 advertise.html 文件的内容
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css"
integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
<style>
* {
margin: 0;
padding: 0;
}
.header {
height: 50px;
width: 100%;
background-color: black;
}
</style>
</head>
<body>
<div class="header"></div>
<div class="container">
<div class="row">
<div class="col-md-3">
<!--在base.html引入advertise.html文件的内容-->
{% include "advertise.html" %}
</div>
<div class="col-md-9"></div>
</div>
</div>
</body>
</html>
2） 模板的继承\派生之 extends 标签、block 标签
<!-- 作用：在一个模板文件中，引入/重用另外一个模板文件的内容 -->
{% extends "模版名称" %}
<!-- 也就是说 include 有的功能 extends 全都有，但是 extends 可以搭配一个 block 标签，用于在继承的基础上定制新的内容 -->
Django 模板引擎中最复杂且最强大的部分就是模板的继承了，我们先创建一个基本的“骨架”模板，它包含我们站点中全部元素，并且可以定义多处 blocks，例如我们创建的 base.html 内容如下
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>
{% block title %}自定义title名{% endblock %}
</title>
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css"
integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
<style>
* {
margin: 0;
padding: 0;
}
.header {
height: 50px;
width: 100%;
background-color: #919191;
margin-bottom: 20px;
}
</style>
</head>
<body>
<div class="header"></div>
<div class="container">
<div class="row">
<div class="col-md-3">
<div class="list-group">
{% block sidebar %}
<a href="#" class="list-group-item active">服装城</a>
<a href="#" class="list-group-item">美妆馆</a>
<a href="#" class="list-group-item">超市</a>
<a href="#" class="list-group-item">全球购</a>
<a href="#" class="list-group-item">闪购</a>
<a href="#" class="list-group-item">团购</a>
{% endblock %}
</div>
</div>
<div class="col-md-9">
{% block content %}
base.html页面内容
{% endblock %}
</div>
</div>
</div>
</body>
</html>
模板 base.html 定义了一个可以用于两列排版页面的简单 HTML 简单骨架，我们新建子模板 index.html 的主要工作就是继承 base.html，然后填充/覆盖其内部的 blocks
{% extends "base.html" %}
<!--用新内容完全覆盖了父模板内容-->
{% block title %}
index页面
{% endblock %}
{% block sidebar %}
<!--该变量会将父模板中sidebar中原来的内容继承过来，然后我们可以在此基础上新增，否则就是纯粹地覆盖-->
{{ block.super }}
<!--在继承父模板内容的基础上新增的标签-->
<a href="#" class="list-group-item">拍卖</a>
<a href="#" class="list-group-item">金融</a>
{% endblock %}
{% block content %}
<!--用新内容完全覆盖了父模板内容-->
<p>index页面内容</p>
{% endblock %}
我们通过 Django 访问 index.html 看到内容如下（block 标签的内容都完成了替换或更新）
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>
index页面
</title>
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@3.3.7/dist/css/bootstrap.min.css"
integrity="sha384-BVYiiSIFeK1dGmJRAkycuHAHRg32OmUcww7on3RYdg4Va+PmSTsz/K68vbdEjh4u" crossorigin="anonymous">
<style>
* {
margin: 0;
padding: 0;
}
.header {
height: 50px;
width: 100%;
background-color: #919191;
margin-bottom: 20px;
}
</style>
</head>
<body>
<div class="header"></div>
<div class="container">
<div class="row">
<div class="col-md-3">
<div class="list-group">
<!--该变量会将父模板中sidebar中原来的内容继承过来，然后我们可以在此基础上新增，否则就是纯粹地覆盖-->
<a href="#" class="list-group-item active">服装城</a>
<a href="#" class="list-group-item">美妆馆</a>
<a href="#" class="list-group-item">超市</a>
<a href="#" class="list-group-item">全球购</a>
<a href="#" class="list-group-item">闪购</a>
<a href="#" class="list-group-item">团购</a>
<!--在继承父模板内容的基础上新增的标签-->
<a href="#" class="list-group-item">拍卖</a>
<a href="#" class="list-group-item">金融</a>
</div>
</div>
<div class="col-md-9">
<!--用新内容完全覆盖了父模板内容-->
<p>index页面内容</p>
</div>
</div>
</div>
</body>
</html>
总结与注意
# 1、标签 extends 必须放在首行，base.html 中 block 越多可定制性越强
# 2、include 仅仅只是完全引用其他模板文件，而extends却可以搭配 block 在引用的基础上进行扩写
# 3、变量 {{ block.super }} 可以重用父类的内容，然后在父类基础上增加新内容，而不是完全覆盖
# 4、为了提升可读性，我们可以给标签 {% endblock %} 起一个名字 。例如：
{% block content %}
...
{% endblock content %}
# 5、在一个模版中不能出现重名的 block 标签。
六、静态文件配置
我们在编写模板文件时，需要大量引用 css、js、图片等静态文件，如果我们这些文件在服务端存放的路径都固定写死那么将非常不利于后期的扩展，我们可以这么做
1） 在 settings.py 文件中添加配置
STATIC_URL = '/static/' # 找到这一行，然后新增下述代码
STATICFILES_DIRS = [
os.path.join(BASE_DIR, 'statics'), # 获取静态文件在服务端的绝对路径
]
# STATIC_URL = '/static/' 就是为静态文件的绝对路径起了一个别名，以后我们只需要用路径 /static/ 即可
2） 在项目文件下面新增文件夹 static
添加 statics 的目的是为了便于管理，可以在 statics 下新建文件夹 css、js、img 等
3） 新建模板文件 index.html，在该文件中对静态文件的引用如下
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<link rel="stylesheet" href="/static/css/my.css">
</head>
<body>
<h4>我是红色的，点我就绿</h4>
<img src="/static/img/rb.jpeg" alt="">
<script src="/static/js/jquery-3.3.1.min.js"></script>
<script src="/static/js/my.js"></script>
</body>
</html>
标签 static 会接收传入的参数，然后根据 settings.py 变量 STATIC_URL 的值拼接出一个完整的路径，如果 STATIC_URL = '/static/'，那么 href = "{% static 'css/my.css' %}" 会被渲染成 href = "/static/css/my.css"，如果 STATIC_URL = '/static123/'，那么 href = "{% static 'css/my.css' %}" 也会被渲染成 href = "/static123/css/my.css"
标签 get_static_prefix 也可以完成同样的效果，只不过用法不同。我们不能为标签 get_static_prefix 传参，因为标签 get_static_prefix 代表的只是 settings.py 中 STATIC_URL 的值，所以我们需要做的是在 get_static_prefix 的基础上自行拼接路径
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
<!--注意：同样需要先加载文件static.py-->
{% load static %}
<!--使用标签get_static_prefix拼接路径-->
<link rel="stylesheet" href="{% get_static_prefix %}css/my.css">
</head>
<body>
<h4>我是红色的，点我就绿</h4>
<img src="{% get_static_prefix %}img/rb.jpeg" alt="">
{% load static %}
<script src="{% get_static_prefix %}js/jquery-3.3.1.min.js"></script>
<script src="{% get_static_prefix %}js/my.js"></script>
</body>
</html>
如果 STATIC_URL = '/static/'，那么 herf = {% get_static_prefix %}css/my.css ，其他同理
