Flask内置的模板语言，它的设计思想来源于 Django 的模板引擎，并扩展了其语法和一系列强大的功能。

渲染模版函数

  • Flask提供的 render_template 函数封装了该模板引擎
  • render_template 函数的第一个参数是模板的文件名，后面的参数都是键值对，表示模板中变量对应的真实值。
  1. 在视图函数中设置渲染模板
  1. from flask import Flask, render_template
  2. @app.route('/')
  3. def index():
  4.     return render_template('index.html')
  1. 在项目下创建 templates 文件夹，用于存放所有的模板文件，并在目录下创建一个模板html文件 index.html 
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8. 我的模板html内容
  9. </body>
  10. </html>

{{}} 来表示变量名，这种 {{}} 语法叫做变量代码块

视图代码：

  1. @app.route("/")
  2. def index():
  3.     title = "网页标题"
  4.     return render_template("index.html",title=title)

模板代码

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>{{title}}</title>
  6. </head>
  7. <body>
  8.     <h1>{{title}}</h1>
  9. </body>
  10. </html>

Jinja2 模版中的变量代码块可以是任意 Python 类型或者对象，只要它能够被 Python 的 str() 方法转换为一个字符串就可以，比如，可以通过下面的方式显示一个字典或者列表中的某个元素:

  1. {{your_dict['key']}}
  2. {{your_list[0]}}

用 {%%} 定义的控制代码块，可以实现一些语言层次的功能，比如循环或者if语句

  1. {% if user %}
  2.     {{ user }}
  3. {% else %}
  4.     hello!
  5. <ul>
  6.     {% for index in indexs %}
  7.     <li> {{ index }} </li>
  8.     {% endfor %}
  9. </ul>

使用 {# #} 进行注释，注释的内容不会在html中被渲染出来

  1. {# {{ name }} #}

你可以在自己的模板中访问一些 Flask 默认内置的函数和对象

你可以从模板中直接访问Flask当前的config对象:

  1. {{config.SQLALCHEMY_DATABASE_URI}}
  2. sqlite:///database.db

就是flask中代表当前请求的request对象：

  1. {{request.url}}
  2. http://127.0.0.1

为Flask的session对象

  1. {{session.new}}
  2. True

在视图函数中设置g变量的 name 属性的值，然后在模板中直接可以取出

  1. {{ g.name }}

url_for会根据传入的路由器函数名,返回该路由对应的URL,在模板中始终使用url_for()就可以安全的修改路由绑定的URL,则不比担心模板中渲染出错的链接:

  1. {{url_for('home')}}

如果我们定义的路由URL是带有参数的,则可以把它们作为关键字参数传入url_for(),Flask会把他们填充进最终生成的URL中:

  1. {{ url_for('post', post_id=1)}}
  2. /post/1

主要包含两个：

  1. - if/else if /else / endif
  2. - for / endfor

Jinja2 语法中的if语句跟 Python 中的 if 语句相似,后面的布尔值或返回布尔值的表达式将决定代码中的哪个流程会被执行:

  1. {%if user.is_logged_in() %}
  2.     <a href='/logout'>Logout</a>
  3. {% else %}
  4.     <a href='/login'>Login</a>
  5. {% endif %}

过滤器可以被用在 if 语句中:

  1. {% if comments | length > 0 %}
  2.     There are {{ comments | length }} comments
  3. {% else %}
  4.     There are no comments
  5. {% endif %}
  • 我们可以在 Jinja2 中使用循环来迭代任何列表或者生成器函数
  1. {% for post in posts %}
  2.     <div>
  3.         <h1>{{ post.title }}</h1>
  4.         <p>{{ post.text | safe }}</p>
  5.     </div>
  6. {% endfor %}
  • 循环和if语句可以组合使用，以模拟 Python 循环中的 continue 功能，下面这个循环将只会渲染post.text不为None的那些post：
  1. {% for post in posts if post.text %}
  2.     <div>
  3.         <h1>{{ post.title }}</h1>
  4.         <p>{{ post.text | safe }}</p>
  5.     </div>
  6. {% endfor %}
  • 在一个 for 循环块中你可以访问这些特殊的变量:
变量 描述
loop.index 当前循环迭代的次数（从 1 开始）
loop.index0 当前循环迭代的次数（从 0 开始）
loop.revindex 到循环结束需要迭代的次数（从 1 开始）
loop.revindex0 到循环结束需要迭代的次数（从 0 开始）
loop.first 如果是第一次迭代，为 True 。
loop.last 如果是最后一次迭代，为 True 。
loop.length 序列中的项目数。
loop.cycle 在一串序列间期取值的辅助函数。见下面示例程序。
  • 在循环内部,你可以使用一个叫做loop的特殊变量来获得关于for循环的一些信息
    • 比如：要是我们想知道当前被迭代的元素序号，并模拟Python中的enumerate函数做的事情，则可以使用loop变量的index属性,例如:
  1. {% for post in posts%}
  2. {{loop.index}}, {{post.title}}
  3. {% endfor %}
  • 会输出这样的结果
  1. 1, Post title
  2. 2, Second Post
  • cycle函数会在每次循环的时候,返回其参数中的下一个元素,可以拿上面的例子来说明:
  1. {% for post in posts%}
  2. {{loop.cycle('odd','even')}} {{post.title}}
  3. {% endfor %}
  • 会输出这样的结果：
  1. odd Post Title
  2. even Second Post

过滤器的本质就是函数。有时候我们不仅仅只是需要输出变量的值，我们还需要修改变量的显示，甚至格式化、运算等等，而在模板中是不能直接调用 Python 中的某些方法，那么这就用到了过滤器。

使用方式：

  • 过滤器的使用方式为：变量名 | 过滤器。
  1. {{variable | filter_name(*args)}}
  • 如果没有任何参数传给过滤器,则可以把括号省略掉
  1. {{variable | filter_name }}
  • 如：“，这个过滤器的作用：把变量variable 的值的首字母转换为大写，其他字母转换为小写

在 jinja2 中，过滤器是可以支持链式调用的，示例如下：

  1. {{ "hello world" | reverse | upper }}
  • safe：禁用转义
  1. <p>{{ '<em>hello</em>' | safe }}</p>
  • capitalize：把变量值的首字母转成大写，其余字母转小写
  1. <p>{{ 'hello' | capitalize }}</p>
  • lower：把值转成小写
  1. <p>{{ 'HELLO' | lower }}</p>
  • upper：把值转成大写
  1. <p>{{ 'hello' | upper }}</p>
  • title：把值中的每个单词的首字母都转成大写
  1. <p>{{ 'hello' | title }}</p>
  • reverse：字符串反转
  1. <p>{{ 'olleh' | reverse }}</p>
  • format：格式化输出
  1. <p>{{ '%s is %d' | format('name',17) }}</p>
  • striptags：渲染之前把值中所有的HTML标签都删掉
  1. <p>{{ '<em>hello</em>' | striptags }}</p>
  • truncate: 字符串截断
  1. <p>{{ 'hello every one' | truncate(9)}}</p>
  • first：取第一个元素
  1. <p>{{ [1,2,3,4,5,6] | first }}</p>
  • last：取最后一个元素
  1. <p>{{ [1,2,3,4,5,6] | last }}</p>
  • length：获取列表长度
  1. <p>{{ [1,2,3,4,5,6] | length }}</p>
  • sum：列表求和
  1. <p>{{ [1,2,3,4,5,6] | sum }}</p>
  • sort：列表排序
  1. <p>{{ [6,2,3,1,5,4] | sort }}</p>
  1. {% filter upper %}
  2.     #一大堆文字#
  3. {% endfilter %}

过滤器的本质是函数。当模板内置的过滤器不能满足需求，可以自定义过滤器。自定义过滤器有两种实现方式：

  • 一种是通过Flask应用对象的 add_template_filter 方法
  • 通过装饰器来实现自定义过滤器

重要：自定义的过滤器名称如果和内置的过滤器重名，会覆盖内置的过滤器。

需求：添加列表反转的过滤器

方式一

通过调用应用程序实例的 add_template_filter 方法实现自定义过滤器。该方法第一个参数是函数名，第二个参数是自定义的过滤器名称：

  1. def do_listreverse(li):
  2.     # 通过原列表创建一个新列表
  3.     temp_li = list(li)
  4.     # 将新列表进行返转
  5.     temp_li.reverse()
  6.     return temp_li
  8. app.add_template_filter(do_listreverse,'lireverse')

方式二

用装饰器来实现自定义过滤器。装饰器传入的参数是自定义的过滤器名称。

  1. @app.template_filter('lireverse')
  2. def do_listreverse(li):
  3.     # 通过原列表创建一个新列表
  4.     temp_li = list(li)
  5.     # 将新列表进行返转
  6.     temp_li.reverse()
  7.     return temp_li
  • 在 html 中使用该自定义过滤器
  1. <br/> my_array 原内容：{{ my_array }}
  2. <br/> my_array 反转：{{ my_array | lireverse }}
  • 运行结果
  1. my_array 原内容：[3, 4, 2, 1, 7, 9] 
  2. my_array 反转：[9, 7, 1, 2, 4, 3]

在模板中，可能会遇到以下情况：

  • 多个模板具有完全相同的顶部和底部内容
  • 多个模板中具有相同的模板代码内容，但是内容中部分值不一样
  • 多个模板中具有完全相同的 html 代码块内容

像遇到这种情况，可以使用 JinJa2 模板中的 继承 来进行实现

模板继承是为了重用模板中的公共内容。一般Web开发中，继承主要使用在网站的顶部菜单、底部。这些内容可以定义在父模板中，子模板直接继承，而不需要重复书写。

  • 标签定义的内容
  1. {% block top %} {% endblock %}
  • 相当于在父模板中挖个坑，当子模板继承父模板时，可以进行填充。
  • 子模板使用 extends 指令声明这个模板继承自哪个模板
  • 父模板中定义的块在子模板中被重新定义，在子模板中调用父模板的内容可以使用super()

父模板代码：

base.html

  1. {% block top %}
  2.   顶部菜单
  3. {% endblock top %}
  5. {% block content %}
  6. {% endblock content %}
  8. {% block bottom %}
  9.   底部
  10. {% endblock bottom %}

子模板代码：

  • extends指令声明这个模板继承自哪
  1. {% extends 'base.html' %}
  2. {% block content %}
  3.  需要填充的内容
  4. {% endblock content %}

模板继承使用时注意点：

  1. 不支持多继承
  2. 为了便于阅读，在子模板中使用extends时，尽量写在模板的第一行。
  3. 不能在一个模板文件中定义多个相同名字的block标签。
  4. 当在页面中使用多个block标签时，建议给结束标签起个名字，当多个block嵌套时，阅读性更好。

config.py

  1. class Config(object):
  2.     DEBUG = True
  3.     SECRET_KEY = "abcccddgadsag"

main.py

  1. from flask import Flask
  2. from config import Config
  3. from flask import render_template
  5. app = Flask(__name__,template_folder='templates')
  6. app.config.from_object(Config)
  8. from flask import session
  9. @app.route("/set_session")
  10. def set_session():
  11.     session["username"] = 'request数据'
  12.     return "ok"
  16. from flask import g
  17. @app.route("/")
  18. def index():
  19.     title = "网页标题"
  20.     dict1 = {"id":1,"username":"xiaoming","money":20.5}
  21.     love  = ['睡觉','吹牛','敲代码']
  22.     g.list1 = ['睡觉','吹牛','敲代码']
  23.     g.book_list = [
  24.         {"id":1,"name":"浪潮之巅","price":88.5},
  25.         {"id":12,"name":"数学之美","price":68.5},
  26.         {"id":12,"name":"数学之美","price":68.5},
  27.         {"id":12,"name":"数学之美","price":68.5},
  28.         {"id":13,"name":"硅谷之谜","price":108.533333},
  29.         {"id":14,"name":"五年高考三年模拟","price":78.5},
  30.     ]
  32.     g.title2 = '<script>alert("大标题")</script>'
  33.     g.question = '如果x=10,x<y,y>z,求z的取值范围?'
  35.     return render_template("index.html",title=title,dict1=dict1,love=love)
  37. """自定义过滤器"""
  39. def rev(data):
  40.     data.reverse()
  41.     return data
  43. app.add_template_filter(rev,'myrev')
  45. @app.route("/filter")
  46. def myfilter():
  48.     g.list1 = ['睡觉', '吹牛', '敲代码']
  50.     return render_template("f.html")
  52. if __name__ == '__main__':
  53.     app.run()

index.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>{{title}}</title>
  6. </head>
  7. <body>
  8.     <h1>{{title}}</h1>
  9.     <table border="1" width="400">
  10.         <tr>
  11.             <th>ID</th>
  12.             <th>姓名</th>
  13.             <th>存款</th>
  14.         </tr>
  15.         <tr>
  16.             <td>{{ dict1["id"] }}</td>
  17.             <td>{{ dict1["username"] }}</td>
  18.             <td>{{ dict1["money"] }}</td>
  19.         </tr>
  20.         <tr>
  21.             <td>{{ dict1.id }}</td>
  22.             <td>{{ dict1.username }}</td>
  23.             <td>{{ dict1.money }}</td>
  24.         </tr>
  25.     </table>
  26.     <ul>
  27.         <li>{{ love.0 }}</li>
  28.         <li>{{ love.1 }}</li>
  29.         <li>{{ love.2 }}</li>
  31.         <li>{{ love[0] }}</li>
  32.         <li>{{ love[1] }}</li>
  33.         <li>{{ love[2] }}</li>
  35.         {# for循环也支持多层的嵌套或者其他语句 #}
  36.         {% for item in love %}
  37.         <li>{{ item }}</li>
  38.         {% endfor %}
  40.     </ul>
  42.     {# 这里是if判断,if还可以支持多个条件的判断 #}
  43.     {% if dict1.money < 20 %}
  44.         <p>存款太少了,需要充值</p>
  45.     {% endif %}
  47.     {# 特殊变量 #}
  48.     {# 支持直接读取配置信息 #}
  49.     <p>{{ config.SECRET_KEY }}</p>
  51.     {# 支持获取请求信息 #}
  52.     <p>{{ request.method }}</p>
  54.     {# 支持获取session数据 #}
  55.     <p>{{ session.username }}</p>
  57.     {# 支持获取g变量 #}
  58.     <p>{{ g.list1 }}</p>
  60.     {# 支持使用url_for生成地址 #}
  61.     <a href="{{ url_for("set_session") }}">跳转到sesion</a>
  63.     {# for循环中还内置了循环对象loop,可以操作循环过程中的索引 #}
  64.     <table border="1" width="600">
  65.         <tr>
  66.             <th>序号</th>
  67.             <th>ID</th>
  68.             <th>书名</th>
  69.             <th>价格</th>
  70.         </tr>
  71.         {% for book in g.book_list %}
  72.         {% if loop.first %}
  73.         <tr style="background-color: orange;">
  74.         {% elif loop.last %}
  75.         <tr style="background-color: blue;color: #fff;">
  76.         {% else %}
  77.         <tr>
  78.         {% endif %}
  79.             <td>{{ loop.revindex }}</td>
  80.             <td>{{ "%03d" % book.id  }}</td>
  81.             <td>{{ book.name }}</td>
  82.             <td>{{ book.price }}</td>
  83.         </tr>
  84.         {% endfor %}
  85.     </table>
  87.     {# 过滤器 #}
  88.     {{ dict1.username | upper | reverse }}
  90.     {#
  91.        默认情况下, flask会自动针对html标签进行实体化转移,目的时为了防止xss攻击
  92.        但是,我们后端也会有一些包含样式的内容要输出页面中,此时可以使用 safe 过滤器
  93.      #}
  94.     {{ g.title2 | safe }}
  96.     {# 这个过滤器会直接删除html标签,也是为了防止xss攻击,但是这个过滤器慎用,在遇到数学公式的时候,会误伤. #}
  97.     {{ g.title2 | striptags }}
  98.     {{ g.question | striptags }}
  101.     {# 字符长度截取 #}
  102.     <p>{{ 'hello every one' | truncate(9)}}</p>
  104. {% filter upper %}
  105. dasdasd
  106. dsa
  107. das
  108. ds
  109. ad
  110. <p>{{ 'hello every one' | truncate(9)}}</p>
  111. asd
  112. asdas
  113. {% endfilter %}
  115. {{ "hwello" }}
  117. </body>
  118. </html>

在 Flask 中， Flask-wtf 扩展有一套完善的 csrf 防护体系，对于我们开发者来说，使用起来非常简单

1 设置应用程序的 secret_key，用于加密生成的 csrf_token 的值

  1. # session加密的时候已经配置过了.如果没有在配置项中设置,则如下:
  2. app.secret_key = "#此处可以写随机字符串#"

2 导入 flask_wtf.csrf 中的 CSRFProtect 类，进行初始化，并在初始化的时候关联 app

  1. from flask.ext.wtf import CSRFProtect
  2. CSRFProtect(app)

3 在表单中使用 CSRF 令牌:

  1. <form method="post" action="/">
  2.     <input type="hidden" name="csrf_token" value="{{ csrf_token() }}" />
  3. </form>

版权声明：本文为Sunzz原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/Sunzz/p/10959471.html