Flask

[WangShuXian6]

Flask

可扩展的框架

Flask 有 3 个主要依赖：

路由、调试和 Web 服务器网关接口（WSGI，Web server gateway interface）

子系统由 Werkzeug 提供；

模板系统由 Jinja2 提供；

命令行集成由 Click 提供。

这些依赖全都是 Flask 的开发者 Armin Ronacher 开发的

安装

进入项目目录，创建虚拟环境

python3 -m venv venv

使用虚拟环境

source venv/bin/activate

虚拟环境中的工作结束后，在命令提示符中输入 deactivate

还原当前终端会话的 PATH 环境变量，把命令提示符重置为最初的状态

安装 Flask 包

(venv) $ pip install flask

执行这个命令后，pip 不仅安装 Flask 自身，还会安装它的所有依赖

验证 Flask 是否正确安装

可以启动 Python 解释器，尝试导入 Flask

(venv) $ python

>>> import flask

>>>

如果没有看到错误提醒，那么恭喜你

[WangShuXian6]

应用的基本结构

初始化

所有 Flask 应用都必须创建一个应用实例。

Web 服务器使用一种名为 Web 服务器网关接口（WSGI，Web server gateway interface，读作“wiz-ghee”）的协议，把接收自客户端的所有请求都转交给这个对象处理。

应用实例是 Flask 类的对象，通常由下述代码创建：

from flask import Flask

app = Flask(__name__)

Flask 类的构造函数只有一个必须指定的参数，即应用主模块或包的名称。

在大多数应用中，Python 的 name 变量就是所需的值。

Flask 用这个参数确定应用的位置，进而找到应用中其他文件的位置，例如图像和模板。

路由和视图函数

路由

客户端（例如 Web 浏览器）把请求发送给 Web 服务器，Web 服务器再把请求发送给 Flask 应用实例。

应用实例需要知道对每个 URL 的请求要运行哪些代码，所以保存了一个 URL 到 Python 函数的映射关系。

处理 URL 和函数之间关系的程序称为路由。

app.route 装饰器 声明路由

在 Flask 应用中定义路由的最简便方式，是使用应用实例提供的 app.route 装饰器

把 index() 函数注册为应用根地址的处理程序

@app.route('/')
def index():
    return '<h1>Hello World!</h1>'

装饰器是 Python 语言的标准特性。惯常用法是把函数注册为事件处理程序，在特定事件发生时调用。

app.add_url_rule() 声明路由

这个方法最简单的形式接受 3 个参数：URL、端点名和视图函数

使用 app.add_url_rule() 方法注册 index() 函数

def index():
    return '<h1>Hello World!</h1>'

app.add_url_rule('/', 'index', index)

视图函数

index() 这样处理入站请求的函数称为视图函数。

如果应用部署在域名为 www.example.com 的服务器上，在浏览器中访问 http://www.example.com 后，会触发服务器执行 index() 函数。

这个函数的返回值称为响应，是客户端接收到的内容。

如果客户端是 Web 浏览器，响应就是显示给用户查看的文档。

视图函数返回的响应可以是包含 HTML 的简单字符串，也可以是复杂表单。

直接在 Python 源码文件中编写响应字符串的 HTML 代码会导致代码难以维护

动态路由

name 参数用于生成个性化的欢迎消息

@app.route('/user/<name>')
def user(name):
    return '<h1>Hello, {}!</h1>'.format(name)

路由 URL 中放在尖括号里的内容就是动态部分，

任何能匹配静态部分的 URL 都会映射到这个路由上。

调用视图函数时，Flask 会将动态部分作为参数传入函数。

在这个视图函数中，name 参数用于生成个性化的欢迎消息。

路由中的动态部分默认使用字符串，不过也可以是其他类型。

例如，路由 /user/ 只会匹配动态片段 id 为整数的 URL，例如 /user/123。

Flask 支持在路由中使用 string、int、float 和 path 类型。

path 类型是一种特殊的字符串，与 string 类型不同的是，它可以包含正斜线。

一个完整的应用

hello.py 应用脚本定义一个应用实例、一个路由和一个视图函数。

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return '<h1>Hello World!</h1>'

Web开发服务器

flask run

Flask 应用自带 Web 开发服务器，通过 flask run 命令启动。

这个命令在 FLASK_APP 环境变量指定的 Python 脚本中寻找应用实例。

Linux 和 macOS

(venv) $ export FLASK_APP=hello.py
(venv) $ flask run
 * Serving Flask app "hello"
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

Windows

(venv) $ set FLASK_APP=hello.py
(venv) $ flask run
 * Serving Flask app "hello"
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

服务器启动后便开始轮询，处理请求。

直到按 Ctrl+C 键停止服务器，轮询才会停止。

如果在基 URL 后面再输入任何内容，应用将不知道如何处理，会向浏览器返回错误码 404

Flask 提供的 Web 服务器只适用于开发和测试

app.run()

Flask Web 开发服务器也可以通过编程的方式启动：调用 app.run() 方法

在没有 flask 命令的旧版 Flask 中，若想启动应用，要运行应用的主脚本。主脚本的尾部包含下述代码片段：

if __name__ == '__main__':
    app.run(port=80,debug=True)

动态路由

包含动态路由的 Flask 应用

在浏览器中访问这个动态 URL 时，你会看到一条个性化的消息，包含你在 URL 中提供的名字

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    return '<h1>Hello World!</h1>'

@app.route('/user/<name>')
def user(name):
    return '<h1>Hello, {}!</h1>'.format(name)

访问 http://localhost:5000/user/Dave。应用会显示一个使用 name 动态参数生成的欢迎消息

调试模式

Flask 应用可以在调试模式中运行。

在这个模式下，开发服务器默认会加载两个便利的工具：重载器和调试器。

重载器

启用重载器后，Flask 会监视项目中的所有源码文件，发现变动时自动重启服务器。

在开发过程中运行启动重载器的服务器特别方便，

因为每次修改并保存源码文件后，服务器都会自动重启，让改动生效。

调试器

调试器是一个基于 Web 的工具，当应用抛出未处理的异常时，它会出现在浏览器中。

此时，Web 浏览器变成一个交互式栈跟踪，你可以在里面审查源码，在调用栈的任何位置计算表达式。

调试模式默认禁用。

若想启用，在执行 flask run 命令之前设定 FLASK_DEBUG=1 环境变量：

(venv) $ export FLASK_APP=hello.py
(venv) $ export FLASK_DEBUG=1
(venv) $ flask run

 * Serving Flask app "hello"
 * Forcing debug mode on
 * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)
 * Restarting with stat
 * Debugger is active!
 * Debugger PIN: 273-181-528

使用 app.run() 方法启动服务器时，不会用到 FLASK_APP 和 FLASK_DEBUG 环境变量。

若想以编程的方式启动调试模式，就使用 app.run(debug=True)。

客户端通过调试器能请求执行远程代码，因此可能导致生产服务器遭到攻击。

作为一种简单的保护措施，启动调试模式时可以要求输入 PIN 码，执行 flask run 命令时会打印在控制台中。

命令行选项

flask 命令支持一些选项。执行 flask --help，或者执行 flask

flask shell

flask shell 命令在应用的上下文中打开一个 Python shell 会话。

在这个会话中可以运行维护任务或测试，也可以调试问题。

flask run

作用是在 Web 开发服务器中运行应用。这个命令有多个参数：flask run --help

--host

--host 参数特别有用，它告诉 Web 服务器在哪个网络接口上监听客户端发来的连接。

默认情况下，Flask 的 Web 开发服务器监听 localhost 上的连接，因此服务器只接受运行服务器的计算机发送的连接。

下述命令让 Web 服务器监听公共网络接口上的连接，因此同一网络中的其他计算机发送的连接也能接收到：

flask run --host 0.0.0.0

现在，网络中的任何计算机都能通过 http://a.b.c.d:5000 访问 Web 服务器。

其中，a.b.c.d 是运行服务器的计算机的 IP 地址。

--reload、--no-reload、--debugger 和 --no-debugger

--reload、--no-reload、--debugger 和 --no-debugger 参数对调试模式进行细致的设置。

例如，启动调试模式后可以使用 --no-debugger 关闭调试器，但是应用还在调试模式中运行，而且重载器也启用了。

请求–响应循环

应用和请求上下文

Flask 从客户端收到请求时，要让视图函数能访问一些对象，这样才能处理请求。请求对象就是一个很好的例子，它封装了客户端发送的 HTTP 请求。

要想让视图函数能够访问请求对象，一种直截了当的方式是将其作为参数传入视图函数，不过这会导致应用中的每个视图函数都多出一个参数。

为了避免大量可有可无的参数把视图函数弄得一团糟，Flask 使用上下文临时把某些对象变为全局可访问。

from flask import request

@app.route('/')
def index():
    user_agent = request.headers.get('User-Agent')
    return '<p>Your browser is {}</p>'.format(user_agent)

在这个视图函数中我们把 request 当作全局变量使用。

事实上，request 不可能是全局变量。

试想，在多线程服务器中，多个线程同时处理不同客户端发送的不同请求时，每个线程看到的 request 对象必然不同。

Flask 使用上下文让特定的变量在一个线程中全局可访问，与此同时却不会干扰其他线程。

线程是可单独管理的最小指令集。进程经常使用多个活动线程，有时还会共享内存或文件句柄等资源。多线程 Web 服务器会创建一个线程池，再从线程池中选择一个线程处理接收到的请求。

在 Flask 中有两种上下文：应用上下文和请求上下文

变量名	上下文	说明
current_app	应用上下文	当前应用的应用实例
g	应用上下文	处理请求时用作临时存储的对象，每次请求都会重设这个变量
request	请求上下文	请求对象，封装了客户端发出的 HTTP 请求中的内容
session	请求上下文	用户会话，值为一个字典，存储请求之间需要“记住”的值

Flask 在分派请求之前激活（或推送）应用和请求上下文，请求处理完成后再将其删除。

应用上下文被推送后，就可以在当前线程中使用 current_app 和 g 变量。

类似地，请求上下文被推送后，就可以使用 request 和 session 变量。

如果使用这些变量时没有激活应用上下文或请求上下文，就会导致错误

应用上下文的使用方法

>>> from hello import app
>>> from flask import current_app
>>> current_app.name
Traceback (most recent call last):
...
RuntimeError: working outside of application context
>>> app_ctx = app.app_context()
>>> app_ctx.push()
>>> current_app.name
'hello'
>>> app_ctx.pop()

在这个例子中，没激活应用上下文之前就调用 current_app.name 会导致错误，但推送完上下文之后就可以调用了。

注意，获取应用上下文的方法是在应用实例上调用 app.app_context()。

请求分派

URL 映射

应用收到客户端发来的请求时，要找到处理该请求的视图函数。

为了完成这个任务，Flask 会在应用的 URL 映射中查找请求的 URL。

URL 映射是 URL 和视图函数之间的对应关系。

Flask 使用 app.route 装饰器或者作用相同的 app.add_url_rule() 方法构建映射。

查看 Flask 应用中的 URL 映射

(venv) $ python
>>> from hello import app
>>> app.url_map
Map([<Rule '/' (HEAD, OPTIONS, GET) -> index>,
 <Rule '/static/<filename>' (HEAD, OPTIONS, GET) -> static>,
 <Rule '/user/<name>' (HEAD, OPTIONS, GET) -> user>])

/ 和 /user/ 路由在应用中使用 app.route 装饰器定义。

/static/ 路由是 Flask 添加的特殊路由，用于访问静态文件。

URL 映射中的 (HEAD, OPTIONS, GET) 是请求方法，由路由进行处理。HTTP 规范中规定，每个请求都有对应的处理方法，这通常表示客户端想让服务器执行什么样的操作。

Flask 为每个路由都指定了请求方法，这样即使不同的请求方法发送到相同的 URL 上时，也会使用不同的视图函数处理。

HEAD 和 OPTIONS 方法由 Flask 自动处理，因此可以这么说，在这个应用中，URL 映射中的 3 个路由都使用 GET 方法（表示客户端想请求信息，例如一个网页）

请求对象

Flask 通过上下文变量 request 对外开放请求对象。包含客户端发送的 HTTP 请求的全部信息

Flask 请求对象中最常用的属性和方法

属性或方法	说明
form	一个字典，存储请求提交的所有表单字段
args	一个字典，存储通过 URL 查询字符串传递的所有参数
values	一个字典， form 和 args 的合集
cookies	一个字典，存储请求的所有 cookie
headers	一个字典，存储请求的所有 HTTP 首部
files	一个字典，存储请求上传的所有文件
get_data()	返回请求主体缓冲的数据
get_json()	返回一个 Python 字典，包含解析请求主体后得到的 JSON
blueprint	处理请求的 Flask 蓝本的名称；蓝本在第 7 章介绍
endpoint	处理请求的 Flask 端点的名称；Flask 把视图函数的名称用作路由端点的名称
method	HTTP 请求方法，例如  GET 或 POST
scheme	URL 方案（ http 或 https）
is_secure()	通过安全的连接（HTTPS）发送请求时返回  True
host	请求定义的主机名，如果客户端定义了端口号，还包括端口号
path	URL 的路径部分
query_string	URL 的查询字符串部分，返回原始二进制值
full_path	URL 的路径和查询字符串部分
url	客户端请求的完整 URL
base_url	同  url，但没有查询字符串部分
remote_addr	客户端的 IP 地址
environ	请求的原始 WSGI 环境字典

请求钩子

在处理请求之前或之后执行代码

在请求开始时，可能需要创建数据库连接或者验证发起请求的用户身份。

为了避免在每个视图函数中都重复编写代码，Flask 提供了注册通用函数的功能，注册的函数可在请求被分派到视图函数之前或之后调用。

请求钩子通过装饰器实现。Flask 支持以下 4 种钩子

before_request

注册一个函数，在每次请求之前运行。

before_first_request

注册一个函数，只在处理第一个请求之前运行。可以通过这个钩子添加服务器初始化任务。

after_request

注册一个函数，如果没有未处理的异常抛出，在每次请求之后运行。

teardown_request

注册一个函数，即使有未处理的异常抛出，也在每次请求之后运行。

共享数据

在请求钩子函数和视图函数之间共享数据一般使用上下文全局变量 g。

例如，before_request 处理程序可以从数据库中加载已登录用户，并将其保存到 g.user 中。

随后调用视图函数时，便可以通过 g.user 获取用户。

响应

Flask 调用视图函数后，会将其返回值作为响应的内容。

多数情况下，响应就是一个简单的字符串，作为 HTML 页面回送客户端。

状态码

HTTP 协议需要的不仅是作为请求响应的字符串。

HTTP 响应中一个很重要的部分是状态码，Flask 默认设为 200，表明请求已被成功处理。

如果视图函数返回的响应需要使用不同的状态码，可以把数字代码作为第二个返回值，添加到响应文本之后。

例如，下述视图函数返回 400 状态码，表示请求无效：

@app.route('/')
def index():
    return '<h1>Bad Request</h1>', 400

响应首部

视图函数返回的响应还可接受第三个参数，这是一个由 HTTP 响应首部组成的字典

make_response()

如果不想返回由 1 个、2 个或 3 个值组成的元组，Flask 视图函数还可以返回一个响应对象。

make_response() 函数可接受 1 个、2 个或 3 个参数（和视图函数的返回值一样），然后返回一个等效的响应对象。

有时我们需要在视图函数中生成响应对象，然后在响应对象上调用各个方法，进一步设置响应。下例创建一个响应对象，然后设置 cookie：

from flask import make_response

@app.route('/')
def index():
    response = make_response('<h1>This document carries a cookie!</h1>')
    response.set_cookie('answer', '42')
    return response

响应对象最常使用的属性和方法

属性或方法	说明
status_code	HTTP 数字状态码
headers	一个类似字典的对象，包含随响应发送的所有首部
set_cookie()	为响应添加一个 cookie
delete_cookie()	删除一个 cookie
content_length	响应主体的长度
content_type	响应主体的媒体类型
set_data()	使用字符串或字节值设定响应
get_data()	获取响应主体

重定向

响应有个特殊的类型，称为重定向。

这种响应没有页面文档，只会告诉浏览器一个新 URL，用以加载新页面。

重定向经常在 Web 表单中使用

重定向的状态码通常是 302，在 Location 首部中提供目标 URL。

重定向响应可以使用 3 个值形式的返回值生成，也可在响应对象中设定。

由于使用频繁，Flask 提供了 redirect() 辅助函数，用于生成这种响应：

redirect()

from flask import redirect

@app.route('/')
def index():
    return redirect('http://www.example.com')

abort()

一种特殊的响应由 abort() 函数生成，用于处理错误。

abort() 不会把控制权交还给调用它的函数，而是抛出异常

在下面这个例子中，如果 URL 中动态参数 id 对应的用户不存在，就返回状态码 404

from flask import abort

@app.route('/user/<id>')
def get_user(id):
    user = load_user(id)
    if not user:
        abort(404)
    return '<h1>Hello, {}</h1>'.format(user.name)

[WangShuXian6]

模板

开发出易于维护的应用，关键在于编写形式简洁且结构良好的代码

Flask 视图函数的两个完全独立的作用却被融合在了一起，这就产生了一个问题。

视图函数的作用很明确，即生成请求的响应

对最简单的请求来说，这就足够了，但很多情况下，请求会改变应用的状态，而这种变化就发生在视图函数中。

业务逻辑和表现逻辑

以用户在网站中注册新账户的过程为例。

用户在表单中输入电子邮件地址和密码，然后点击提交按钮。服务器接收到包含用户输入数据的请求，然后 Flask 把请求分派给处理注册请求的视图函数。这个视图函数需要访问数据库，添加新用户，然后生成响应回送浏览器，指明操作成功还是失败。这两个过程分别称为业务逻辑和表现逻辑。

把业务逻辑和表现逻辑混在一起会导致代码难以理解和维护

把表现逻辑移到模板中能提升应用的可维护性

模板 渲染

模板是包含响应文本的文件，其中包含用占位变量表示的动态部分，其具体值只在请求的上下文中才能知道。

使用真实值替换变量，再返回最终得到的响应字符串，这一过程称为渲染。

为了渲染模板，Flask 使用一个名为 Jinja2 的强大模板引擎。

Jinja2模板引擎

形式最简单的 Jinja2 模板就是一个包含响应文本的文件

templates/index.html：Jinja2 模板

<h1>Hello World!</h1>

使用变量

templates/user.html：Jinja2 模板

<h1>Hello, {{ name }}!</h1>

渲染模板 render_template()

默认情况下，Flask 在应用目录中的 templates 子目录里寻找模板

hello.py：渲染模板

from flask import Flask, render_template

# ...

@app.route('/')
def index():
    return render_template('index.html')

@app.route('/user/<name>')
def user(name):
    return render_template('user.html', name=name)

Flask 提供的 render_template() 函数把 Jinja2 模板引擎集成到了应用中。

这个函数的第一个参数是模板的文件名，随后的参数都是键 – 值对，表示模板中变量对应的具体值。

在这段代码中，第二个模板收到一个名为 name 的变量。

前例中的 name=name 是经常使用的关键字参数。

左边的 name 表示参数名，就是模板中使用的占位符；

右边的 name 是当前作用域中的变量，表示同名参数的值。

两侧使用相同的变量名是很常见，但不是强制要求。

变量

在模板中使用的 {{ name }} 结构表示一个变量，这是一种特殊的占位符，告诉模板引擎这个位置的值从渲染模板时使用的数据中获取。

Jinja2 能识别所有类型的变量，甚至是一些复杂的类型，例如列表、字典和对象

<p>A value from a dictionary: {{ mydict['key'] }}.</p>
<p>A value from a list: {{ mylist[3] }}.</p>
<p>A value from a list, with a variable index: {{ mylist[myintvar] }}.</p>
<p>A value from an object's method: {{ myobj.somemethod() }}.</p>

Jinja2变量过滤器

变量的值可以使用过滤器修改。过滤器添加在变量名之后，二者之间以竖线分隔。

下述模板把 name 变量的值变成首字母大写的形式：

Hello, {{ name|capitalize }}

Jinja2变量过滤器

过滤器名	说明
safe	渲染值时不转义
capitalize	把值的首字母转换成大写，其他字母转换成小写
lower	把值转换成小写形式
upper	把值转换成大写形式
title	把值中每个单词的首字母都转换成大写
trim	把值的首尾空格删掉
striptags	渲染之前把值中所有的 HTML 标签都删掉

完整的过滤器列表可在 Jinja2 文档（http://jinja.pocoo.org/docs/2.10/templates/#builtin-filters）中查看。

safe 过滤器

默认情况下，出于安全考虑，Jinja2 会转义所有变量。

例如，如果一个变量的值为 '<h1>Hello</h1>'，Jinja2 会将其渲染成 '&lt;h1&gt;Hello&lt;/ h1&gt;'，

浏览器能显示这个 h1 元素，但不会解释它。

很多情况下需要显示变量中存储的 HTML 代码，这时就可使用 safe 过滤器。

千万别在不可信的值上使用 safe 过滤器，例如用户在表单中输入的文本。

控制结构

Jinja2 提供了多种控制结构，可用来改变模板的渲染流程

在模板中使用条件判断语句

{% if user %}
    Hello, {{ user }}!
{% else %}
    Hello, Stranger!
{% endif %}

使用 for 循环

<ul>
    {% for comment in comments %}
        <li>{{ comment }}</li>
    {% endfor %}
</ul>

宏

宏类似于 Python 代码中的函数

{% macro render_comment(comment) %}
    <li>{{ comment }}</li>
{% endmacro %}

<ul>
    {% for comment in comments %}
        {{ render_comment(comment) }}
    {% endfor %}
</ul>

为了重复使用宏，可以把宏保存在单独的文件中，然后在需要使用的模板中导入：

{% import 'macros.html' as macros %}

<ul>
    {% for comment in comments %}
        {{ macros.render_comment(comment) }}
    {% endfor %}
</ul>

需要在多处重复使用的模板代码片段可以写入单独的文件，再引入所有模板中，以避免重复：

{% include 'common.html' %}

模板继承

重复使用代码的强大方式

类似于 Python 代码中的类继承

首先，创建一个名为 base.html 的基模板：

<html>
<head>
    {% block head %}
    <title>{% block title %}{% endblock %} - My Application</title>
    {% endblock %}
</head>
<body>
    {% block body %}
    {% endblock %}
</body>
</html>

基模板中定义的区块可在衍生模板中覆盖。

Jinja2 使用 block 和 endblock 指令在基模板中定义内容区块。

在本例中，我们定义了名为 head、title 和 body 的区块。

注意，title 包含在 head 中。

基模板的衍生模板：

{% extends "base.html" %}
{% block title %}Index{% endblock %}
{% block head %}
    {{ super() }}
    <style>
    </style>
{% endblock %}
{% block body %}
<h1>Hello, World!</h1>
{% endblock %}

extends 指令声明这个模板衍生自 base.html。

在 extends 指令之后，基模板中的 3 个区块被重新定义，模板引擎会将其插入适当的位置。

如果基模板和衍生模板中的同名区块中都有内容，衍生模板中的内容将显示出来。

在衍生模板的区块里可以调用 super()，引用基模板中同名区块里的内容。上例中的 head 区块就是这么做的。

使用Flask-Bootstrap集成Bootstrap

要想在应用中集成 Bootstrap，最直接的方法是根据 Bootstrap 文档中的说明对 HTML 模板进行必要的改动。

不过，这个任务使用 Flask 扩展处理要简单得多，而且相关的改动不会导致主逻辑凌乱不堪。

安装 Flask-Bootstrap

(venv) $ pip install flask-bootstrap

初始化 Flask-Bootstrap

Flask 扩展在创建应用实例时初始化

hello.py：初始化 Flask-Bootstrap

把应用实例作为参数传给构造函数

from flask_bootstrap import Bootstrap

# ...

bootstrap = Bootstrap(app)

初始化 Flask-Bootstrap 之后，就可以在应用中使用一个包含所有 Bootstrap 文件和一般结构的基模板。应用利用 Jinja2 的模板继承机制来扩展这个基模板

使用 Flask-Bootstrap 的模板

templates/user.html：使用 Flask-Bootstrap 的模板

{% extends "bootstrap/base.html" %}

{% block title %}Flasky{% endblock %}

{% block navbar %}
<div class="navbar navbar-inverse" role="navigation">
    <div class="container">
        <div class="navbar-header">
            <button type="button" class="navbar-toggle"
            data-toggle="collapse" data-target=".navbar-collapse">
                <span class="sr-only">Toggle navigation</span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
                <span class="icon-bar"></span>
            </button>
            <a class="navbar-brand" href="/">Flasky</a>
        </div>
        <div class="navbar-collapse collapse">
            <ul class="nav navbar-nav">
                <li><a href="/">Home</a></li>
            </ul>
        </div>
    </div>
</div>
{% endblock %}

{% block content %}
<div class="container">
    <div class="page-header">
        <h1>Hello, {{ name }}!</h1>
    </div>
</div>
{% endblock %}

Jinja2 中的 extends 指令从 Flask-Bootstrap 中导入 bootstrap/base.html，从而实现模板继承。Flask-Bootstrap 的基模板提供了一个网页骨架，引入了 Bootstrap 的所有 CSS 和 JavaScript 文件。

上面这个 user.html 模板定义了 3 个区块，分别名为 title、navbar 和 content。这些区块都是基模板提供的，可在衍生模板中重新定义。title 区块的作用很明显，其中的内容会出现在渲染后的 HTML 文档头部，放在