Flask 快速入门指南 – wiki基地

作者： /

Flask 快速入门指南：从零构建你的第一个 Web 应用

Web 开发是现代软件开发的核心领域之一。无论是构建一个简单的个人博客、一个企业级后台，还是一个复杂的 API 服务，Web 框架都能极大地提高开发效率。在众多 Python Web 框架中，Flask 以其“微框架”的哲学、简洁的设计和极高的灵活性赢得了大量开发者的青睐。

本指南将带你从零开始，一步步了解 Flask 的核心概念，并构建一个简单的 Web 应用。无论你是对 Web 开发感兴趣的 Python 初学者，还是希望了解 Flask 这个流行框架的资深开发者，这篇指南都将为你提供坚实的基础。

我们将从环境准备开始，然后构建最简单的 “Hello, World!” 应用，逐步深入到路由、模板、静态文件、表单处理等关键概念。

目录

  1. 什么是 Flask？
    • 微框架的哲学
    • Flask 的优势
    • Flask 的典型应用场景
  2. 准备工作
    • 安装 Python
    • 虚拟环境 (Virtual Environment) 的重要性
    • 创建和激活虚拟环境
  3. 安装 Flask
  4. 你的第一个 Flask 应用
    • 编写代码
    • 运行应用
    • 在浏览器中查看
  5. 理解第一个应用的代码
    • 导入 Flask
    • 创建 Flask 应用实例
    • 路由装饰器 @app.route()
    • 视图函数 (View Function)
    • 运行开发服务器
    • debug=True 的作用
  6. 路由 (Routing)
    • 添加更多路由
    • 带变量的路由
    • URL 变量类型转换器
  7. HTTP 方法 (HTTP Methods)
    • 常见的 HTTP 方法
    • 在 Flask 中指定 HTTP 方法
    • 访问请求数据 (request 对象)
  8. 使用模板 (Templates)
    • 为什么需要模板？
    • Jinja2 模板引擎
    • 创建 templates 文件夹
    • 编写第一个模板文件
    • 在视图函数中渲染模板 (render_template)
    • 向模板传递数据
    • Jinja2 语法基础 ({{}}, {% %}, {# #})
      • 变量
      • 控制结构 (if/else, for 循环)
      • 注释
  9. 处理静态文件 (Static Files)
    • 什么是静态文件？
    • 创建 static 文件夹
    • 在模板中链接静态文件 (url_for)
  10. 处理表单 (Form Handling)
    • 创建一个简单的 HTML 表单
    • 使用 GET 方法提交表单并获取数据
    • 使用 POST 方法提交表单并获取数据
  11. 重定向和错误处理
    • 重定向 (redirect 和 url_for)
    • 处理 404 页面未找到错误 (abort)
    • 自定义错误页面 (简述)
  12. 项目结构 (Simple Project Structure)
  13. 再进一步
    • Flask 扩展 (Extensions)
    • 数据库集成
    • 用户认证
    • 部署
  14. 总结

1. 什么是 Flask？

Flask 是一个使用 Python 语言编写的 Web 服务器网关接口（WSGI）Web 应用框架。它由 Armin Ronacher 领导的 Pocoo 团队开发。

微框架的哲学

Flask 被称为“微框架”不是因为它代码量少，而是因为它本身只包含 Web 应用最核心的功能：请求处理和路由。它不强制要求你使用特定的数据库、模板引擎或项目结构。这给了开发者极大的自由和灵活性，可以根据项目需求选择最合适的工具和库。

Flask 的优势

  • 简洁与灵活: 核心功能精简，易于理解和上手，非常适合构建小型应用或微服务。
  • 易于扩展: Flask 设计时就考虑了可扩展性，拥有丰富的第三方扩展库，可以轻松集成数据库、认证、缓存、表单验证等功能。
  • 文档完善: Flask 拥有高质量的官方文档和活跃的社区支持。
  • Python 生态: 能够充分利用 Python 强大的生态系统和各种库。
  • 适合学习: 对于初学者来说，Flask 的代码更容易理解，是学习 Web 开发原理的优秀选择。

Flask 的典型应用场景

  • 构建 RESTful API 服务
  • 开发小型到中型的 Web 应用
  • 快速原型开发
  • 微服务架构中的服务单元

2. 准备工作

在开始使用 Flask 之前，你需要确保你的计算机上安装了 Python。Flask 需要 Python 3.7 或更高版本。

安装 Python

大多数现代操作系统（如 macOS 和 Linux）已经预装了 Python。你可以在终端或命令提示符中输入 python --version 或 python3 --version 来检查是否安装以及安装的版本。如果未安装或版本过低，请访问 Python 官方网站 下载并安装最新版本。

虚拟环境 (Virtual Environment) 的重要性

在 Python 开发中，强烈建议使用虚拟环境。虚拟环境是一个独立的 Python 运行环境，它允许你为每个项目安装独立的库，而不会影响全局的 Python 环境或其他项目的库。这可以避免不同项目之间库版本冲突的问题。

Python 3.3+ 内置了 venv 模块，无需额外安装即可创建虚拟环境。

创建和激活虚拟环境

  1. 打开终端或命令提示符。
  2. 导航到你希望创建项目的文件夹。
  3. 创建虚拟环境：
    • 在 macOS/Linux 上：
      bash
      python3 -m venv myflaskenv
      这里 myflaskenv 是你给虚拟环境起的名字，你可以换成其他名字。
    • 在 Windows 上：
      bash
      python -m venv myflaskenv
  4. 激活虚拟环境：
    • 在 macOS/Linux 上：
      bash
      source myflaskenv/bin/activate
    • 在 Windows 上（Command Prompt）：
      bash
      myflaskenv\Scripts\activate.bat
    • 在 Windows 上（PowerShell）：
      powershell
      myflaskenv\Scripts\Activate.ps1
      激活成功后，你的终端提示符前面会显示虚拟环境的名字（例如 (myflaskenv)），表明你现在处于这个独立的 Python 环境中。

3. 安装 Flask

确保你的虚拟环境已激活。然后使用 pip 命令安装 Flask：

bash
pip install Flask

pip 会自动下载并安装 Flask 及其依赖项（如 Jinja2 用于模板，Werkzeug 用于 WSGI 工具集等）。

你可以通过 pip list 命令查看当前虚拟环境中安装的所有库，确认 Flask 是否安装成功。

4. 你的第一个 Flask 应用

现在，我们来编写一个最简单的 Flask 应用，它将在浏览器中显示 “Hello, World!”。

编写代码

创建一个名为 app.py 的文件（或者你喜欢的任何名字，但 .py 后缀是必须的）。在文件中输入以下代码：

“`python

app.py

from flask import Flask

创建 Flask 应用实例

name 是 Python 模块的内置变量，表示当前模块的名字

对于一个作为应用入口的脚本，它的 name 是 ‘main‘

app = Flask(name)

使用 app.route() 装饰器定义一个 URL 路由

斜杠 ‘/’ 表示应用的根 URL

@app.route(‘/’)
def hello_world():
# 这个函数被称为视图函数 (View Function)
# 它处理对指定 URL 的请求，并返回响应
return ‘Hello, World!’

当 app.py 作为主程序运行时，执行 app.run()

if name == ‘main‘:
# 运行开发服务器
# debug=True 开启调试模式
app.run(debug=True)
“`

运行应用

在激活的虚拟环境终端中，确保你位于 app.py 文件所在的目录，然后运行：

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)
Press Ctrl+C to quit

这表示 Flask 的开发服务器已经在你的本地机器上运行起来了。

在浏览器中查看

打开你的网页浏览器，在地址栏输入 http://127.0.0.1:5000/ 并回车。

你应该能在浏览器窗口中看到 “Hello, World!” 字符串。

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

5. 理解第一个应用的代码

让我们详细剖析一下刚才的代码：

  • from flask import Flask: 这一行从安装好的 flask 库中导入了 Flask 类。Flask 类是 Flask 应用的核心，用于创建你的 Web 应用实例。
  • app = Flask(__name__): 这一行创建了一个 Flask 类的实例，并将其赋值给变量 app。这是你的 Web 应用对象。__name__ 是一个 Python 内置变量，它会根据你的代码运行方式（作为主脚本还是作为模块被导入）自动设置为合适的值。在 Flask 中，__name__ 参数告诉 Flask 你的应用在哪里查找资源，比如模板和静态文件，这对于正确配置应用路径非常重要。
  • @app.route('/'): 这是一个 Python 装饰器（Decorator）。装饰器是 Python 的一种高级语法，用于修改或增强函数的功能。在这里，@app.route('/') 将它下面的函数注册为一个视图函数，并将其与特定的 URL 路径关联起来。当用户访问应用的根 URL（/）时，Flask 就会调用这个被装饰的函数。
  • def hello_world():: 这是一个普通的 Python 函数，它被 @app.route('/') 装饰器标记为处理 / URL 的视图函数。视图函数负责处理进入的 Web 请求。它必须返回一个响应，通常是一个字符串（作为 HTML 或纯文本）、一个模板渲染的结果、一个 JSON 响应或一个 Response 对象。在这个简单的例子中，它返回字符串 'Hello, World!'，Flask 会将这个字符串作为 HTTP 响应体发送回浏览器。
  • if __name__ == '__main__':: 这是标准的 Python 写法，用于判断当前脚本是否是直接运行的。如果是直接运行（而不是作为模块被其他脚本导入），那么 __name__ 的值就是 '__main__'。
  • app.run(debug=True): 这一行启动了 Flask 内置的开发服务器。
    • app.run() 会让应用开始监听来自客户端的请求。
    • debug=True 参数开启了调试模式。在调试模式下，服务器会在代码修改后自动重新加载，并且在发生错误时会显示一个交互式的调试器，这在开发过程中非常有用。请注意：调试模式会暴露应用内部信息，绝不能在生产环境中使用 debug=True！ 在生产环境部署时，你应该使用更强大和安全的 WSGI 服务器（如 Gunicorn, uWSGI 等）。

6. 路由 (Routing)

路由是将特定的 URL 路径映射到处理该路径的视图函数的过程。 @app.route() 装饰器是 Flask 中定义路由的主要方式。

添加更多路由

你可以为不同的 URL 定义不同的视图函数：

“`python

app.py (继续修改)

from flask import Flask

app = Flask(name)

@app.route(‘/’)
def index():
return ‘这是首页’

@app.route(‘/about’)
def about():
return ‘这是关于页面’

… other code …

if name == ‘main‘:
app.run(debug=True)
“`

保存文件，如果你的应用正在运行且 debug=True，它会自动重启。现在访问 http://127.0.0.1:5000/about，你将看到 “这是关于页面”。

带变量的路由

你可以在 URL 路径中包含变量部分，并将这些变量作为参数传递给视图函数。这对于创建动态 URL 非常有用，例如显示特定用户的个人资料或特定商品的详情页。

使用尖括号 <variable_name> 来定义 URL 变量：

“`python

app.py (继续修改)

from flask import Flask

app = Flask(name)

… previous routes …

@app.route(‘/user/‘)
def show_user_profile(username):
# username 将从 URL 中捕获并作为参数传递给函数
return f’用户: {username}’

@app.route(‘/post/‘)
def show_post(post_id):
# post_id 将从 URL 中捕获，并通过 int 转换器转换为整数
return f’帖子 ID: {post_id}’

… other code …

if name == ‘main‘:
app.run(debug=True)
“`

现在访问 http://127.0.0.1:5000/user/alice，会显示 “用户: alice”。访问 http://127.0.0.1:5000/post/123，会显示 “帖子 ID: 123″。如果访问 http://127.0.0.1:5000/post/abc，会返回 404 错误，因为 ‘abc’ 不能转换为整数。

URL 变量类型转换器

Flask 内置了几个常用的 URL 变量类型转换器：

  • <string:variable> (默认): 接受任何不包含斜杠 / 的字符串。
  • <int:variable>: 接受整数。
  • <float:variable>: 接受浮点数。
  • <path:variable>: 接受包含斜杠 / 的字符串，通常用于文件路径。
  • <uuid:variable>: 接受 UUID 字符串。

使用类型转换器可以确保 URL 变量是预期的类型，如果类型不匹配则会返回 404 错误。

7. HTTP 方法 (HTTP Methods)

Web 浏览器与服务器通信时，会使用不同的 HTTP 方法来表示请求的意图。最常见的两种方法是：

  • GET: 用于请求资源（例如，加载一个网页）。GET 请求的数据（如果需要）会附加在 URL 后面。
  • POST: 用于向服务器提交数据（例如，提交一个表单）。POST 请求的数据放在请求体中。

默认情况下，Flask 的路由只响应 GET 请求。如果你想让一个路由同时响应其他方法，可以在 @app.route() 装饰器中指定 methods 参数：

“`python

app.py (继续修改)

from flask import Flask, request # 需要导入 request 对象

app = Flask(name)

… previous routes …

@app.route(‘/login’, methods=[‘GET’, ‘POST’])
def login():
if request.method == ‘POST’:
# 处理 POST 请求，例如获取表单数据
username = request.form.get(‘username’)
password = request.form.get(‘password’)
# 这里可以添加认证逻辑
return f’登录成功，用户名: {username}’ # 简单示例
else:
# 处理 GET 请求，通常是显示一个登录表单
return ”’

用户名:
密码:

”’

… other code …

if name == ‘main‘:
app.run(debug=True)
“`

访问 http://127.0.0.1:5000/login 会显示一个简单的表单（GET 请求）。填写表单并提交会触发 POST 请求，服务器会打印出提交的用户名（简化版）。

访问请求数据 (request 对象)

flask 模块中的 request 对象是一个全局对象，它包含了当前请求的所有信息，比如请求方法、URL、表单数据、查询参数、请求头等等。你需要在视图函数中导入它：from flask import request。

  • 获取查询参数 (URL 中 ?key=value 部分): request.args.get('key')
  • 获取表单数据 (POST 请求体中的数据): request.form.get('key')
  • 获取请求方法: request.method
  • 获取文件上传: request.files
  • 获取请求头: request.headers

使用 .get('key') 方法访问数据是安全的，即使键不存在也不会抛出错误，而是返回 None。你也可以直接使用字典访问方式 request.form['key']，但这会在键不存在时抛出 KeyError。

8. 使用模板 (Templates)

到目前为止，我们的视图函数都直接返回简单的字符串。但在实际的 Web 应用中，我们通常需要返回复杂的 HTML 页面。直接在 Python 代码中拼接大量 HTML 字符串是非常繁琐且难以维护的。这时就需要使用模板引擎。

Flask 默认集成了 Jinja2 模板引擎。模板引擎允许我们将 HTML 结构与 Python 代码逻辑分离。我们可以在模板文件中编写 HTML，并在其中嵌入特殊的标记来显示来自视图函数的数据。

为什么需要模板？

  • 分离关注点: HTML（表现）与 Python 代码（逻辑）分离，提高代码的可读性和可维护性。
  • 复用: 可以定义布局（layout）模板，让其他页面继承，减少重复代码。
  • 动态内容: 可以在模板中方便地插入变量、执行简单的逻辑判断和循环。

创建 templates 文件夹

Flask 默认会在应用根目录下查找一个名为 templates 的文件夹来存放模板文件。所以，在你的项目根目录（app.py 所在的目录）创建一个新的文件夹 templates。

编写第一个模板文件

在 templates 文件夹中创建一个名为 index.html 的文件，输入以下内容：

“`html





我的第一个 Flask 应用

欢迎来到我的 Flask 网站!

这是一个使用 Jinja2 模板渲染的页面。


“`

在视图函数中渲染模板 (render_template)

现在修改首页的视图函数，让它渲染 index.html 模板：

“`python

app.py (继续修改)

from flask import Flask, render_template # 需要导入 render_template

app = Flask(name)

@app.route(‘/’)
def index():
# render_template 函数会在 templates 文件夹中查找指定的模板文件
return render_template(‘index.html’)

… other routes …

if name == ‘main‘:
app.run(debug=True)
“`

保存并运行应用（如果 debug=True 会自动重启）。访问 http://127.0.0.1:5000/，你将看到 index.html 的内容被正确渲染并显示在浏览器中。

向模板传递数据

视图函数可以将数据传递给模板，以便在模板中动态显示内容。你只需在 render_template 函数中以关键字参数的形式传递变量即可：

修改 app.py：

“`python

app.py (继续修改)

from flask import Flask, render_template

app = Flask(name)

@app.route(‘/’)
def index():
# 传递一个变量 ‘title’ 和一个变量 ‘content’ 到模板
return render_template(‘index.html’, title=’首页’, content=’这是首页的内容。’)

@app.route(‘/user/‘)
def user_page(name):
return render_template(‘user.html’, username=name, items=[‘苹果’, ‘香蕉’, ‘橙子’])

… other routes …

if name == ‘main‘:
app.run(debug=True)

“`

在 templates 文件夹中创建 user.html：

“`html





用户页面

欢迎, {{ username }}!

{# 使用 {{}} 显示变量 #}

你的物品:

    {# 使用 {% %} 执行控制结构，这里是一个 for 循环 #}
    {% for item in items %}

  • {{ item }}

    • {% endfor %}

{# 这是 Jinja2 注释，不会显示在最终的 HTML 中 #}

“`

现在访问 http://127.0.0.1:5000/user/bob，你将看到 user.html 被渲染，并且 username 和 items 的值都正确地显示了出来。

Jinja2 语法基础

Jinja2 模板引擎使用特定的语法来嵌入逻辑和变量：

  • {{ variable }}: 用于输出变量的值。Jinja2 会自动对输出进行 HTML 转义，防止跨站脚本攻击 (XSS)。
  • {% control_structure %}: 用于执行控制结构，如 if/else 语句、for 循环、宏定义等。
  • {# comment #}: 用于添加模板注释，这些注释不会包含在最终生成的 HTML 中。

9. 处理静态文件 (Static Files)

静态文件是指那些不需要服务器端处理、可以直接提供给浏览器的文件，比如 CSS 样式表、JavaScript 脚本、图片等。

Flask 默认在应用根目录下查找一个名为 static 的文件夹来存放静态文件。

创建 static 文件夹

在你的项目根目录（app.py 所在的目录）创建一个新的文件夹 static。

在模板中链接静态文件 (url_for)

为了在模板中正确地引用静态文件，你应该使用 url_for() 函数来生成 URL。url_for() 函数的第一个参数是端点名称，对于静态文件，这个端点是 'static'。第二个参数 filename 指定了静态文件在 static 文件夹中的相对路径。

修改 templates/index.html 或其他模板文件，添加一个 CSS 文件：

“`html





{{ title }}
{# 使用 url_for(‘static’, filename=’style.css’) 链接静态文件 #}

欢迎来到我的 Flask 网站!

{{ content }}

{# 添加一个图片示例 #}
Flask Logo


“`

在 static 文件夹中创建一个 style.css 文件（并在 static 中创建一个 images 文件夹，放入一个图片，例如 flask_logo.png）：

“`css
/ static/style.css /
body {
font-family: sans-serif;
margin: 20px;
background-color: #f0f0f0;
}

h1 {
color: #333;
}
“`

现在访问 http://127.0.0.1:5000/，你会发现页面应用了 style.css 中定义的样式，并且图片也正确显示了。

为什么使用 url_for？

使用 url_for() 生成 URL 的好处是：

  1. 避免硬编码: 如果将来你改变了路由规则（例如，把 /static 改成 /assets），你只需要在代码中修改一处配置（虽然静态文件的默认端点通常不会改），而不需要手动修改模板文件中所有静态文件的链接。
  2. 自动处理前缀: 如果你的应用被部署在 URL 的子路径下（例如 example.com/myapp/），url_for 会自动为你处理好前缀，确保链接正确。

url_for() 不仅可以用于静态文件，也可以用于生成应用内部其他视图函数的 URL，只需将第一个参数替换为视图函数的名称（即函数名）。例如，url_for('index') 会生成 /，url_for('show_user_profile', username='alice') 会生成 /user/alice。这同样是避免硬编码、提高灵活性的重要方法。

10. 处理表单 (Form Handling)

Web 应用经常需要与用户交互，最常见的方式是通过 HTML 表单。用户在表单中输入数据并提交，数据会被发送到服务器，由对应的视图函数处理。

我们将创建一个简单的表单，让用户输入名字，然后页面显示问候语。

首先，创建一个名为 form.html 的模板文件：

“`html





简单表单

请输入你的名字

{# 表单的 action 属性指向处理表单提交的 URL，method 指定 HTTP 方法 #}


{# name 属性很重要，用于在服务器端获取数据 #}


“`

然后，在 app.py 中添加两个路由：一个用于显示表单，一个用于处理表单提交。

“`python

app.py (继续修改)

from flask import Flask, render_template, request, redirect, url_for # 需要导入 request, redirect, url_for

app = Flask(name)

… previous routes …

@app.route(‘/simple_form’)
def simple_form():
# 显示表单的视图函数
return render_template(‘form.html’)

@app.route(‘/handle_form’, methods=[‘POST’])
def handle_form():
# 处理表单提交的视图函数
# 只接受 POST 请求
if request.method == ‘POST’:
# 从 request.form 中获取表单字段的值
# input 标签的 name=”username” 对应这里的 ‘username’
username = request.form.get(‘username’) # 使用 get() 方法更安全
if username:
# 如果获取到了用户名，重定向到显示问候语的页面
return redirect(url_for(‘greet_user’, name=username))
else:
# 如果用户名为空，可以重定向回表单页或显示错误消息
return ‘名字不能为空！
返回表单‘
# 如果不是 POST 请求，理论上不会进入这里，但为了完整性可以加个返回
return redirect(url_for(‘simple_form’)) # 或者 abort(405) Method Not Allowed

@app.route(‘/greet/‘)
def greet_user(name):
# 显示问候语的视图函数
return f’你好, {name}!’

… other code …

if name == ‘main‘:
app.run(debug=True)
“`

现在访问 http://127.0.0.1:5000/simple_form，填写名字并提交。如果一切正确，页面将重定向到 /greet/你的名字 并显示问候语。

注意：

  • 表单的 method="post" 属性很重要，它决定了数据如何发送。
  • 表单输入字段的 name="..." 属性是服务器端获取数据时使用的键。
  • 在处理 POST 请求时，使用 request.form.get('fieldname') 来获取提交的数据。
  • 使用 redirect(url_for(...)) 在处理完 POST 请求后进行重定向是一个好的实践，可以避免用户刷新页面时重复提交表单。

11. 重定向和错误处理

重定向 (redirect 和 url_for)

重定向是 Web 应用中非常常见的操作，它指示浏览器跳转到另一个 URL。例如，用户成功登录后跳转到首页，或者表单提交成功后跳转到结果页。

在 Flask 中，你可以使用 redirect() 函数来创建重定向响应。结合 url_for() 可以生成目标 URL：

“`python

app.py (继续修改)

from flask import Flask, redirect, url_for # 确保导入

app = Flask(name)

… other routes …

@app.route(‘/old_path’)
def old_path():
# 访问 /old_path 会被重定向到首页
return redirect(url_for(‘index’)) # ‘index’ 是上面定义的 index() 视图函数的名称

… other code …

if name == ‘main‘:
app.run(debug=True)
“`

访问 http://127.0.0.1:5000/old_path 将自动跳转到 http://127.0.0.1:5000/。

错误处理 (abort)

当发生错误时，Web 应用通常会返回一个特定的 HTTP 状态码，比如 404 (Not Found), 500 (Internal Server Error) 等。Flask 提供 abort() 函数来立即中断请求并返回一个带有指定状态码的响应。

“`python

app.py (继续修改)

from flask import Flask, abort # 确保导入

app = Flask(name)

… other routes …

@app.route(‘/need_auth’)
def need_auth():
# 模拟需要认证，但当前用户未认证的情况
is_authenticated = False # 假设用户未登录
if not is_authenticated:
abort(401) # 返回 401 Unauthorized 错误
return “你已认证！”

@app.route(‘/item/‘)
def get_item(item_id):
# 模拟从数据库查找商品
item = None # 假设没找到 ID 为 item_id 的商品
if item is None:
abort(404) # 返回 404 Not Found 错误
return f”商品详情: {item[‘name’]}”

… other code …

if name == ‘main‘:
app.run(debug=True)
“`

访问 http://127.0.0.1:5000/need_auth 会看到一个 401 错误页面。访问一个不存在的商品 ID，如 http://127.0.0.1:5000/item/999，会看到一个 404 错误页面。

自定义错误页面 (简述)

Flask 默认提供简单的错误页面，但你可以为不同的 HTTP 错误码注册自定义的错误处理函数：

“`python
@app.errorhandler(404)
def page_not_found(error):
# 返回自定义的 404 页面，通常会渲染一个模板
return render_template(‘404.html’), 404 # 注意返回状态码

@app.errorhandler(401)
def unauthorized_error(error):
return render_template(‘401.html’), 401
“`

你需要在 templates 文件夹中创建对应的 404.html 和 401.html 文件来定制错误页面的内容。

12. 项目结构 (Simple Project Structure)

对于本指南中的简单应用，将所有代码放在一个 app.py 文件中是可以接受的。但随着项目的增长，将代码分解到不同的文件中会更有利于组织和管理。一个基本的 Flask 项目结构通常看起来像这样：

my_flask_app/
│
├── myflaskenv/ # 虚拟环境文件夹 (gitignore 忽略)
├── app.py # Flask 应用实例的创建和配置 (或者创建 __init__.py 在包中)
├── routes.py # 存放所有的视图函数 (路由)
├── models.py # 存放数据库模型 (如果使用数据库)
├── forms.py # 存放表单类 (如果使用 Flask-WTF 等扩展)
├── templates/ # 存放 HTML 模板文件
│ ├── base.html # 基础布局模板
│ ├── index.html
│ ├── user.html
│ ├── form.html
│ └── 404.html # 错误页面模板
└── static/ # 存放静态文件 (CSS, JS, images 等)
├── css/
│ └── style.css
├── js/
└── images/
└── flask_logo.png
├── requirements.txt # 存放项目依赖库列表 (pip freeze > requirements.txt)

在这种结构下，你可以在 app.py 或一个包的 __init__.py 文件中创建 app = Flask(__name__) 实例，然后在 routes.py 中导入 app 对象并定义路由和视图函数。

“`python

routes.py (示例)

from flask import render_template # 导入需要的函数

from app import app # 从 app.py 或包的 init.py 导入 app 实例

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

@app.route(‘/about’)
def about():
return render_template(‘about.html’)

… 其他路由 …

“`

然后，在 app.py 中（如果它是启动文件），你需要导入 routes 模块，这样其中定义的路由才会被注册到 app 实例上。

“`python

app.py (启动文件示例)

from flask import Flask

app = Flask(name)

导入 routes 模块，这会执行 routes.py 中的代码并注册路由

import routes

if name == ‘main‘:
app.run(debug=True)
“`

随着项目的进一步发展，你可能会将应用拆分成蓝图 (Blueprints)，以更好地组织不同功能的模块。

13. 再进一步

掌握了以上基础知识，你已经可以使用 Flask 构建简单的 Web 应用了。但要构建更强大、功能更丰富的应用，你还需要学习更多内容：

  • Flask 扩展 (Extensions): Flask 的强大之处在于其丰富的扩展生态系统。常用的扩展包括：
    • Flask-SQLAlchemy: 方便地集成 SQLAlchemy ORM 来处理数据库操作。
    • Flask-WTF: 简化表单创建、验证和处理。
    • Flask-Login: 处理用户会话管理、登录和登出。
    • Flask-Migrate: 集成 Alembic 进行数据库迁移。
    • Flask-RESTful / Flask-RESTX: 简化构建 RESTful API。
  • 数据库集成: 学习如何使用 ORM (如 SQLAlchemy) 或直接使用数据库驱动与数据库（如 PostgreSQL, MySQL, SQLite 等）进行交互。
  • 用户认证和授权: 实现用户注册、登录、会话管理、权限控制等。
  • 蓝图 (Blueprints): 学习如何使用蓝图来组织大型应用，将应用划分为可重用的模块。
  • 上下文 (Contexts): 理解 Flask 的请求上下文 (Request Context) 和应用上下文 (Application Context)。
  • 信号 (Signals): 了解 Flask 的信号机制。
  • 测试: 学习如何为你的 Flask 应用编写单元测试和集成测试。
  • 部署: 将你的应用部署到生产环境，学习使用 Gunicorn/uWSGI 等 WSGI 服务器，以及 Nginx/Apache 等反向代理。

14. 总结

恭喜你走完了 Flask 快速入门的旅程！本指南涵盖了 Flask 的核心概念，包括：

  • 理解 Flask 的微框架哲学
  • 环境准备和安装
  • 创建和运行最简单的 Flask 应用
  • 理解应用的各个组成部分
  • 定义和使用路由，包括带变量的路由
  • 处理不同的 HTTP 方法并访问请求数据
  • 使用 Jinja2 模板渲染动态 HTML
  • 管理和链接静态文件
  • 处理简单的 HTML 表单
  • 实现重定向和基本错误处理
  • 了解基本的项目结构

Flask 的简洁和灵活性使其成为一个优秀的 Web 开发框架。通过不断练习和探索其丰富的扩展，你将能够构建出各种类型的 Web 应用。

继续学习和实践是掌握任何框架的关键。现在，你可以尝试构建一个更复杂的应用，比如一个简单的博客或待办事项列表应用，并将本指南中学到的知识应用到实践中去。

祝你使用 Flask 开发愉快！

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部