如何使用jinja2和flask在html页面上显示消息？（flask加载静态html）

25-03-11 14

如果您对如何使用jinja2和flask在html页面上显示消息？和flask加载静态html感兴趣，那么这篇文章一定是您不可错过的。我们将详细讲解如何使用jinja2和flask在html页面上显示

如果您对如何使用jinja2和flask在html页面上显示消息？和flask加载静态html感兴趣，那么这篇文章一定是您不可错过的。我们将详细讲解如何使用jinja2和flask在html页面上显示消息？的各种细节，并对flask加载静态html进行深入的分析，此外还有关于flask Jinja2怎么使用、Flask 的 jinja2 模板、Flask-jinja2、flask中jinjia2模板的使用（二）的实用技巧。

本文目录一览：

如何使用jinja2和flask在html页面上显示消息？（flask加载静态html）
flask Jinja2怎么使用
Flask 的 jinja2 模板
Flask-jinja2
flask中jinjia2模板的使用（二）

如何使用jinja2和flask在html页面上显示消息？（flask加载静态html）

如何解决如何使用jinja2和flask在html页面上显示消息？？

我想在html页面上打印消息方法。是在构造函数里面，但是print()函数只在终端运行。

s=bt.Strategy("s1",[bt.algos.SelectAll(),bt.algos.RunQuarterly,bt.algos.WeighTarget(weights),bt.algos.Rebalance()])

test=bt.Backtest(s,data_bt)
res=bt.run(test)

使用return，我可以，但它不能解决所有情况。在构造函数中，我想传递一个 ''{% include ''cabecalho.html'' %} <body> <img src="/static/img/logo.png" width="25%"> <hr> {% block conteudo %} {% set character1 = character(name=''Arqueiro das Sombas'',vocation=''Paladin'',level=32) %} {{ character1.name }} {{ character1.vocation }} {{ character1.level }} {{ character1.getvocation() }} {% set character2 = character(name=''Mordoc Cery'',vocation=''Knight'',level=19) %} {{ character2.getname() }} {{ character2.messagem(name=character2.getname(),vocation=character2.getvocation(),level=character2.getlevel()) }} {{ character2.promotion(level=character2.getlevel(),vocation=character2.getvocation()) }} {% endblock %} </body> {% include ''rodape.html'' %}'' 方法。在方法“messagem”中，类似 return 的东西不会执行整个函数。

promotion

解决方法

暂无找到可以解决该程序问题的有效方法，小编努力寻找整理中！

如果你已经找到好的解决方法，欢迎将解决方案带上本链接一起发送给小编。

小编邮箱:dio#foxmail.com (将#修改为@）

flask Jinja2怎么使用

本篇内容介绍了“flask Jinja2怎么使用”的有关知识，在实际案例的操作过程中，不少人都会遇到这样的困境，接下来就让小编带领大家学习一下如何处理这些情况吧！希望大家仔细阅读，能够学有所成！

1. 什么是Jinja2模板引擎

要了解jinja2，那么需要先理解模板的概念。模板在Python的web开发中广泛使用，它能够有效的将业务逻辑和页面逻辑分开，使代码可读性增强、并且更加容易理解和维护。

　　模板简单来说就是一个其中包涵占位变量表示动态的部分的文件，模板文件在经过动态赋值后，返回给用户。 --> 可以理解为渲染

　　python中自带一个简单的模板，就是string提供的。

>>> import string

>>> a = string.Template('$who is $role')

>>> a.substitute(who='daxin',role='Linux')

'daxin is Linux'

>>> a.substitute(who='daxin',role='cat')

'daxin is cat'

>>>

Python自带的模板功能极其有限，如果我们想要在模板中使用控制语句，和表达式，以及继承等功能的话，就无法实现了。

　　目前主流的模板系统，最常用的就是jinja2和mako

jinja2介绍

　　jinja2是Flask作者开发的一个模板系统，起初是仿django模板的一个模板引擎，为Flask提供模板支持，由于其灵活，快速和安全等优点被广泛使用。

jinja2的优点

　　jinja2之所以被广泛使用是因为它具有以下优点：

相对于Template，jinja2更加灵活，它提供了控制结构，表达式和继承等。
相对于Mako，jinja2仅有控制结构，不允许在模板中编写太多的业务逻辑。
相对于Django模板，jinja2性能更好。
Jinja2模板的可读性很棒。

安装jinja2

　　由于jinja2属于第三方模块，首先需要对其进行安装

pip3 install jinja2

测试模板是否安装成功

python -c "import jinja2"

# 没有报错就表示安装成功

# 必须用双引号"

jinja2语法

　　作为一个模板系统，它还提供了特殊的语法，我们按照它支持的语法进行编写之后，就能使用jinja2模块进行渲染。

基本语法

　　在jinja2中，存在三种语法：

控制结构 {% %}
变量取值 {

{ }}
注释 {# #}

　　下面是一个简单的jinja2例子

{# This is jinja code


    {% for file in filenames %}

    ...

    {% endfor %}


#}

可以看到，for循环的使用方式和Python比较类似，但是没有了句尾的冒号，另外需要使用endfor最为结尾，其实在jinja2中，if也是一样的，结尾需要使用endif。

jinja2变量

　　jinja2模板中使用 { { }} 语法表示一个变量，它是一种特殊的占位符。当利用jinja2进行渲染的时候，它会把这些特殊的占位符进行填充/替换，jinja2支持python中所有的Python数据类型比如列表、字段、对象等。

<p>this is a dicectory:{
  
  
  { mydict['key'] }} </p>

<p>this is a list:{
  
  
  { mylist[3] }} </p>

<p>this is a object:{
  
  
  { myobject.something() }} </p>

jinja2中的过滤器

　　变量可以通过“过滤器”进行修改，过滤器可以理解为是jinja2里面的内置函数和字符串处理函数。

　　常用的过滤器有：

过滤器名称	说明
safe	渲染时值不转义
capitialize	把值的首字母转换成大写，其他子母转换为小写
lower	把值转换成小写形式
upper	把值转换成大写形式
title	把值中每个单词的首字母都转换成大写
trim	把值的首尾空格去掉
striptags	渲染之前把值中所有的HTML标签都删掉
join	拼接多个值为字符串
replace	替换字符串的值
round	默认对数字进行四舍五入，也可以用参数进行控制
int	把值转换成整型

　　那么如何使用这些过滤器呢？只需要在变量后面使用管道(|)分割，多个过滤器可以链式调用，前一个过滤器的输出会作为后一个过滤器的输入。

{
  
  
  { 'abc' | captialize  }}

# Abc


{
  
  
  { 'abc' | upper  }}

# ABC
 

{
  
  
  { 'hello world' | title  }}

# Hello World


{
  
  
  { "hello world" | replace('world','daxin') | upper }}

# HELLO DAXIN

 
{
  
  
  { 18.18 | round | int }}

# 18

jinja2的控制结构

　　jinja2中的if语句类似与Python的if语句，它也具有单分支，多分支等多种结构，不同的是，条件语句不需要使用冒号结尾，而结束控制语句，需要使用endif关键字。

{% if daxin.safe %}

daxin is safe.

{% elif daxin.dead %}

daxin is dead

{% else %}

daxin is okay

{% endif %}

jinja2的for循环

　　jinja2中的for循环用于迭代Python的数据类型，包括列表，元组和字典。在jinja2中不存在while循环。

　　迭代列表

<ul>

{% for user in users %}

<li>{
  
  
  { user.username|title }}</li>

{% endfor %}

</ul>

迭代字典

<dl>

{% for key, value in my_dict.iteritems() %}

<dt>{
  
  
  { key }}</dt>

<dd>{
  
  
  { value}}</dd>

{% endfor %}

</dl>

当然也可以加入else语句，在循环正确执行完毕后，执行

在for循环中，jinja2还提供了一些特殊的变量，用以来获取当前的遍历状态：

变量	描述
loop.index	当前迭代的索引（从1开始）
loop.index0	当前迭代的索引（从0开始）
loop.first	是否是第一次迭代，返回bool
loop.last	是否是最后一次迭代，返回bool
loop.length	序列中的项目数量
loop.revindex	到循环结束的次数（从1开始）
loop.revindex0	到循环结束的次数(从0开始）

jinja2的宏

　　宏类似于Python中的函数，我们在宏中定义行为，还可以进行传递参数，就像Python中的函数一样一样儿的。

　　在宏中定义一个宏的关键字是macro，后面跟其宏的名称和参数等

{% macro input(name,age=18) %}   # 参数age的默认值为18

 <input type='text' name="{
  
  
  { name }}" value="{
  
  
  { age }}" >

{% endmacro %}

调用方法也和Python的类似

<p>{
  
  
  { input('daxin') }} </p>

<p>{
  
  
  { input('daxin',age=20) }} </p>

jinja2的继承和Super函数

　　jinja2中最强大的部分就是模板继承。模板继承允许我们创建一个基本(骨架)文件，其他文件从该骨架文件继承，然后针对自己需要的地方进行修改。

　　jinja2的骨架文件中，利用block关键字表示其包涵的内容可以进行修改。

　　以下面的骨架文件base.html为例：

<!DOCTYPE html>

<html lang="en">

<head>

    {% block head %}

    <link rel="stylesheet" href="style.css"/>

    <title>{% block title %}{% endblock %} - My Webpage</title>

    {% endblock %}

</head>

<body>

<div id="content">{% block content %}{% endblock %}</div>

<div id="footer">

    {% block  footer %}

    <script>This is javascript code </script>

    {% endblock %}

</div>

</body>

</html>

这里定义了四处 block，即：head，title，content，footer。那怎么进行继承和变量替换呢？注意看下面的文件

{% extend "base.html" %}       # 继承base.html文件

{% block title %} Dachenzi {% endblock %}   # 定制title部分的内容

{% block head %}

    {
  
  
  {  super()  }}        # 用于获取原有的信息

    <style type='text/css'>

    .important { color: #FFFFFF }

    </style>

{% endblock %}   

# 其他不修改的原封不同的继承

　PS: super()函数表示获取block块中定义的原来的内容。

利用jinja2进行渲染

　　jinja2模块中有一个名为Enviroment的类，这个类的实例用于存储配置和全局对象，然后从文件系统或其他位置中加载模板。

基本使用方法

　　大多数应用都在初始化的时候撞见一个Environment对象，并用它加载模板。Environment支持两种加载方式：

PackageLoader：包加载器
FileSystemloader：文件系统加载器

PackageLoader

　　使用包加载器来加载文档的最简单的方式如下：

from jinja2 import PackageLoader,Environment

env = Environment(loader=PackageLoader('python_project','templates'))    # 创建一个包加载器对象

template = env.get_template('bast.html')    # 获取一个模板文件

template.render(name='daxin',age=18)   # 渲染

其中：

PackageLoader()的两个参数为：python包的名称，以及模板目录名称。

render()：接受变量，对模板进行渲染

get_template()：获取模板目录下的某个具体文件。

FileSystemloader

　　文件系统加载器，不需要模板文件存在某个Python包下，可以直接访问系统中的文件

“flask Jinja2怎么使用”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注小编网站，小编将为大家输出更多高质量的实用文章！

Flask 的 jinja2 模板

还记的 “第一个 Flask 程序”这一小节中我们直接在 Python 源程序中直接返回一段 HTML 字符串，就可以在浏览器中看到效果，但是如果我们的 HTML 特别复杂呢？我们还能使用这样的形式吗？

答案是不行的，如果你的 HTML 特别复杂仍然使用这样的方法会造成你的后端程序非常的混乱，Python 代码和 HTML 代码混杂在一起，程序的可阅读行非常差。

本节课我们将会使用一个叫做 Jinja2 的东西来解决上面提到的问题。

Tips：本节课所有的代码已经上传到了 Github，可以点击这里进行下载。

1. 模板简介

1.1 简介

浏览器访问网站时，服务端通常会返回一个包含各类信息的 html 页面。因为网页是动态的，页面中的某些信息需要根据不同的情况来进行调整，比如对登录和未登录用户显示不同的信息，所以页面需要在用户访问时根据程序逻辑动态生成。

把包含变量和运算逻辑的 html 或其他格式的文本叫做模板，执行这些变量替换和逻辑计算工作的过程被称为渲染，在 Flask 中，这个工作由模板渲染引擎——jinja2 来完成。

1.2 一个具体的例子

以下是一个 jinja2 的模板，它对登录和未登录用户显示不同的信息:

<html>
{% if login %}
  <p>你好，{{name}}</p>
{% else %}
  <a href=''/login''>登录</a>
{% endif %}
</html>

如果用户已经登录：变量 login 为真、变量 name 为 tom，模板被渲染成如下的 html 文件：

<html>
  <p>你好，tom</p>
</html>

如果用户没有登录：变量 login 为假，模板被渲染成如下的 html 文件：

<html>
  <a href=''/login''>登录</a>
</html>

2. 在 Flask 中使用模板

本节通过一个具体的例子讲解如何在 Flask 中使用 jinja2 模板。

2.1 目录结构

程序包含有两个源文件: app.py 和 index.html，目录结构如下：

图片描述

app.py 是 Flask 程序，将渲染后的模板返回给浏览器；templates 是存放模板的目录，它和 app.py 位于相同的目录；templates/index.html 是模板文件。

2.2 编写 `app.py`

from flask import Flask, render_template
app = Flask(__name__)

@app.route(''/'')
def index():
    return render_template(''index.html'', name = ''tom'', age = )

app.run(debug = True)

在第 1 行，从模块 flask 中导入函数 render_template，该函数将 jinja2 模板渲染为 html；在第 3 行，编写路径 / 的处理函数 index()，调用 render_template，对模板 templates/index.html 进行渲染。

render_template 包含有 2 个命名参数：name 和 age，模板引擎将模板 templates/index.html 中的变量进行替换。

2.3 编写模板文件 templates/index.html

<html>
<body>
  <h2>My name is {{ name }}, I am {{ age }} years old</h2>
</body>
</html>

模板文件中的 {{ name }} 和 {{ age }} 被称为 jinja2 变量。render_template 包含有两个命名参数: name 和 age，{{ name }} 被替换为 name，{{ age }} 被替换为 age，最后渲染的 html 如下：

<html>
<body>
  <h2>My name is tom, I am 10 years old</h2>
</body>
</html>

在浏览器中显示如下：

图片描述

3. 分界符

jinja2 模板文件混合 html 语法与 jinja2 语法，使用分界符区分 html 语法与 jinja2 语法。有 5 种常见的分界符：

{{ 变量 }}，将变量放置在 {{ 和 }} 之间；
{% 语句 %}，将语句放置在 {% 和 %} 之间；
# 语句，将语句放置在 # 之后；
{# 注释 #}，将注释放置在 {# 和 #} 之间；
## 注释，将注释放置在 # 之后。

以下模板文件包含了所有常见的分界符：

<!DOCTYPE html>
<html lang="en">
<body>
  {{ variable }}    

  <ul>
  {% for item in seq %}
    <li>{{ item }}</li>
  {% endfor %}
  </ul>

  <ul>
  # for item in seq
    <li>{{ item }}</li>
  # endfor
  </ul>

  {# this is comment #}
  ## this is comment
</body>
</html>

4. 变量

1. 语法

jinja2 模板中，使用 {{ 和 }} 包围的标识符称为变量，模板渲染会将其替换为 Python 中的变量，语法如下：

 {{ 变量 }}

2. jinja2 模板

定义演示变量功能的模板：

<html>
{{ string }}

<ul>
  <li> {{ list[0] }}
  <li> {{ list[0] }}
  <li> {{ list[1] }}
</ul>    

<ul>
  <li> {{ dict[''name''] }}
  <li> {{ dict[''age''] }}
</ul>    
</html>

包含有 3 种类型的变量：字符串、列表、字典，它们会被替换为同名的 Python 变量。

3. jinja2 的模板输入

string = ''www.imooc.com''
list = [''www'', ''imooc'', ''com'']
dict = {''name'': ''zhangsan'', ''age'': }

4. 渲染后的 HTML

<html>
www.imooc.com

<ul>
  <li> www
  <li> www
  <li> imooc
</ul>    

<ul>
  <li> zhangsan
  <li> 12
</ul>

5. for 语句

1. 语法

jinja2 模板中，使用 {% 和 %} 包围的语法块称为语句，jinja2 支持类似于 Python 的 for 循环语句，语法如下：

{% for item in iterable %}
{% endfor %}

或者

# for item in iterable
# endfor

以上两者是等价的。

2. jinja2 模板

定义一个演示 for 循环语句功能的模板：

<h1>Members</h1>
<ul>
{% for user in users %}
  <li>{{ user }}</li>
{% endfor %}
</ul>

在第 3 行，定义 for 循环语句，遍历列表 users；在第 4 行，在循环体中使用 {{ user }} 引用当前正在被遍历的元素。

3. jinja2 的模板输入

users = [''tom'', ''jerry'', ''mike'']

4. 渲染后的 HTML

<h1>Members</h1>
<ul>
  <li>tom</li>
  <li>jerry</li>
  <li>mike</li>
</ul>

6. if 语句

1. 语法

jinja2 模板中，使用 {% 和 %} 包围的语法块称为语句，jinja2 支持类似于 Python 的 if-else 判断语句，语法如下：

{% if cond %}
{% else %}
{% endif %}

jinja2 支持类似于 Python 的 if-elif 判断语句，语法如下：

{% if cond %}
{% elif cond %}
{% endif %}

2. jinja2 模板

定义一个演示 if 语句功能的模板：

<html>
{% if a %}
  <p>a is True</p>
{% else %}
  <p>a is False</p>
{% endif %}

{% if b %}
  <p>b is True</p>
{% elif c %}
  <p>b is False, and c is True</p>
{% endif %}
</html>

在模板中根据变量 a、b、c 的取值生成不同的内容。

3. jinja2 的模板输入

a = False
b = False
c = True

4. 渲染后的 html


<html>
  <p>a is False</p>
  <p>b is False, and c is True</p>
</html>

7. 测试

1. 语法

jinja2 提供的 tests 可以用来在语句里对变量或表达式进行测试，语法如下：

{% variable is test %}

完整的 test 请参考 https://jinja.palletsprojects.com/en/master/templates/#builtin-tests，部分的 test 如下：

test 名称	功能
defined	变量是否已经定义
boolean	变量的类型是否是 boolean
integer	变量的类型是否是 integer
float	变量的类型是否是 float
string	变量是否是 string
mapping	变量的类型是否是字典
sequence	变量的类型是否是序列
even	变量是否是偶数
odd	变量是否是奇数
lower	变量是否是小写
upper	变量是否是大写

2. jinja2 模板

定义一个演示 test 功能的模板：

<html>
{% if number is odd %}
  <p> {{ number }} is odd
{% else %}
  <p> {{ number }} is even
{% endif %}

{% if string is lower %}
  <p> {{ string }} is lower
{% else %}
  <p> {{ string }} is upper
{% endif %}
</html>

在第 2 行，number is odd 测试 number 是否为奇数；在第 8 行，string is lower 测试 string 是否为小写。

3. jinja2 的模板输入

number = 
string = ''HELLO''

4. 渲染后的 html

<html>
  <p> 404 is even
  <p> HELLO is upper
</html>

8. 过滤器

1. 语法

jinja2 过滤器的是一个函数，语法如下：

{{ variable | filter }}

执行函数调用 filter(varialbe)，把函数返回值作为这个代码块的值。

在词条 “jinja2 模板过滤器的使用” 中，详细讲解过滤器，本节仅仅给出一个简单例子。

2. jinja2 模板

<html>
{{ string | upper }}
</html>

3. jinja2 的模板输入

string = ''hello''

4. 渲染后的 html

<html>
HELLO
</html>

9. 小结

本节讲解 Flask 的默认模板语言 jinja2，通过具体的例子讲解了 jinja2 中的变量、if 语句、for 语句等概念，使用思维导图概括如下：

图片描述

Flask-jinja2

渲染数据

数据准备

后端定义几个字符串,用于传递到前端

STUDENT = {''name'': ''Old'', ''age'': 38, ''gender'': ''中''},

STUDENT_LIST = [
    {''name'': ''Old'', ''age'': 38, ''gender'': ''中''},
    {''name'': ''Boy'', ''age'': 73, ''gender'': ''男''},
    {''name'': ''EDU'', ''age'': 84, ''gender'': ''女''}
]

STUDENT_DICT = {
    1: {''name'': ''Old'', ''age'': 38, ''gender'': ''中''},
    2: {''name'': ''Boy'', ''age'': 73, ''gender'': ''男''},
    3: {''name'': ''EDU'', ''age'': 84, ''gender'': ''女''},
}

Jinja2模板中的流程控制

逻辑语法

Jinja2模板语言中的 for

{% for foo in g %}

{% endfor %}

Jinja2模板语言中的 if

{% if g %}

{% elif g %}
    
{% else %}
    
{% endif %}

变量

{{}}

接下来,我们对这几种情况分别进行传递,并在前端显示成表格

1. 使用STUDENT字典传递至前端

前端页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<table border="1px">
    <thead>
        <tr>
            <th>姓名</th>
            <th>年龄</th>
            <th>性别</th>
        </tr>
    </thead>
    <tbody>
        {% for foo in stu %}
            <tr>
                <td>{{ foo.name }}</td>
                <td>{{ foo.age }}</td>
                <td>{{ foo.gender }}</td>
            </tr>
        {% endfor %}
    </tbody>
</table>
</body>
</html>

后端代码

from flask import Flask,render_template,request
app = Flask(__name__)
STUDENT = {''name'': ''Old'', ''age'': 38, ''gender'': ''中''},

@app.route(''/login'',methods=["POST","GET"])
def login():
    if request.method == "GET":
        return render_template("login.html",stu=STUDENT)

if __name__ == ''__main__'':
    app.run("0.0.0.0", 9876)

2. STUDENT_LIST 列表传入前端Jinja2 模板的操作

前端页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<table border="1px">
    <thead>
        <tr>
            <th>姓名</th>
            <th>年龄</th>
            <th>性别</th>
        </tr>
    </thead>
    <tbody>
        {% for foo in stu %}
            <tr>
                <td>{{ foo.get("name") }}</td>
                <td>{{ foo.age }}</td>
                <td>{{ foo["gender"] }}</td>
            </tr>
        {% endfor %}

    </tbody>
</table>

</body>
</html>

上面我们用了三种取值方式,这里foo就是每个字典

后端代码

from flask import Flask,render_template,request
app = Flask(__name__)

STUDENT_LIST = [
    {''name'': ''Old'', ''age'': 38, ''gender'': ''中''},
    {''name'': ''Boy'', ''age'': 73, ''gender'': ''男''},
    {''name'': ''EDU'', ''age'': 84, ''gender'': ''女''}
]

@app.route(''/login'',methods=["POST","GET"])
def login():
    if request.method == "GET":
        return render_template("login.html",stu=STUDENT_LIST)

if __name__ == ''__main__'':
    app.run("0.0.0.0", 9876)

3.STUDENT_DICT 大字典传入前端 Jinja2 模板

前端页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<table border="1px">
    <thead>
        <tr>
            <th>序号</th>
            <th>姓名</th>
            <th>年龄</th>
            <th>性别</th>
        </tr>
    </thead>
    <tbody>
        {% for foo in stu %}
            <tr>
                <td>{{ foo }}</td>
                <td>{{ stu.get(foo).name }}</td>
                <td>{{ stu.get(foo).age }}</td>
                <td>{{ stu.get(foo).gender }}</td>

            </tr>
        {% endfor %}

    </tbody>
</table>

</body>
</html>

后端代码

from flask import Flask,render_template,request
app = Flask(__name__)

STUDENT_DICT = {
    1: {''name'': ''Old'', ''age'': 38, ''gender'': ''中''},
    2: {''name'': ''Boy'', ''age'': 73, ''gender'': ''男''},
    3: {''name'': ''EDU'', ''age'': 84, ''gender'': ''女''},
}
@app.route(''/login'',methods=["POST","GET"])
def login():
    if request.method == "GET":
        return render_template("login.html",stu=STUDENT_DICT)

if __name__ == ''__main__'':
    app.run("0.0.0.0", 9876)

在遍历字典的时候,foo 其实是相当于拿出了字典中的Key

Markup

该方法和django中的safe一样都是防止xss攻击、

from flask import Flask,render_template,request
from markupsafe import Markup

app = Flask(__name__)

@app.route(''/login'',methods=["POST","GET"])
def login():
    if request.method == "GET":
        my_in = Markup("<input type=''text'' name=''uname''>")
        return render_template("login.html",ss=my_in)

if __name__ == ''__main__'':
    app.run("0.0.0.0", 9876)

前端页面生成的标签：

<input type="text" name="uname">

flask中jinjia2模板的使用（二）

set和with语句以及模版中定义变量

1、set语句：

语法结构：

{% set  uname='cbb'%}
<p>用户名：{{ uname }}</p>

一旦定义了这个变量，那么在后面的代码中，都可以使用这个变量，就类似于Python的变量定义是一样的。

2、with语句

语法：

<!--with语句来定义变量，只有在指定区域 才能使用这个变量-->
{% with classroom='2021'%}
    <p>班级：{{ classroom }}</p>
{% endwith %}

`with`语句定义的变量，只能在`with`语句块中使用，超过了这个代码块，就不能再使用了

注意：关于定义的变量，`with`语句也不一定要跟一个变量，可以定义一个空的`with`语句，需要在指定的区域才能使用的情况，可以set与with组合使用。

例如

{% with %}
  {% set  name='绿茶' %}
   <p>饮料：{{ pname }}</p>
{% endwith %}

关于如何使用jinja2和flask在html页面上显示消息？和flask加载静态html的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于flask Jinja2怎么使用、Flask 的 jinja2 模板、Flask-jinja2、flask中jinjia2模板的使用（二）的相关知识，请在本站寻找。

本文标签：