模版简介

模板是一个web开发必备的模块。因为我们在渲染一个网页的时候，并不是只渲染一个纯文本字符串，而是需要渲染一个有富文本标签的页面。这时候我们就需要使用模板了。在Flask中，配套的模板是Jinja2，Jinja2的作者也是Flask的作者。这个模板非常的强大，并且执行效率高。以下对Jinja2做一个简单介绍！

渲染`Jinja`模板

要渲染一个模板，通过render_template方法即可，以下将用一个简单的例子进行讲解：

创建about.html


1
<h1>welcome back!</h1>

执行下面代码


x
1
from flask import Flask,render_template
2
app = Flask(__name__)
3

4
@app.route('/about/')
5
def about():
6
    return render_template('about.html')
7
# 渲染 about.html 注意：必须要在 templates 文件夹下
8

9
if __name__ == '__main__':
10
    app.run(debug=True,host='0.0.0.0',port=5000)

当访问/about/的时候，about()函数会在当前目录下的templates文件夹下寻找about.html模板文件。如果想更改模板文件地址，应该在创建app的时候，给Flask传递一个关键字参数template_folder，指定具体的路径，再看以下例子：


xxxxxxxxxx
6
1
from flask import Flask,render_template
2
app = Flask(__name__,template_folder=r'C:\templates')
3

4
@app.route('/about/')
5
def about():
6
    return render_template('about.html')

以上例子将会在C盘的templates文件夹中寻找模板文件。还有最后一点是，如果模板文件中有参数需要传递，应该怎么传呢，我们再来看一个例子：

about.html 修改为如下


xxxxxxxxxx
1
1
<h1>welcome {{ user }} </h1>

在渲染模版的时候传递一下参数


xxxxxxxxxx
3
1
@app.route('/about/')
2
def about():
3
    return render_template('about.html', user='user01')

如果有多个参数要传递的话可以放在字典中


xxxxxxxxxx
4
1
@app.route('/about/')
2
def about():
3
    return render_template('about.html', **{'user':'alice','name':'bob'})
4
#  about.html 中需要有 user 和 name

以上例子介绍了两种传递参数的方式，因为render_template需要传递的是一个关键字参数，所以第一种方式是顺其自然的。但是当你的模板中要传递的参数过多的时候，把所有参数放在一个函数中显然不是一个好的选择，因此我们使用字典进行包装，并且加两个*号，来转换成关键字参数。

Jinja2模版概述

概要

先看一个简单例子：


xxxxxxxxxx
18
1
<html lang="en">
2
<head>
3
   <title>My Webpage</title>
4
</head>
5
<body>
6
    <ul id="navigation">
7
    {% for item in navigation %}
8
        <li><a href="{{ item.href }}">{{ item.caption }}</a></li>
9
    {% endfor %}
10
    </ul>
11

12
    {{ a_variable }}
13
    {{ user.name }}
14
    {{ user['name'] }}
15

16
    {# a comment #}
17
 </body>
18
</html>

以上示例有需要进行解释：

第12~14行的{{ ... }}：用来装载一个变量，模板渲染的时候，会把这个变量代表的值替换掉。并且可以间接访问一个变量的属性或者一个字典的key。关于点.号访问和[]中括号访问，没有任何区别，都可以访问属性和字典的值。
第7~9行的{% ... %}：用来装载一个控制语句，以上装载的是for循环，以后只要是要用到控制语句的，就用{% ... %}。
第16行的{# ... #}：用来装载一个注释，模板渲染的时候会忽视这中间的值。

对应的 Python 代码如下


xxxxxxxxxx
9
1
@app.route('/demo1/')
2
def demo1():
3
    navigation = [
4
        {'href':'http://www.baidu.com','caption':'百度'},
5
        {'href':'http://www.qq.com','caption':'腾讯'}
6
    ]
7
    a = 'hello world'
8
    user = {'name':'alice'}
9
    return render_template('demo1.html', navigation=navigation, a_variable=a, user=user)

Jinja2 模版过滤器

过滤器是通过管道符号（|）进行使用的，例如：{{ name|length }}，将返回name的长度。过滤器相当于是一个函数，把当前的变量传入到过滤器中，然后过滤器根据自己的功能，再返回相应的值，之后再将结果渲染到页面中。Jinja2中内置了许多过滤器，在这里可以看到所有的过滤器，现对一些常用的过滤器进行讲解：

abs(value)：返回一个数值的绝对值。例如：-1|abs。
default(value,default_value,boolean=false)：如果当前变量没有值，则会使用参数中的值来代替。name|default('alice')——如果name不存在，则会使用alice来替代。boolean=False默认是在只有这个变量为undefined的时候才会使用default中的值，如果想使用python的形式判断是否为false，则可以传递boolean=true。也可以使用or来替换。
escape(value)或e：转义字符，会将<、>等符号转义成HTML中的符号。例如：content|escape或content|e。
first(value)：返回一个序列的第一个元素。names|first。
format(value,*arags,**kwargs)：格式化字符串。例如以下代码：


xxxxxxxxxx
1
1
{{ "%s - %s"|format("hello","alice") }}

将输出：Hello - alice

last(value)：返回一个序列的最后一个元素。示例：names|last。
length(value)：返回一个序列或者字典的长度。示例：names|length。
join(value,d=u'')：将一个序列用d这个参数的值拼接成字符串。
safe(value)：如果开启了全局转义，那么safe过滤器会将变量关掉转义。示例：content_html|safe。
int(value)：将值转换为int类型。
float(value)：将值转换为float类型。
lower(value)：将字符串转换为小写。
upper(value)：将字符串转换为小写。
replace(value,old,new)：替换将old替换为new的字符串。
truncate(value,length=255,killwords=False)：截取length长度的字符串。
striptags(value)：删除字符串中所有的HTML标签，如果出现多个空格，将替换成一个空格。
trim：截取字符串前面和后面的空白字符。
string(value)：将变量转换成字符串。
wordcount(s)：计算一个长字符串中单词的个数。

控制语句

所有的控制语句都是放在{% ... %}中，并且有一个语句{% endxxx %}来进行结束，Jinja中常用的控制语句有if/for..in..，现对他们进行讲解：

if：if语句和python中的类似，可以使用>，<，<=，>=，==，!=来进行判断，也可以通过and，or，not，()来进行逻辑合并操作，以下看例子：


xxxxxxxxxx
7
1
{% if num < 60 %}
2
    你猜的数字小了
3
{% elif num > 60 %}
4
    你猜的数字大了
5
{% else %}
6
    你猜对了
7
{% endif %}

for...in...：for循环可以遍历任何一个序列包括列表、字典、元组。并且可以进行反向遍历，以下将用几个例子进行解释：

普通的遍历：


xxxxxxxxxx
5
1
<ul>
2
{% for user in users %}
3
<li>{{ user.username|e }}</li>
4
{% endfor %}
5
</ul>

遍历字典：


xxxxxxxxxx
6
1
<dl>
2
{% for key, value in my_dict.iteritems() %}
3
    <dt>{{ key|e }}</dt>
4
    <dd>{{ value|e }}</dd>
5
{% endfor %}
6
</dl>

如果序列中没有值的时候，进入else：


xxxxxxxxxx
7
1
<ul>
2
{% for user in users %}
3
    <li>{{ user.username|e }}</li>
4
{% else %}
5
    <li><em>no users found</em></li>
6
{% endfor %}
7
</ul>

并且Jinja中的for循环还包含以下变量，可以用来获取当前的遍历状态：

变量	描述
loop.index	当前迭代的索引（从1开始）
loop.index0	当前迭代的索引（从0开始）
loop.first	是否是第一次迭代，返回True或False
loop.last	是否是最后一次迭代，返回True或False
loop.length	序列的长度

另外，不可以使用continue和break表达式来控制循环的执行。

测试器

测试器主要用来判断一个值是否满足某种类型，并且这种类型一般通过普通的if判断是有很大的挑战的。语法是：if...is...，先来简单的看个例子：


xxxxxxxxxx
5
1
{% if variable is upper %}
2
    value of variable: {{ variable }}
3
{% else %}
4
    variable is not upper
5
{% endif %}

以上判断variable这个变量是否全大写，Jinja中内置了许多的测试器，看以下列表：

测试器	说明
`callable(object)`	是否可调用
`defined(object)`	是否已经被定义了。
`escaped(object)`	是否已经被转义了。
`upper(object)`	是否全是大写。
`lower(object)`	是否全是小写。
`string(object)`	是否是一个字符串。
`sequence(object)`	是否是一个序列。
`number(object)`	是否是一个数字。
`odd(object)`	是否是奇数。
`even(object)`	是否是偶数。

宏和import语句

宏

模板中的宏跟python中的函数类似，可以传递参数，但是不能有返回值，可以将一些经常用到的代码片段放到宏中，然后把一些不固定的值抽取出来当成一个变量，以下将用一个例子来进行解释：


xxxxxxxxxx
3
1
{% macro input(name, value='', type='text') %}
2
    <input type="{{ type }}" name="{{ name }}" value="{{ value|e }}">
3
{% endmacro %}

以上例子可以抽取出了一个input标签，指定了一些默认参数。那么我们以后创建input标签的时候，可以通过他快速的创建：


xxxxxxxxxx
2
1
<p>{{ input('username') }}</p>
2
<p>{{ input('password', type='password') }}</p>

import语句：

在真实的开发中，会将一些常用的宏单独放在一个文件中，在需要使用的时候，再从这个文件中进行导入。import语句的用法跟python中的import类似，可以直接import...as...，也可以from...import...或者from...import...as...，假设现在有一个文件，叫做forms.html，里面有两个宏分别为input和textarea，如下：


xxxxxxxxxx
8
1
{% macro input(name, value='', type='text') %}
2
    <input type="{{ type }}" value="{{ value|e }}" name="{{ name }}">
3
{% endmacro %}
4

5
{% macro textarea(name, value='', rows=10, cols=40) %}
6
    <textarea name="{{ name }}" rows="{{ rows }}" cols="{{ cols
7
    }}">{{ value|e }}</textarea>
8
{% endmacro %}

导入宏的例子：

import...as...形式：


xxxxxxxxxx
8
1
{% import 'forms.html' as forms %}
2
<dl>
3
 <dt>Username</dt>
4
 <dd>{{ forms.input('username') }}</dd>
5
 <dt>Password</dt>
6
 <dd>{{ forms.input('password', type='password') }}</dd>
7
</dl>
8
<p>{{ forms.textarea('comment') }}</p>

from...import...as.../from...import...形式：


xxxxxxxxxx
8
1
{% from 'forms.html' import input as input_field, textarea %}
2
<dl>
3
 <dt>Username</dt>
4
 <dd>{{ input_field('username') }}</dd>
5
 <dt>Password</dt>
6
 <dd>{{ input_field('password', type='password') }}</dd>
7
</dl>
8
<p>{{ textarea('comment') }}</p>

include和set语句

include语句

include语句可以把一个模板引入到另外一个模板中，类似于把一个模板的代码copy到另外一个模板的指定位置，看以下例子：

header.html


xxxxxxxxxx
10
1
<!DOCTYPE html>
2
<html lang="en">
3
<head>
4
    <meta charset="UTF-8">
5
    <title>Title</title>
6
</head>
7
<body>
8
    <div class="box">
9
        我是头部~~
10
    </div>

footer.html


xxxxxxxxxx
5
1
<div class="copy">
2
    &copy;copyright eagleslab 1988
3
</div>
4
</body>
5
</html>

demo1.html


xxxxxxxxxx
3
1
{% include 'header.html' %}
2
<h1>正文内容</h1>
3
{% include 'footer.html' %}

flask中


xxxxxxxxxx
3
1
@app.route("/demo1/")
2
def demo1():
3
    return render_template('demo1.html')

最终效果

赋值（set）语句

有时候我们想在在模板中添加变量，这时候赋值语句（set）就派上用场了，先看以下例子：


xxxxxxxxxx
1
1
{% set name='eagle' %}

那么以后就可以使用name来代替eagle这个值了，同时，也可以给他赋值为列表和元组：


xxxxxxxxxx
1
1
{% set navigation = [('index.html', 'Index'), ('about.html', 'About')] %}

赋值语句创建的变量在其之后都是有效的，如果不想让一个变量污染全局环境，可以使用with语句来创建一个内部的作用域，将set语句放在其中，这样创建的变量只在with代码块中才有效，看以下示例：


xxxxxxxxxx
4
1
{% with %}
2
    {% set foo = 42 %}
3
    {{ foo }}           foo is 42 here
4
{% endwith %}

也可以在with的后面直接添加变量，比如以上的写法可以修改成这样：


xxxxxxxxxx
3
1
{% with foo = 42 %}
2
    {{ foo }}
3
{% endwith %}

这两种方式都是等价的，一旦超出with代码块，就不能再使用foo这个变量了。


xxxxxxxxxx
25
1
<!DOCTYPE html>
2
<html lang="en">
3
<head>
4
    <meta charset="UTF-8">
5
    <title>Document</title>
6
</head>
7
<body>
8
    {% set name="alice"  %}
9
    <h1>欢迎{{ name }}</h1>
10
    {% set link=[('http://www.baidu.com','百度'),('http://www.qq.com','腾讯')] %}
11
    <ul>
12
    {% for i in link %}
13
        <li><a href="{{ i[0] }}">{{ i[1] }}</a></li>
14
    {% endfor %}
15
    </ul>
16

17
    {% set foo=24 %}
18
    {% with foo=88 %}
19
        <p>在局部作用域中的值：{{ foo }}</p>
20
    {% endwith %}
21
        <p>在全局作用域中的值：{{ foo }}</p>
22
        {# with中的修改不会影响全局的内容 #}
23
        
24
</body>
25
</html>

模版继承

Flask中的模板可以继承，通过继承可以把模板中许多重复出现的元素抽取出来，放在父模板中，并且父模板通过定义block给子模板开一个口，子模板根据需要，再实现这个block，假设现在有一个base.html这个父模板，代码如下：


xxxxxxxxxx
18
1
<!DOCTYPE html>
2
<html lang="en">
3
<head>
4
    <link rel="stylesheet" href="base.css" />
5
    <title>{% block title %}{% endblock %}</title>
6
    {% block head %}
7
    <meta charset="UTF-8">
8
    {% endblock %}
9
</head>
10
<body>
11
    <div id="body">{% block body %}{% endblock %}</div>
12
    <div id="footer">
13
        {% block footer %}
14
        &copy; Copyright 2008 by <a href="http://domain.invalid/">you</a>
15
        {% endblock %}
16
    </div>
17
</body>
18
</html>

以上父模板中，抽取了所有模板都需要用到的元素html、body等，并且对于一些所有模板都要用到的样式文件style.css也进行了抽取，同时对于一些子模板需要重写的地方，比如title、head、body都定义成了block，然后子模板可以根据自己的需要，再具体的实现。以下再来看子模板的代码：


xxxxxxxxxx
17
1
{% extends "base.html" %}
2
{% block title %}首页{% endblock %}
3
{% block head %}
4
    {{ super() }}
5
    {# super()在原本head里面内容后面加上下面的内容 #}
6
    <style type="text/css">
7
        .detail{
8
            color: red;
9
        }
10
    </style>
11
{% endblock %}
12
{% block body %}
13
    <h1>这里是首页</h1>
14
    <p class="detail">
15
      首页的内容
16
    </p>
17
{% endblock %}

首先第一行就定义了子模板继承的父模板，并且可以看到子模板实现了title这个block，并填充了自己的内容，再看head这个block，里面调用了super()这个函数，这个函数的目的是执行父模板中的代码，把父模板中的内容添加到子模板中，如果没有这一句，则父模板中处在head这个block中的代码将会被子模板中的代码给覆盖掉。

另外，模板中不能出现重名的block，如果一个地方需要用到另外一个block中的内容，可以使用self.blockname的方式进行引用，比如以下示例：


xxxxxxxxxx
6
1
<title>
2
    {% block title %}
3
        这是标题
4
    {% endblock %}
5
</title>
6
<h1>{{ self.title() }}</h1>

以上示例中h1标签重用了title这个block中的内容，子模板实现了title这个block，h1标签也能拥有这个值。

另外，在子模板中，所有的文本标签和代码都要添加到从父模板中继承的block中。否则，这些文本和标签将不会被渲染。

转义

转义的概念是，在模板渲染字符串的时候，字符串有可能包括一些非常危险的字符比如<、>等，这些字符会破坏掉原来HTML标签的结构，更严重的可能会发生XSS跨域脚本攻击，因此如果碰到<、>这些字符的时候，应该转义成HTML能正确表示这些字符的写法，比如>在HTML中应该用<来表示等。

但是Flask中默认没有开启全局自动转义，针对那些以.html、.htm、.xml和.xhtml结尾的文件，如果采用render_template函数进行渲染的，则会开启自动转义。并且当用render_template_string函数的时候，会将所有的字符串进行转义后再渲染。而对于Jinja2默认没有开启全局自动转义，作者有自己的原因：

渲染到模板中的字符串并不是所有都是危险的，大部分还是没有问题的，如果开启自动转义，那么将会带来大量的不必要的开销。
Jinja2很难获取当前的字符串是否已经被转义过了，因此如果开启自动转义，将对一些已经被转义过的字符串发生二次转义，在渲染后会破坏原来的字符串。

在没有开启自动转义的模式下（比如以.conf结尾的文件），对于一些不信任的字符串，可以通过{{ content_html|e }}或者是{{ content_html|escape }}的方式进行转义。在开启了自动转义的模式下，如果想关闭自动转义，可以通过{{ content_html|safe }}的方式关闭自动转义。而{%autoescape true/false%}...{%endautoescape%}可以将一段代码块放在中间，来关闭或开启自动转义，例如以下代码关闭了自动转义：


xxxxxxxxxx
8
1
<h1>{{ name }}</h1>
2
<!-- 正常的变量值是会被转义的 -->
3

4
{% autoescape false %}
5
    <p>autoescaping is disabled here
6
    <p>{{ name }}
7
        <!-- 关闭转义以后，就不转义了 -->
8
{% endautoescape %}

数据类型和运算符

数据类型

Jinja支持许多数据类型，包括：字符串、整型、浮点型、列表、元组、字典、True/False。

运算符

+号运算符：可以完成数字相加，字符串相加，列表相加。但是并不推荐使用+运算符来操作字符串，字符串相加应该使用~运算符。
-号运算符：只能针对两个数字相减。
/号运算符：对两个数进行相除。
%号运算符：取余运算。
*号运算符：乘号运算符，并且可以对字符进行相乘。
**号运算符：次幂运算符，比如2**3=8。
in操作符：跟python中的in一样使用，比如{{1 in [1,2,3]}}返回true。
~号运算符：拼接多个字符串，比如{{"Hello" ~ "World"}}将返回HelloWorld。

静态文件的配置

Web应用中会出现大量的静态文件来使得网页更加生动美观。类似于CSS样式文件、JavaScript脚本文件、图片文件、字体文件等静态资源。在Jinja中加载静态文件非常简单，只需要通过url_for全局函数就可以实现，看以下代码：


xxxxxxxxxx
1
1
<link href="{{ url_for('static',filename='about.css') }}">

url_for函数默认会在项目根目录下的static文件夹中寻找about.css文件，如果找到了，会生成一个相对于项目根目录下的/static/about.css路径。当然我们也可以把静态文件不放在static文件夹中，此时就需要具体指定了，看以下代码：


xxxxxxxxxx
1
1
app = Flask(__name__,static_folder='C:\static')

那么访问静态文件的时候，将会到/static这个文件夹下寻找。