---

从零开始：踏上 Python Web 开发之旅，深入浅出 Flask 框架

互联网是现代社会不可或缺的基础设施，而驱动互联网的，是无数运行在服务器上的 Web 应用程序。从你每天浏览的资讯网站、使用的社交媒体，到在线购物平台，无一不是 Web 应用的体现。如果你对构建自己的网站、服务或 API 感兴趣，Web 开发无疑是一个充满创意和挑战的领域。

对于刚接触 Web 开发的新手来说，选择一个合适的入门框架至关重要。它既要功能强大，能够完成实际任务，又不能过于复杂，让初学者望而生畏。在 Python 的世界里，有两个主流的 Web 框架：Django 和 Flask。Django 是一个功能齐全的“全栈”框架，自带大量组件（如 ORM、模板引擎、管理员面板等），适合快速开发大型应用。而 Flask，则是一个以简洁和灵活性著称的“微框架”。

本文将聚焦 Flask，带领完全没有 Web 开发经验，但具备基础 Python 知识的你，一步一步地学习这个优雅而强大的框架。我们将从最基本的概念讲起，搭建开发环境，编写第一个 Flask 应用，并逐步深入理解其核心组件，最终为你构建更复杂的 Web 应用打下坚实的基础。

一、为什么选择 Flask？微框架的魅力

在正式开始学习之前，我们先来了解一下为什么 Flask 是一个非常适合初学者入门的框架，以及它“微框架”的含义：

1. 微而强大 (Micro but Mighty): “微框架”并不意味着功能不足。Flask 只是在核心功能上保持精简，它不强制你使用特定的数据库、模板引擎或验证工具。它只提供处理 HTTP 请求和响应、路由等核心功能。这就像提供了一块精心设计的积木基础，你可以根据自己的需求，选择和集成各种优秀的第三方库来搭建你的应用。
2. 易于学习和理解: Flask 的代码结构清晰，API 设计直观，核心概念相对较少。入门门槛低，你可以很快地构建一个可以运行的 Web 应用，获得成就感。
3. 灵活性高: 正因为不绑定大量组件，你可以自由选择最适合你项目的技术栈。无论是使用哪种数据库 (SQLAlchemy, Peewee)，哪种模板引擎 (Jinja2 是默认推荐的)，或者构建 RESTful API，Flask 都能很好地适应。
4. 丰富的扩展 (Extensions): 尽管 Flask 核心精简，但社区为其开发了大量的扩展，涵盖数据库集成、用户认证、表单处理、调试工具等方方面面。这些扩展可以轻松地添加到你的项目中，弥补了核心的精简，同时保持了选择的自由度。
5. 良好的文档和社区支持: Flask 拥有清晰、易懂的官方文档，社区活跃，遇到问题很容易找到解决方案。

总而言之，Flask 就像一个精巧的工具箱，提供了开始 Web 开发所需的必备工具，并允许你根据需要添加更多专业工具。它能让你快速理解 Web 应用的基本工作原理，是学习其他更大型框架（如 Django）或深入 Web 后端开发的绝佳跳板。

二、万事开头难？准备你的学习环境

在开始编写 Flask 代码之前，我们需要做好一些准备工作：

1. 安装 Python: 确保你的电脑上已经安装了 Python 3.6 或更高版本。你可以访问 https://www.python.org/downloads/ 下载并安装。安装完成后，打开命令行终端（Windows 用户可以使用 Command Prompt 或 PowerShell，macOS/Linux 用户使用 Terminal），输入 python --version 或 python3 --version 来确认安装成功并查看版本号。
2. 掌握 Python 基础: 本文假设你已经了解 Python 的基本语法，包括变量、数据类型（字符串、列表、字典）、函数、控制流（if/else, for 循环）、模块导入等。如果你对这些概念还不熟悉，建议先花时间学习 Python 基础知识。
3. 了解命令行基础: 你需要知道如何在终端中导航目录（cd 命令）、运行 Python 脚本（python your_script.py）以及使用包管理工具 pip。
4. 理解 HTTP 基础 (可选但强烈推荐): Web 应用基于 HTTP 协议工作。了解请求 (Request) 和响应 (Response)、HTTP 方法 (GET, POST) 等基本概念将极大地帮助你理解 Flask 的工作原理。

搭建隔离的开发环境 – 虚拟环境 (Virtual Environments)

在 Python 开发中，强烈推荐使用虚拟环境。它可以为你的每个项目创建一个独立的 Python 环境，使得项目依赖的库之间不会相互冲突。

操作步骤:

• 打开命令行终端。
• 导航到你想要创建项目的文件夹。
• 创建一个虚拟环境。通常，我们会给虚拟环境命名为 venv 或 .venv：
  bash
python -m venv venv
• 激活虚拟环境：
  • Windows:
    bash
venv\Scripts\activate
  • macOS/Linux:
    bash
source venv/bin/activate
• 激活成功后，你会看到命令行提示符前面出现了虚拟环境的名称（例如 (venv)）。现在，你在这个环境中安装的所有 Python 包都只会存在于这个虚拟环境中，不会影响到全局 Python 环境或其他项目的虚拟环境。
• 当你想退出虚拟环境时，只需输入 deactivate。

安装 Flask:

虚拟环境激活后，使用 pip 安装 Flask：

bash
pip install Flask

pip 会自动下载并安装 Flask 及其依赖项。现在，你的开发环境已经准备就绪！

三、第一个 Flask 应用：Hello, World!

按照程序员的传统，我们的第一个应用将是经典的 “Hello, World!”。这个简单的例子将展示 Flask 应用的基本结构。

在一个新的文件夹（比如 my_first_flask_app）中，确保你已经创建并激活了虚拟环境，然后创建一个名为 app.py 的文件。

在 app.py 中输入以下代码：

“`python

导入 Flask 类

from flask import Flask

创建 Flask 应用实例

name 是 Python 模块的内置变量

如果这个文件是直接运行的，name 的值就是 ‘main‘

Flask 用这个参数来确定应用根路径，以便找到资源文件（如模板、静态文件）

app = Flask(name)

定义一个路由

@app.route(‘/’) 装饰器将 URL 路径 ‘/’ 映射到后面的函数

当用户访问应用的根 URL 时，就会触发这个函数

@app.route(‘/’)
def hello_world():
“””
处理根 URL (‘/’) 的请求，返回一个简单的字符串作为响应
“””
return ‘Hello, World!’

运行应用

if name == ‘main‘: 确保只有直接运行这个脚本时才会执行 app.run()

如果这个脚本被其他文件导入，下面的代码不会执行

if name == ‘main‘:
# app.run() 启动 Flask 内置的开发服务器
# debug=True 开启调试模式，当代码修改后服务器会自动重启，并且能提供更详细的错误信息
app.run(debug=True)
“`

保存文件。

现在，在命令行终端中，确保你在 my_first_flask_app 文件夹内并且虚拟环境已激活，然后运行你的应用：

bash
python app.py

你应该会看到类似以下的输出：

* Serving Flask app 'app'
* Debug mode: on
WARNING: This is a development server. Do not use it in a production deployment. Use a production WSGI server instead.
* Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

这表示 Flask 开发服务器已经在你的本地机器上启动，监听端口 5000。打开你的网页浏览器，访问地址 http://127.0.0.1:5000/。你应该能看到页面上显示着 “Hello, World!”。

恭喜你！你已经成功创建并运行了你的第一个 Flask Web 应用。

代码解析:

• from flask import Flask: 从 Flask 库中导入 Flask 类。这是所有 Flask 应用的基础。
• app = Flask(__name__): 创建一个 Flask 类的实例，即一个 Flask 应用对象。__name__ 是一个特殊的 Python 变量，它表示当前模块的名称。对于一个作为主程序运行的脚本，__name__ 的值是 '__main__'。Flask 使用这个参数来确定应用根目录的位置，这对寻找模板和静态文件非常重要。
• @app.route('/'): 这是一个装饰器 (decorator)。在 Python 中，装饰器是一种特殊的函数，它能够修改其他函数的行为。这里的 @app.route('/') 装饰器告诉 Flask，当用户访问 URL / 时，就调用紧随其后的那个函数 (hello_world) 来处理请求。/ 代表网站的根路径。
• def hello_world():: 这是一个 Python 函数，我们称之为“视图函数” (View Function)。它的作用是处理来自 @app.route 指定的 URL 的请求，并返回一个响应。在这个例子中，它返回一个简单的字符串 'Hello, World!'。Flask 会把这个字符串作为 HTTP 响应发送给用户的浏览器。
• if __name__ == '__main__':: 这是标准的 Python 写法，用于判断当前脚本是否是直接运行的。如果是，那么 __name__ 变量的值就是 '__main__'。
• app.run(debug=True): 启动 Flask 应用的开发服务器。debug=True 开启了调试模式，这在开发阶段非常有用。它会提供详细的错误信息，并且在代码发生修改时自动重新加载应用，无需手动重启服务器。注意：在生产环境中绝对不能开启调试模式，因为它会暴露敏感信息！

四、深入核心：Flask 的关键概念

现在你已经运行了一个最简单的 Flask 应用，接下来我们将详细讲解构建更复杂应用所需的核心概念。

4.1 路由 (Routing)

路由是将特定的 URL 路径映射到相应的视图函数的机制。在 Flask 中，我们使用 @app.route() 装饰器来定义路由。

基本路由:

“`python
@app.route(‘/about’)
def about():
return ‘这是关于我们页面’

@app.route(‘/contact’)
def contact():
return ‘联系方式：…’
“`

当你访问 http://127.0.0.1:5000/about 时，about() 函数会被调用；访问 http://127.0.0.1:5000/contact 时，contact() 函数会被调用。

变量规则 (Variable Rules):

很多时候，URL 中需要包含动态部分，比如用户的 ID 或文章的标题。Flask 允许你在路由中使用变量规则。

“`python
@app.route(‘/user/‘)
def show_user_profile(username):
# username 是从 URL 中捕获的字符串
return f’用户：{username}’

@app.route(‘/post/‘)
def show_post(post_id):
# post_id 是从 URL 中捕获的整数
return f’文章 ID：{post_id}’

@app.route(‘/path/‘)
def show_subpath(subpath):
# subpath 可以匹配包含斜杠的完整路径
return f’子路径：{subpath}’
“`

在上面的例子中，<username>、<int:post_id>、<path:subpath> 是变量规则。Flask 会从 URL 中提取这些动态部分的值，并将它们作为参数传递给视图函数。你可以指定变量的类型，常用的转换器 (converter) 包括：

• string (默认): 接受任何不包含斜杠的字符串。
• int: 接受整数。
• float: 接受浮点数。
• path: 接受包含斜杠的字符串。
• uuid: 接受 UUID 字符串。

HTTP 方法限制:

一个路由可以响应不同的 HTTP 方法（如 GET, POST, PUT, DELETE 等）。默认情况下，路由只响应 GET 请求。你可以通过 methods 参数指定允许的方法：

“`python
from flask import request # 导入 request 对象

@app.route(‘/login’, methods=[‘GET’, ‘POST’])
def login():
if request.method == ‘POST’:
# 处理 POST 请求的数据，比如表单提交
username = request.form.get(‘username’) # 获取表单中的用户名
password = request.form.get(‘password’) # 获取表单中的密码
# … 验证用户名密码等逻辑 …
return ‘登录成功！’ # 或者重定向到其他页面
else: # request.method == ‘GET’
# 显示登录表单
return ‘请通过 POST 方法提交登录信息’ # 实际应用中会渲染一个 HTML 模板
“`

4.2 请求 (Request) 和响应 (Response)

Web 开发的核心在于处理客户端（通常是浏览器）发来的 请求 (Request)，并生成返回给客户端的 响应 (Response)。

Flask 提供了全局的 request 对象（需要从 flask 模块导入），它包含了当前请求的所有信息：

• request.method: 请求方法（如 'GET', 'POST'）。
• request.args: URL 查询参数（如 ?name=value），以字典形式访问。
• request.form: 表单提交的数据，以字典形式访问（通常用于 POST 请求）。
• request.json: 如果请求体是 JSON 格式，可以通过它访问解析后的数据。
• request.headers: 请求头信息。
• request.remote_addr: 客户端的 IP 地址。
• request.url: 完整的请求 URL。
• request.files: 上传的文件。

视图函数返回的值就是响应。可以是：

• 字符串: Flask 会将其作为响应体发送，内容类型默认为 text/html 或 text/plain。
  python
return '<h1>Hello!</h1>'
• 元组: 可以返回一个包含响应体、状态码和响应头的元组。
  python
return '创建成功', 201 # 返回状态码 201 (Created)
return '自定义头部', 200, {'X-My-Header': 'Value'}
• Response 对象: 可以直接创建 Flask 提供的 Response 对象，进行更精细的控制。
  python
from flask import Response
# ...
resp = Response('自定义内容', status=200, mimetype='text/plain')
resp.headers['X-Another-Header'] = 'Another Value'
return resp

• 重定向 (Redirect): 使用 redirect() 函数可以将用户重定向到另一个 URL。
  python
from flask import redirect, url_for
# ...
return redirect(url_for('index')) # 重定向到名为 'index' 的路由对应的 URL
url_for() 函数是 Flask 中非常重要的一个函数，它可以根据视图函数的名称动态生成对应的 URL。这样做的好处是，即使你更改了路由的 URL 路径，只要函数名称不变，url_for() 生成的链接依然有效，避免了硬编码 URL 带来的维护问题。例如，如果你的根路由是 @app.route('/') def index(): ...，那么 url_for('index') 就会生成 /。如果后来你把根路由改成了 @app.route('/home') def index(): ...，url_for('index') 就会自动生成 /home。

• JSON 响应: 使用 jsonify() 函数可以方便地返回 JSON 格式的响应，这在构建 API 时非常常用。
  python
from flask import jsonify
# ...
@app.route('/api/data')
def get_data():
data = {
'name': 'Flask Example',
'version': '1.0',
'items': [1, 2, 3]
}
return jsonify(data)

4.3 模板 (Templates)

直接在视图函数中返回 HTML 字符串对于简单的例子尚可，但对于复杂的页面来说，将 HTML 结构、样式和 Python 逻辑混杂在一起是非常糟糕的做法。这使得代码难以阅读、维护和重用。

Flask 推荐使用模板引擎来解决这个问题。模板引擎允许你创建包含占位符和控制结构的文本文件（通常是 HTML），然后在运行时用实际数据填充这些占位符，生成最终的响应。Flask 默认使用 Jinja2 模板引擎，这是一个非常强大和灵活的模板引擎。

使用模板的步骤:

1. 创建 templates 文件夹: 在你的 Flask 应用根目录（与 app.py 同级）创建一个名为 templates 的文件夹。所有模板文件都应该放在这里。
2. 编写模板文件: 在 templates 文件夹中创建一个 HTML 文件，比如 index.html。
   html
<!-- templates/index.html -->
<!DOCTYPE html>
<html>
<head>
<title>My Flask App</title>
</head>
<body>
<h1>欢迎来到我的网站！</h1>
<p>这是一个简单的示例页面。</p>
<p>来自服务器的消息：{{ message }}</p>
</body>
</html>
   注意 { { message } } 这是 Jinja2 模板的语法，表示一个变量占位符。
3. 在视图函数中渲染模板: 使用 Flask 提供的 render_template() 函数（需要从 flask 导入）来加载并渲染模板。
   python
from flask import render_template
# ...
@app.route('/')
def index():
greeting = "Hello from Flask!"
# 查找 templates 文件夹中的 index.html 文件
# 并将 Python 变量 greeting 传递给模板，在模板中可以通过 message 访问
return render_template('index.html', message=greeting)
render_template() 函数的第一个参数是模板文件的名称（相对于 templates 文件夹），后续参数是你想传递给模板的变量，以关键字参数的形式传递，变量名即模板中使用的占位符名称。

Jinja2 模板基础语法:

• 变量: { { variable_name } }：用于显示 Python 变量的值。

• 控制结构: {% ... %}：用于编写逻辑，如 if 语句和 for 循环。
  “`html
  {% if user %}

  你好, {{ user.name }}!

  {% else %}

  请登录

  {% endif %}

  {% for item in items %}
  • {{ item }}

  {% endfor %}

  * **注释:** `{# ... #}`：模板中的注释，不会显示在最终生成的 HTML 中。
* **模板继承:** Jinja2 最强大的特性之一是模板继承。你可以定义一个基础模板 (`base.html`) 包含网页的公共部分（如头部、导航、底部），并在其中定义一些“块” (`{% block block_name %}{% endblock %}`)。其他模板可以继承基础模板，并覆盖（填充）这些块。html
  
  <!DOCTYPE html>
  
  
  
  
  

  ---

  {% block content %}{% endblock %}

  ---

  
  

  
  {% extends ‘base.html’ %}

  {% block title %}首页{% endblock %}

  {% block content %}

  欢迎来到我的网站！

  这是一个简单的示例页面。

  {% endblock %}
  “`
  继承极大地提高了模板的可重用性。

4.4 静态文件 (Static Files)

Web 应用除了动态生成的 HTML 页面，还需要提供静态资源，如 CSS 文件（控制样式）、JavaScript 文件（提供交互性）和图片文件。

Flask 会自动处理位于应用根目录下的一个名为 static 的文件夹中的文件。

使用静态文件的步骤:

1. 创建 static 文件夹: 在你的 Flask 应用根目录（与 app.py 同级）创建一个名为 static 的文件夹。
2. 组织静态文件: 在 static 文件夹内，你可以创建子文件夹来组织不同类型的静态文件，例如 static/css、static/js、static/images。
3. 在模板中链接静态文件: 在模板中，使用 url_for() 函数并指定端点名为 'static' 来生成静态文件的 URL。
   html
<!-- templates/base.html 中 -->
<head>
<title>{% block title %}{% endblock %} - My Flask App</title>
<!-- 链接到 static/css/style.css -->
<link rel="stylesheet" href="{{ url_for('static', filename='css/style.css') }}">
</head>
<body>
<nav>
<a href="{{ url_for('index') }}">首页</a>
<a href="{{ url_for('about') }}">关于我们</a>
</nav>
<hr>
{% block content %}{% endblock %}
<hr>
<footer>
<!-- 链接到 static/images/logo.png -->
<img src="{{ url_for('static', filename='images/logo.png') }}" alt="Logo">
&copy; 2023 My Flask App
</footer>
<!-- 链接到 static/js/script.js -->
<script src="{{ url_for('static', filename='js/script.js') }}"></script>
</body>
</html>
url_for('static', filename='...') 会生成指向 /static/your/file/path 的 URL。

五、构建一个简单的示例应用（概念）

将上述概念结合起来，我们可以构建一个简单的应用，比如一个非常简陋的在线记事本或博客。这里我们只描述其结构和思路，不提供完整的代码，以便你尝试自己实现。

应用目标: 显示一个记事列表，并允许添加新的记事。

文件结构:

my_notepad_app/
├── venv/ # 虚拟环境文件夹
├── static/
│ └── css/
│ └── style.css # 样式文件
├── templates/
│ ├── base.html # 基础模板
│ ├── index.html # 显示记事列表的模板
│ └── add_note.html # 添加记事的表单模板
└── app.py # Flask 应用主文件

app.py 思路:

• 导入 Flask, render_template, request, redirect, url_for。
• 创建一个 Flask 应用实例。
• 使用一个 Python 列表或字典作为临时存储记事的数据源（实际应用会用数据库）。
• 路由 /:
  • 方法：GET。
  • 视图函数：index()。
  • 功能：从存储中获取所有记事，渲染 index.html 模板，并将记事列表作为变量传递给模板。
• 路由 /add:
  • 方法：GET, POST。
  • 视图函数：add_note()。
  • 功能：
    • 如果是 GET 请求，渲染 add_note.html 模板，显示添加记事的表单。
    • 如果是 POST 请求（用户提交了表单），从 request.form 中获取表单数据（比如记事内容），将新记事添加到存储中，然后重定向到 / 页面（使用 redirect(url_for('index'))）。
• 使用 if __name__ == '__main__': app.run(debug=True) 启动应用。

templates/base.html 思路:

• 定义基本的 HTML 结构、头部、导航、底部。
• 使用 {% block title %} 和 {% block content %} 定义可覆盖的块。
• 链接到 static/css/style.css 使用 url_for('static', filename='css/style.css')。

templates/index.html 思路:

• {% extends 'base.html' %} 继承基础模板。
• 在 {% block title %} 中设置页面标题。
• 在 {% block content %} 中：
  • 显示一个标题，比如“我的记事”。
  • 使用 {% for note in notes %} 循环遍历从视图函数传递过来的记事列表。
  • 在循环中显示每个记事的内容。
  • 添加一个链接到 /add 页面，用于添加新记事 (<a href="{{ url_for('add_note') }}">添加记事</a>)。

templates/add_note.html 思路:

• {% extends 'base.html' %} 继承基础模板。
• 在 {% block title %} 中设置页面标题。
• 在 {% block content %} 中：
  • 显示一个标题，比如“添加新记事”。
  • 创建一个 HTML <form> 表单，method="post"，action="{{ url_for('add_note') }}"。
  • 在表单中包含一个文本输入区域 (<textarea>) 用于输入记事内容。
  • 包含一个提交按钮 (<button type="submit">保存</button>)。

通过实现这个简单的例子，你就能将路由、请求、响应、模板和静态文件等核心概念串联起来，构建一个具备基本功能的 Web 应用。

六、 Flask 的扩展：构建更复杂的应用

Flask 的核心非常精简，但通过丰富的扩展，它能够胜任各种复杂的任务。安装扩展通常使用 pip，并在应用中进行简单的配置和初始化。

一些常用的 Flask 扩展：

• Flask-SQLAlchemy: 集成 SQLAlchemy ORM（对象关系映射），让你使用 Python 类来操作数据库，而无需直接写 SQL 语句。这是 Flask 应用中最常用的扩展之一。
• Flask-WTF: 集成 WTForms 库，简化表单的创建、处理和验证。可以方便地定义表单字段、生成 HTML，并进行服务器端验证。
• Flask-Login: 提供用户会话管理、登录、注销、记住我等功能，简化用户认证流程。
• Flask-Migrate: 集成 Alembic，用于数据库模式的迁移。当你的数据库模型发生变化时，可以使用它来生成和应用数据库迁移脚本，而不会丢失现有数据。
• Flask-RESTful 或 Flask-RESTX: 用于快速构建 RESTful API。它们提供了一些方便的工具来处理请求解析、响应格式化和 API 文档生成。
• Flask-Mail: 用于发送电子邮件。

学习使用这些扩展是提升 Flask 开发效率和能力的必经之路。每个扩展都有自己的文档，通常也非常清晰易懂。

七、下一步去哪里？学习进阶方向

掌握了 Flask 的基础后，你可以继续深入学习：

1. 数据库: 学习如何使用 Flask-SQLAlchemy 连接并操作实际的数据库（如 SQLite, PostgreSQL, MySQL）。理解关系型数据库的概念和 SQL 基础。
2. 表单处理: 深入学习 Flask-WTF，掌握各种表单字段、验证器以及如何在模板中渲染表单。
3. 用户认证与授权: 学习 Flask-Login 等扩展，了解如何实现用户注册、登录、会话管理以及控制用户权限。
4. 构建 RESTful API: 学习如何使用 Flask 结合 jsonify 或 Flask-RESTful/Flask-RESTX 来构建和测试 API。
5. 错误处理: 学习如何在 Flask 中捕获和处理各种错误（如 404 Not Found, 500 Internal Server Error）。
6. 上下文 (Context): 理解 Flask 的请求上下文 (request context) 和应用上下文 (application context) 的概念，这对于理解某些高级特性和扩展至关重要。
7. 测试: 学习如何编写单元测试和集成测试来确保你的 Flask 应用按预期工作。
8. 部署 (Deployment): 学习如何将你的 Flask 应用从开发环境部署到生产服务器，通常需要使用 WSGI 服务器（如 Gunicorn, uWSGI）和 Web 服务器（如 Nginx, Apache），并考虑如何处理静态文件和数据库。

八、总结与鼓励

从零开始学习 Flask 框架是一段令人兴奋的旅程。你已经迈出了第一步，理解了 Flask 作为微框架的理念，掌握了搭建环境、创建第一个应用、理解了路由、请求、响应、模板和静态文件等核心概念。

Flask 的简洁设计使得你可以专注于 Web 开发的本质，逐步添加所需的功能。不要害怕错误，编程就是一个不断尝试、犯错、调试和学习的过程。

实践是最好的老师！ 学习的最佳方式是动手构建项目。从简单的记事本开始，然后尝试构建一个博客、一个简单的电商网站后端、或者一个提供数据服务的 API。每完成一个项目，你都会对 Flask 和 Web 开发有更深入的理解。

记住，你并不孤单。Flask 拥有庞大的社区和丰富的资源。遇到问题时，查阅官方文档、搜索在线教程、参与技术社区讨论，都能帮助你找到答案。

祝你在 Flask 的学习之路上一切顺利！

---