1.jinja2模板介绍和查找路径

  1. import os
  2. from flask import Flask, render_template
  4. # 之前提到过在渲染模板的时候，默认会从项目根目录下的templates目录下查找模板
  5. # 如果不想把模板文件放在templates文件夹下，那么可以在Flask初始化的时候指定
  6. '''
  7. Flask类的构造函数
  9.     def __init__(
  10.         self,
  11.         import_name,
  12.         static_url_path=None,
  13.         static_folder='static',
  14.         static_host=None,
  15.         host_matching=False,
  16.         subdomain_matching=False,
  17.         template_folder='satori',
  18.         instance_path=None,
  19.         instance_relative_config=False,
  20.         root_path=None
  21.     ):
  22. 可以看到有一个template_folder='satori'
  23. 我们在初始化的时候可以重新指定
  24. 但是最好不要变
  25. '''
  26. BASE_DIR = os.path.dirname(__file__)
  27. app = Flask(__name__, template_folder=os.path.join(BASE_DIR, "satori"))
  29. @app.route(r"/go")
  30. def go():
  31.     return render_template("test.html")
  33. if __name__ == '__main__':
  34.     app.run(port=8888, debug=True)

后面，我将模板目录改回来了

2.模板传参以及技巧

test.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>my name is {{name}}, age is {{age}}</h1>
  9. </body>
  10. </html>
  1. from flask import Flask, render_template
  3. app = Flask(__name__)
  5. @app.route(r"/index")
  6. def index():
  7.     '''
  8.     在html文件中，以{{}}定义，比如{{name}}，然后在渲染模板的时候传参进去即可
  9.     通过name="xxx"的形式，会自动进行替换。
  10.     渲染的流程是先把html文件读取进来，再将{{}}里面的内容替换掉，因此最终返回给浏览器的内容是不包含{{}}的
  11.     '''
  12.     return render_template("test.html", name="satori", age=17)
  14. if __name__ == '__main__':
  15.     app.run(port=8888, debug=True)

  1. @app.route(r"/index")
  2. def index():
  3.     '''
  4.     但是如果要替换的内容比较多的话，那么一个一个写的话，风格不是很pythonic
  5.     因此我们会把内容都写在一个字典里,然后通过**传值
  6.     '''
  7.     replace_content = {"name": "mashiro", "age": 16}
  8.     return render_template("test.html", **replace_content)

依旧可以打印出结果

既然如此的话，那么可不可以传入字典或者列表呢？

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <!--可以使用Python的语法d["xx"], 也可以使用d.xx-->
  9.     <h2>my name is {{info['name']}}, age is {{info.age}}</h2>
  10.     <h2>在{{arr}}中，数字1总共出现了{{arr.count(1)}}次</h2>
  11.     <h2>另外两个花括号之间必须要写值，不能是空的花括号，否则报错</h2>
  12.     <h2>但如果两个花括号中间的内容，我们在模板渲染的时候没有传值呢，那么不会显示，也不会报错</h2>
  13.     <h2>比如下面的类容就不会显示，因为在render_template中没有mmp="xx"</h2>
  14.     <h2>{{mmp}}</h2>
  16. </body>
  17. </html>
  1. from flask import Flask, render_template
  3. app = Flask(__name__)
  5. @app.route(r"/index")
  6. def index():
  7.     info = {"name": "matsuri", "age": 400}
  8.     arr = [1, 1, 2, 3, 1, 1, 3]
  9.     return render_template("test.html", info=info, arr=arr)
  11. if __name__ == '__main__':
  12.     app.run(port=8888, debug=True)

3.模板中使用url_for的两种方式

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <h2><a href="{{link}}">你想成为女装大佬吗？想搞基吗？想的话，就点击进入新世界的大门吧</a></h2>
  9. </body>
  10. </html>
  1. from flask import Flask, render_template, url_for
  3. app = Flask(__name__)
  5. @app.route(r"/bili")
  6. def bili():
  7.     import requests
  8.     content = requests.get("http://www.bilibili.com")
  9.     content.encoding = content.apparent_encoding
  10.     return content.text
  12. @app.route(r"/gay")
  13. def gay():
  14.     return render_template("test.html", link=url_for("bili"))
  16. if __name__ == '__main__':
  17.     app.run(port=8888, debug=True)

访问"/gay"的时候，会将endpoint="bili"的值传递进去，点击的时候会访问/bili，从而执行

另一种方式

可以直接在模板中使用url_for,之前说过jinja2是把整个模板读取进来，然后对{{}}里面的内容进行替换，所以是可以直接使用url_for的

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <h2><a href="{{ url_for('bili') }}">你想成为女装大佬吗？想搞基吗？想的话，就点击进入新世界的大门吧</a></h2>
  9. </body>
  10. </html>
  1. from flask import Flask, render_template, url_for
  3. app = Flask(__name__)
  5. @app.route(r"/bili")
  6. def bili():
  7.     import requests
  8.     content = requests.get("http://www.bilibili.com")
  9.     content.encoding = content.apparent_encoding
  10.     return content.text
  12. @app.route(r"/gay")
  13. def gay():
  14.     # 替换之后，这里就不用传参了，因为在模板中可以直接获取链接
  15.     return render_template("test.html")
  17. if __name__ == '__main__':
  18.     app.run(port=8888, debug=True)

访问页面的结果和之前是一样的

4.jinja2模板过滤器的基本使用

  1. 过滤器是通过管道符|来实现过滤的，例如：{{name:length}},将返回name的长度。过滤器相当于是一个函数，把当前的变量传到过滤器中，然后过滤器根据自己的功能再返回相应的值，之后再将结果渲染到页面中。jinja2内置了很多的过滤器，下面介绍一些常用的
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <h1>{{age|abs}}</h1>
  9.     <h1>{{name|length}}</h1>
  10.     <h1>{{ money|sum }}</h1>
  11. </body>
  12. </html>
  1. from flask import Flask, render_template
  3. app = Flask(__name__)
  5. @app.route(r"/index")
  6. def index():
  7.     return render_template("test.html", age=-18, name="古明地觉", money=[100, 210, 320])
  9. if __name__ == '__main__':
  10.     app.run(port=8888, debug=True)

5.default过滤器

之前我们说过，如果我们定义了一个{{mmp}}，但是我们在render_template的时候没有传值的话，默认是不会显示的，当然也不会报错。但是我们想，对于那些没有传值的变量，我们能不能给一个默认值呢？显然是可以的

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <h2>{{s1|default("这个人很懒，什么也没留下")}}</h2>
  9.     <h2>{{s2|default("这个人很懒，什么也没留下")}}</h2>
  10. </body>
  11. </html>
  1. from flask import Flask, render_template
  3. app = Flask(__name__)
  5. @app.route(r"/index")
  6. def index():
  7.     s1 = "一个人只要好好活着，就足以拯救某个人"
  8.     return render_template("test.html", s1=s1)
  10. if __name__ == '__main__':
  11.     app.run(port=8888, debug=True)

我定义了s1，所以s1的内容正常显示。然而我没有定义s2，因此按理来说是不显示的，但是我指定了default，因此render_templates没有传值的时候，会显示默认值

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <h2>{{s1}}</h2>
  9.     <!--不过这里还有一个问题，那么如果我指定了s2=None,那么页面上就会显示None
  10.         default是否执行，不在于你传的什么值，而在于你有没有传值，只要传了，就不会显示default的内容
  11.         那如果我想，当传入空字符串，空字典等等，在Python中为False的值，还是等价于没传值，继续执行default的内容，
  12.         该怎么办呢？可以加入一个参数boolean=True，表示在Python中bool为False的值也会被包含在内-->
  13.     <h2>{{s2|default("这个人很懒，什么也没留下", boolean=True)}}</h2>
  14.     <!--如果s3为False，那么会自动选择"默认值"，两种方式比较类似-->
  15.     <h2>{{s3 or "默认值"}}</h2>
  16. </body>
  17. </html>

6.常用过滤器

  1. escape：转义,默认是开启的。{{xxx|escape}}
  2. 那么如何关闭转义呢？这里要介绍一下{{}}和{% %}，{{}}存放变量，{%%}执行逻辑
  3. {% autoescape off %}
  4. 这里的标签是不会被转义的
  5. {% endautoescape %}
  6. safe：和escape相反，意思是安全的。{xxx|safe}也不会被转义
  7. first：{xx|first},返回序列xx的第一个元素，我们也可以直接使用{{xx[0]}}
  8. last：返回最后一个元素
  9. length：返回序列的长度，sum：返回序列的总和
  10. join：{xx|join(sep)},使用sep将序列xx拼接成一个字符串
  11. int：转化为int
  12. float：转化为float
  13. string：转化为str
  14. lower：小写
  15. upper：大写
  16. replace：{xx|replace(old, new)},将xx中old替换成new
  17. truncate：{xx|truncate(length=14)},表示不管你输入多少字符，在页面上最多显示14个，剩下的用几个省略号表示
  18. wordcounts：计算一个长字符串中某单词出现的次数
  19. 　　

7.自定义过滤器

  1. 过滤器本质上就是个函数，因此我们只需要写个函数，定义相应的逻辑，然后注册到jinja2过滤器当中即可。
  2. 下面我们手动实现一个replace过滤器
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <h2>{{s|my_replace("satori", "koishi")}}</h2>
  9.     <h2>{{s|my_replace2("satori", "koishi", 2)}}</h2>
  10. </body>
  11. </html>
  1. from flask import Flask, render_template
  3. app = Flask(__name__)
  5. @app.route(r"/index")
  6. def index():
  7.     s = "hello satori satori satori"
  8.     return render_template("test.html", s=s)
  10. """
  11. 这里需要一提的是，我们在模板中是{{s|my_replace}}
  12. 我们my_replace过滤器对应的函数至少要有一个参数，也就是用来接收s的。
  13. 如果只有一个参数的话，那么会自动传进去
  14. 也就是说{{s|my_replace}}和{{s|my_replace()}}是一样的
  16. 但是如果还需要其他的参数，那么就把参数按照顺序传递进去即可，{{s|my_replace("old_string", "new_string)}}
  17. 至于s本身，会自动传递给过滤器对应的函数的第一个参数。所以过滤器对应的函数至少要能接收一个参数。
  18. """
  19. @app.template_filter(name="my_replace")  # 这里的name就是我们的过滤器名字
  20. def xxxx(string, old, new):
  21.     return string.replace(old, new)
  23. def yyyy(string, old, new, count):
  24.     return string.replace(old, new, 2)
  26. # 还可以使用这种方式注册过滤器
  27. app.add_template_filter(name="my_replace2", f=yyyy)
  28. """
  29.     @setupmethod
  30.     def template_filter(self, name=None):
  31.         def decorator(f):
  32.             self.add_template_filter(f, name=name)
  33.             return f
  35.         return decorator
  36. 当然这种装饰器的模式，本质上还是调用了add_template_filter
  37. """
  39. if __name__ == '__main__':
  40.     app.run(port=8888, debug=True)

8.if语句

和python的if语句比较类似，使用{% %}包裹，但是不要忘记结尾的{% endif %}

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     {% if gender == 'f' %}
  9.     <!--这里相当于Python的两层if循环-->
  10.         {% if age >= 18 %}
  11.         <h1>或许我们可以进行一场交易</h1>
  12.         {% else %}
  13.         <h1>虽然担些风险，但也值得一试</h1>
  14.         {% endif %}
  15.     {% else %}
  16.         {% if age >= 18 %}
  17.         <h1>我不搞基</h1>
  18.         {% else %}
  19.         <h1>可爱的男孩子也是可以的</h1>
  20.         {% endif %}
  21.     {% endif %}
  23. </body>
  24. </html>
  1. from flask import Flask, render_template
  3. app = Flask(__name__)
  5. @app.route(r"/index")
  6. def index():
  7.     return render_template("test.html", age=17, gender="f")
  9. if __name__ == '__main__':
  10.     app.run(port=8888, debug=True)

当然if语句，还可以支持elif，和python语法是一样的，只是不要忘记有{% if %}就必须要有{% endif %}这两个是必须成对出现的

9.for语句

和python里面的for语句也是一样，但是不要忘记结尾的{% endfor %}

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     {% for age in ages %}
  9.         <h2>{{age}}</h2>
  10.     {% endfor %}
  12.     <table border="1px solid red">
  13.         <thead>
  14.             <tr>
  15.                 <th>姓名</th>
  16.                 <th>出场动漫</th>
  17.             </tr>
  18.         </thead>
  19.         <tbody>
  20.             {% for name,anime in girls.items() %}
  21.             <tr>
  22.                 <td>{{name}}</td>
  23.                 <td>{{anime}}</td>
  24.             </tr>
  25.             {% endfor %}
  26.         </tbody>
  27.     </table>
  28. </body>
  29. </html>
  1. from flask import Flask, render_template
  3. app = Flask(__name__)
  5. @app.route(r"/index")
  6. def index():
  7.     ages = [17, 400, 20, 16, 14]
  8.     girls = {"古明地觉": "东方地灵殿", "四方茉莉": "sola", "牧濑红莉栖": "命运石之门",
  9.              "坂上智代": "Clannad", "神尾观铃": "air"}
  10.     return render_template("test.html", ages=ages, girls=girls)
  12. if __name__ == '__main__':
  13.     app.run(port=8888, debug=True)

  1. 如果想反向遍历，只需要加上一个过滤器，xx|reverse，表示反向遍历xx
  2. 此外，jinja2还提供了索引
  3. loop.index 　　当前迭代的索引（从1开始）
  4. loop.index0　　当前迭代的索引（从0开始）
  5. loop.first　　是否是第一次迭代，返回True或者False
  6. loop.last　　是否是最后一次迭代，返回True或者False
  7. loop.length  　　序列的长度
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <table border="1px solid red">
  9.         <thead>
  10.             <tr>
  11.                 <th>序号</th>
  12.                 <th>姓名</th>
  13.                 <th>出场动漫</th>
  14.                 <th>年龄</th>
  15.             </tr>
  16.         </thead>
  17.         <tbody>
  18.             {% for name,anime in girls.items() %}
  19.             <tr>
  20.                 <td>{{loop.index}}</td>
  21.                 <td>{{name}}</td>
  22.                 <td>{{anime}}</td>
  23.                 <td>{{ages[loop.index0]}}</td>
  24.             </tr>
  25.             {% endfor %}
  26.         </tbody>
  27.     </table>
  28. </body>
  29. </html>
  1. from flask import Flask, render_template
  3. app = Flask(__name__)
  5. @app.route(r"/index")
  6. def index():
  7.     ages = [17, 400, 20, 16, 14]
  8.     girls = {"古明地觉": "东方地灵殿", "四方茉莉": "sola", "牧濑红莉栖": "命运石之门",
  9.              "坂上智代": "Clannad", "神尾观铃": "air"}
  10.     return render_template("test.html", ages=ages, girls=girls)
  12. if __name__ == '__main__':
  13.     app.run(port=8888, debug=True)

10.range

jinja2中还可以使用range

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <table border="1px">
  9.         {% for i in range(1, 10) %}
  10.         <tr>
  11.             <!--此外还有一种方式，那就是jinja2中，for循环是可以带条件的，这句话还可以这么改-->
  12.             <!--{#  {% for j in range(1, 10) if j < i %}, j也从1遍历到10，但必须满足j < i  #}-->
  13.             <!--关于上面的{# #}在jinja中表示注释，html的注释没用，还是会被解释，必须要在模板语言两端加上{# #} -->
  14.             {% for j in range(1, i) %}
  15.                 <td>{{j}} * {{i}} = {{i * j}}</td>
  16.             {% endfor %}
  17.         </tr>
  18.         {% endfor %}
  19.     </table>
  20. </body>
  21. </html>
  1. from flask import Flask, render_template
  3. app = Flask(__name__)
  5. @app.route(r"/index")
  6. def index():
  7.     return render_template("test.html")
  9. if __name__ == '__main__':
  10.     app.run(port=8888, debug=True)

11.宏的概念和基本使用

宏，说的通俗一点，就类似于python里面的函数，我们给一系列操作进行一个封装，再给一个名字。然后调用宏名的时候，就会执行一系列的操作

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <!--如何定义一个宏-->
  9.     {% macro input(name, value="", type="text") %}
  10.         <input type="{{type}}" name="{{name}}" value="{{value}}"/>
  11.     {% endmacro %}
  12.     <!--input就类似于函数名，这里叫什么无所谓。name是我们需要传的参数，value和type是缺省参数-->
  13.     <!--当我们执行{#    {{input("satori", "love")}}    #}的时候，等价于<input type="text" name="satori" value="love"/>-->
  14.     <form action="/show" method="post">
  15.         {{input("satori","东方地灵殿")}}
  16.         {{input("mashiro","樱花庄的宠物女孩")}}
  17.         {{input("", "提交", "submit")}}
  18.     </form>
  19. </body>
  20. </html>
  1. from flask import Flask, render_template, request
  3. app = Flask(__name__)
  5. @app.route(r"/index")
  6. def index():
  7.     return render_template("test.html")
  9. @app.route(r"/show", methods=["POST"])
  10. def show():
  11.     satori = request.form.get("satori")
  12.     mashiro = request.form.get("mashiro")
  13.     return f"satori come from {satori}, mashiro come from {mashiro}"
  15. if __name__ == "__main__":
  16.     app.run(host="localhost", port=8888)

12.宏的导入

宏也是可以导入的，在flask中，宏的导入和Python导入模块是类似的。话说为什么要有宏的导入，和Python中模块的导入是一致的。不然文件看起来很乱

marco.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     {% macro input(name, value="", type="text") %}
  9.         <input type="{{type}}" name="{{name}}" value="{{value}}"/>
  10.     {% endmacro %}
  11. </body>
  12. </html>

这样我们就把宏单独定义在一个文件里面，导入宏的话直接通过import "宏文件的路径" as xxx，然后通过xxx.宏名 调用即可，注意这里必须要起名字，也就是必须要as。或者from "宏文件的路径" import 宏名[as xxx]，这里起别名则是可选的

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <!--导入的同时指定一个别名-->
  9.     {% import "macro.html" as macro  %}
  10.     <form action="/show" method="post">
  11.         <!--使用的时候直接通过marco.input即可。marco相当于模块，input相当于函数或者类-->
  12.         {{macro.input("satori","东方地灵殿")}}
  13.         {{macro.input("mashiro","樱花庄的宠物女孩")}}
  14.         {{macro.input("", "提交", "submit")}}
  15.     </form>
  16. </body>
  17. </html>

13.include标签的使用

include的使用非常简单，直接导入就行了，{% include "xx.html" %},相当于 ctrl+c和ctrl+v

a.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <p>但使龙城飞将在</p>
  9. </body>
  10. </html>
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     {% include "a.html" %}
  9.     <p>不教胡马度阴山</p>
  10. </body>
  11. </html>

14.set和with语句以及模板中定义变量

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     {% set username="satori" %}
  9.     <!--set一旦设置了，那么在全局都可以使用-->
  10.     <h2>{{username}}</h2>
  12.     {% with username="koishi" %}
  13.     <h2>{{username}}</h2>
  14.     {% endwith %}
  15.     <!--{#with一旦设置，那么设置的值只会在with语句块内生效，所以结尾才要有endwith构成一个语句块
  16.     此外with还有另一种写法，那就是
  17.     {% with %}
  18.     {% set username = "koishi" %}
  19.     {% endwith %}
  20.     这样写也是没问题的，因为set在with里面 #}-->
  22.     <h1>{{username}}</h1>
  23. </body>
  24. </html>

15.加载静态文件

需要在项目根目录下，创建一个static文件夹，当然也可以不叫static，但是flask默认叫static。当然我们也可以在创建app的时候单独指定static_folder,类似template_folder

  1. p{
  2.     color: aqua;
  3. }
  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6.     <link rel="stylesheet" href="{{url_for('static', filename='css/index.css')}}">
  7. </head>
  8. <body>
  9.     <p>xxxxxxxxxxxxxxxx</p>
  10. </body>
  11. </html>

一句话总结：无论图片啊，js啊，还是css，都使用使用{{url_for('static', filename='css|js|images/xxx.xxx')}}

16.模板继承

  1. 之前介绍了include，但是还不够灵活，因为网站一大的话，那么重合的部分就会变多，因此使用include还不是一个最好的方式。接下来介绍的模板继承非常的灵活。可以想象一下，我们博客园，四周很多内容都是不变的，如果每来一个页面都要写一遍的话，会很麻烦。因此我们可以将不变的部分先写好，在变的部分留一个坑，这就是父模板。然后子模板继承的时候，会将父模板不变的部分继承过来，然后将变的部分，也就是父模板中挖的坑填好。总结一下就是：父模板挖坑，子模板填坑。

base.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <p>なんでそんなになれてんだよ</p>
  9.     <p>雪菜と何度もキースしたんだよ</p>
  10.     {% block 冬马小三 %}
  11.     {% endblock %}   <!--这两行便相当于我们在父模板中挖的坑-->
  12.     <p>どこまで私を置いてきぼりに気が済むんだよ</p>
  13.     {% block 雪菜碧池 %}
  14.     {% endblock %}
  15.     <p>最初私の前から消えたのはお前だろ</p>
  16.     {% block 打死白学家 %}
  17.     {% endblock %}
  18.     <p>勝手に私の手が届けないところに行ったのはお前だろう</p>
  20. </body>
  21. </html>
  1. {% extends "base.html" %}   <!--将父模板继承过来-->
  3. <!--接下来填好我们在父模板中挖的坑,我们挖了三个，所以这里也应该要埋三个-->
  4. {% block 冬马小三 %}
  5. <h2>我爱小三</h2>
  6. {% endblock %}
  8. {% block 雪菜碧池 %}
  9. <h2>我爱碧池</h2>
  10. {% endblock %}
  12. {% block 打死白学家 %}
  13. <h2>打死春哥，悄悄抱走冬马和雪菜</h2>
  14. {% endblock %}

base.html

  1. <!DOCTYPE html>
  2. <html lang="en">
  3. <head>
  4.     <meta charset="UTF-8">
  5.     <title>Title</title>
  6. </head>
  7. <body>
  8.     <!--另外模板继承，如果父模板中挖的坑中，已经有内容了，那么子模板继承过来的时候会自动清除。-->
  9.     <!--{#   如果想保留，需要加上{{super()}}    #}-->
  10.     {% block 冬马小三 %}
  11.     <p>我是父模板中的内容</p>
  12.     {% endblock %}
  14.     {% block 雪菜碧池 %}
  16.     {% endblock %}
  18. </body>
  19. </html>
  1. {% extends "base.html" %}
  3. {% block 冬马小三 %}
  4. {{super()}}
  5. <h2>我是子模板中的内容</h2>
  6. {% endblock %}
  8. <!--{#  如果在一个块中，想使用另一个块的内容，可以通过{{self.块名()}}来实现   #}-->
  9. {% block 雪菜碧池 %}
  10. {{self.冬马小三()}}
  11. {% endblock %}

  1. 注意：{% extend "xxx.html"  %}要放在最上面，不然容易出问题，在Django中是直接会报错的
  2. 另外，子模板中的代码一定要放在block语句块内，如果放在了外面，jinja2是不会渲染的

2.flask模板--jinja2的更多相关文章

  1. 怎么用Python Flask模板jinja2在网页上打印显示16进制数？

    问题:Python列表(或者字典等)数据本身是10进制,现在需要以16进制输出显示在网页上 解决: Python Flask框架中 模板jinja2的If 表达式和过滤器 假设我有一个字典index, ...

  2. flask的jinja2模板中过过滤器的相关小内容

    jinja2模板中有自带的过滤器,有需要直接拿来使用.也可以自己定义过滤器 在过滤器中,有一些常见得操作及关键字.有对字符串的操作,还有对大小写转换的操作.还有对list的操作 过滤器的语法 {# 过 ...

  3. Flask入门模板Jinja2语法与函数(四)

    1 模板的创建 模板文件结构: project/ templates/ 模板文件 跳转模板一般使用: from flask import render_template,render_template ...

  4. Flask - 模板语言jinja2 和render_template高级用法

    目录 Flask - 模板语言jinja2 和render_template高级用法 一. 字典传递至前端 二. 列表传入前端Jinja2 模板的操作: 三. 大字典传入前端 Jinja2 模板 四. ...

  5. Flask模板_学习笔记

    代码尽在我的github上面:https://github.com/521xueweihan 概述:    在Flask中,Jinja2默认配置如下:        A.扩展名为.html,.htm, ...

  6. flask模板

    做为python web开发领域的一员,flask跟Django在很多地方用法以都是相似的,比如flask的模板 模板就是服务器端的页面,在模板中可以使用服务端的语法进行输出控制 1.模板的工作原理 ...

  7. flask模板的基本用法（定界符、模板语法、渲染模板），模板辅助工具（上下文、全局对象、过滤器、测试器、模板环境对象）

    flask模板 在动态web程序中,视图函数返回的HTML数据往往需要根据相应的变量(比如查询参数)动态生成. 当HTML代码保存到单独的文件中时,我们没法再使用字符串格式化或拼接字符串的当时在HTM ...

  8. Python 模板 Jinja2

    Python 模板 Jinja2 模板 要了解Jinja2,就需要先理解模板的概念.模板在Python的web开发中广泛使用,它能够有效的将业务逻辑和页面逻辑分开,使代码可读性更强.更加容易理解和维护 ...

  9. flask模板语言

    由于Django的模板引擎和Flask中的Jinja2模板引擎有很多一样的地方,所以我将一样的地方总结到了独立的文章中 https://www.cnblogs.com/kuxingseng95/art ...

随机推荐

  1. Systemd 指令

    Systemd 指令 原文:http://www.ruanyifeng.com/blog/2016/03/systemd-tutorial-commands.html 一.由来 历史上,Linux 的 ...

  2. 百度AI接口---身份证识别Demo

    题记:自己是做java web的,但是本人以前接触并学习很多图像的知识,所以对图像很敏感.下面以百度的一个接口,实现身份证识别案例 1.需要百度开发者AppID.SecretKey .API Key. ...

  3. flutter Could not find the built application bundle at build/ios/iphonesimulator/Runner.app

    运行flutter run时报错 提示如下: Could not find the built application bundle at build/ios/iphonesimulator/Runn ...

  4. java最常见的5个错误

    1. Null 的过度使用 避免过度使用 null 值是一个最佳实践.例如,更好的做法是让方法返回空的 array 或者 collection 而不是 null 值,因为这样可以防止程序抛出 Null ...

  5. SQL中group by使用

    多条重复记录,有一个字段可以进行区分,从重复的记录中取出其中一条,可利用group by字段 举例如下: 查询所有 查询地区中的最高分

  6. HCL试验六

    交换机R1: syssysname R1interface loopback 0ip add 192.168.10.1 24quinterface g0/0ip address 10.1.1.1 30 ...

  7. android webview 添加内置对象

    package com.android.EBrowser; import android.app.Activity;import android.graphics.Rect;import androi ...

  8. Django 数据库操作

    Django 数据库操作 Django运算表达式与Q对象/F对象 1 模型查询 概述: 1 查询集:表示从数据库中获取的对象的集合 2 查询集可以有多个过滤器,通过 逻辑运算符连接 3 过滤器就是一个 ...

  9. Python报错module 'scipy.misc' has no attribute 'xxx'

    Python报错module 'scipy.misc' has no attribute 'imresize' 解决办法: 安装Pillow包,命令如下: pip install Pillow 然后重 ...

  10. springcloud zookeeper+gateway

    搭建springcloud项目的时候以 zookeeper为注册中心  gateway为路由 启动时出现以下报错: ****************************************** ...