Flask 入门教程 – wiki基地

作者： /

Flask 入门教程：轻松构建你的第一个Web应用

欢迎来到精彩的Web开发世界！如果你正在寻找一个既强大又灵活、同时对初学者友好的Python Web框架，那么 Flask 绝对是一个绝佳的选择。不同于一些“全栈”框架（如 Django，它提供了数据库ORM、管理后台等许多内置功能），Flask 是一个“微框架”（microframework）。这意味着它提供的是构建Web应用的核心功能——请求处理和路由，而将其他决策（如数据库选择、模板引擎选择——尽管它默认推荐 Jinja2）留给开发者自己。这种设计哲学使得 Flask 极其灵活，非常适合小型项目、API开发，或者当你想要完全掌控项目结构和技术栈时。

本篇教程将带你从零开始，一步步走进 Flask 的世界。我们将涵盖 Flask 的核心概念、环境搭建、基本应用构建、模板渲染、处理静态文件、处理表单数据等基础知识。通过学习，你将能够独立构建一个简单的动态Web应用。

预计学习时长： 2-4小时，取决于你的Python基础和练习时间。

目录

  1. 什么是 Flask？为什么选择它？
  2. 准备工作：安装 Python 和虚拟环境
  3. 搭建你的第一个 Flask 项目
    • 创建项目目录和虚拟环境
    • 安装 Flask
  4. 你的第一个 Flask 应用：”Hello, World!”
    • 编写代码
    • 运行应用
    • 代码解释
  5. 深入理解路由（Routes）
    • 基本路由
    • 带变量的路由
    • HTTP 方法：GET 和 POST
  6. 使用模板（Templates）渲染HTML
    • 为什么需要模板？
    • Jinja2 模板引擎
    • 创建模板文件
    • 在 Flask 中使用模板
    • 向模板传递数据
  7. 处理静态文件（Static Files）
    • 为什么需要静态文件？
    • 静态文件目录结构
    • 在模板中链接静态文件
  8. 处理表单数据（Forms）
    • 创建HTML表单
    • 在 Flask 中接收表单数据
    • GET vs POST 处理
  9. 构建URL：url_for() 函数
    • 为什么避免硬编码URL？
    • url_for() 的用法
  10. 调试你的 Flask 应用
  11. 整合应用：构建一个简单的示例
  12. 下一步：继续学习

1. 什么是 Flask？为什么选择它？

Flask 是一个使用 Python 语言编写的轻量级 Web 服务器网关接口（WSGI）Web 应用框架。它由 Armin Ronacher 开发，基于 Werkzeug WSGI 工具箱和 Jinja2 模板引擎。

为什么选择 Flask？

  • 微框架特性： 它只包含Web开发的核心功能，不强制你使用特定的工具或库来处理数据库、表单验证等。这给了开发者极大的自由度去选择最适合项目的组件。
  • 易于上手： 代码简洁，学习曲线平缓，非常适合新手入门Web开发。你可以很快地搭建起一个可工作的Web应用。
  • 灵活性： 它的组件是可插拔的，你可以轻松集成各种第三方库来扩展功能，例如 SQLAlchemy 用于数据库、WTForms 用于表单、Flask-Login 用于用户认证等等。
  • 完善的文档： Flask 拥有高质量且详细的官方文档。
  • 活跃的社区： 庞大的用户群体意味着你在遇到问题时很容易找到帮助。

总之，如果你想快速构建一个原型、开发一个API服务，或者偏爱自由选择项目组件，Flask 是一个非常棒的选择。

2. 准备工作：安装 Python 和虚拟环境

在开始之前，你需要确保你的计算机上已经安装了 Python。推荐使用 Python 3.6 或更高版本。你可以在 Python 官网 (python.org) 下载并安装。

强烈建议使用虚拟环境！

在Python开发中，虚拟环境（Virtual Environment）是一个独立的环境，它允许你安装特定项目所需的库，而不会影响系统中其他Python项目或系统自带的Python环境。这可以有效避免不同项目之间库版本冲突的问题。

Python 3.3+ 内置了 venv 模块，使用起来非常方便。

创建虚拟环境：

打开你的终端或命令行工具（Windows 用户推荐使用 Git Bash 或 PowerShell），导航到你想要创建项目的目录。然后执行以下命令：

“`bash

对于 macOS/Linux 用户

python3 -m venv venv

对于 Windows 用户 (可能需要根据安装路径调整 python 命令)

python -m venv venv

“`

这会在当前目录下创建一个名为 venv 的文件夹，里面包含了独立的Python解释器和pip工具。

激活虚拟环境：

在安装任何库之前，你需要激活虚拟环境。

“`bash

对于 macOS/Linux 用户

source venv/bin/activate

对于 Windows 用户 (在 PowerShell 中)

.\venv\Scripts\Activate.ps1

对于 Windows 用户 (在 Command Prompt 中)

venv\Scripts\activate.bat

“`

激活后，你会看到终端提示符前面出现了虚拟环境的名称（通常是 (venv)），这表示你当前正处于虚拟环境中。

退出虚拟环境：

当你完成工作时，可以输入 deactivate 命令退出虚拟环境。

现在，你已经准备好开始搭建 Flask 项目了。

3. 搭建你的第一个 Flask 项目

我们来创建一个简单的项目目录结构。

  1. 创建项目目录：
    在一个合适的位置创建一个文件夹，例如 my_flask_app。

    bash
    mkdir my_flask_app
    cd my_flask_app

  2. 创建并激活虚拟环境：
    在这个新的目录中创建并激活虚拟环境（如果你之前没有创建的话）。

    bash
    python3 -m venv venv
    source venv/bin/activate
    （Windows 用户请使用相应的命令激活）

  3. 安装 Flask：
    在激活的虚拟环境中，使用 pip 安装 Flask。

    bash
    pip install Flask

    pip 会下载并安装 Flask 及其依赖项（Werkzeug, Jinja2, itsdangerous, MarkupSafe, click）。安装完成后，你可以使用 pip list 查看当前虚拟环境中安装的库。

4. 你的第一个 Flask 应用：”Hello, World!”

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

  1. 创建应用文件：
    在项目目录 my_flask_app 下创建一个 Python 文件，命名为 app.py。

  2. 编写代码：
    打开 app.py 文件，输入以下代码：

    “`python
    from flask import Flask

    创建一个 Flask 应用实例

    name 是一个特殊的 Python 变量。

    当一个脚本作为主程序运行时，name 的值是 ‘main‘。

    Flask 使用这个参数来确定应用根目录，以便找到资源文件（如模板和静态文件）。

    app = Flask(name)

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

    这个装饰器告诉 Flask 当用户访问网站的根 URL (‘/’) 时，执行下面的函数。

    @app.route(‘/’)
    def hello_world():
    # 函数返回的内容将作为 HTTP 响应发送给浏览器
    return ‘Hello, World! This is my first Flask app!’

    这个条件判断确保只有在直接运行 app.py 文件时，才会启动开发服务器

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

    if name == ‘main‘:
    # app.run() 启动 Flask 内置的开发服务器
    # debug=True 开启调试模式：
    # 1. 当代码修改时，服务器会自动重新加载。
    # 2. 当发生错误时，会在浏览器中显示详细的调试信息。
    # 注意：在生产环境中绝不能开启调试模式！
    app.run(debug=True)
    “`

  3. 运行应用：
    保存 app.py 文件。确保你仍在项目目录 my_flask_app 下，并且虚拟环境已激活。然后在终端中运行：

    bash
    python app.py

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

    * Serving Flask app 'app' (lazy loading)
    * Environment: development
    * Debug mode: on
    * Running on http://127.0.0.1:5000/ (Press CTRL+C to quit)

    这表示你的 Flask 应用已经在本地的 5000 端口启动了。

  4. 在浏览器中访问：
    打开你的Web浏览器，访问地址 http://127.0.0.1:5000/。你应该能看到页面显示 “Hello, World! This is my first Flask app!”。

  5. 停止应用：
    在终端中按下 Ctrl+C 来停止服务器。

代码解释：

  • from flask import Flask: 导入 Flask 类。
  • app = Flask(__name__): 创建 Flask 应用的实例。__name__ 参数是必须的，用于告诉 Flask 应用在哪里寻找资源。
  • @app.route('/'): 这是一个装饰器（Decorator）。它将紧随其后的函数与特定的 URL 路径（/，即根路径）关联起来。当浏览器访问 / 时，就会调用这个函数。
  • def hello_world():: 定义一个函数来处理 / 路径的请求。函数名可以是任意合法的Python标识符。
  • return '...': 函数返回一个字符串。Flask 将这个字符串作为 HTTP 响应的主体发送回浏览器。默认情况下，返回的响应类型是 text/html。
  • if __name__ == '__main__':: 这是一个标准的 Python 结构，确保 app.run() 只在直接执行 app.py 文件时运行。
  • app.run(debug=True): 启动 Flask 的开发服务器。debug=True 开启调试模式，方便开发。

5. 深入理解路由（Routes）

路由是将 URL 路径映射到处理该请求的函数的过程。在 Flask 中，通过 @app.route() 装饰器来定义路由。

基本路由

我们已经在 “Hello, World!” 例子中看到了基本路由 @app.route('/')。你可以创建更多的路由：

“`python

… (前面的导入和 app = Flask(name) 保持不变)

@app.route(‘/’)
def index():
return ‘This is the homepage.’

@app.route(‘/about’)
def about():
return ‘This is the about page.’

@app.route(‘/contact’)
def contact():
return ‘Contact us at [email protected]’

… (if name == ‘main‘: app.run(debug=True) 保持不变)

“`

现在运行 python app.py，访问 http://127.0.0.1:5000/ 会看到首页内容，访问 http://127.0.0.1:5000/about 会看到关于页面内容，访问 http://127.0.0.1:5000/contact 会看到联系页面内容。

带变量的路由

很多时候，URL 中需要包含可变的部分，例如用户ID、文章ID等。Flask 允许你在路由中定义变量：

“`python
@app.route(‘/user/‘)
def show_user_profile(username):
# show the user profile for that user
return f’User: {username}’

@app.route(‘/post/‘)
def show_post(post_id):
# show the post with the given id, the id is an integer
return f’Post ID: {post_id}’
“`

  • <username>: 这是一个 URL 变量。Flask 会捕获 URL 中 <username> 位置的值，并将其作为关键字参数传递给 show_user_profile 函数。默认情况下，URL 变量被视为字符串。
  • <int:post_id>: 你可以在变量名前指定一个转换器（converter），例如 int。这将确保 URL 变量必须是整数，并且在传递给函数时已经被转换为整数类型。Flask 内置了常见的转换器，如 string, int, float, path (包含斜杠的字符串), uuid。

现在，访问 /user/alice 会显示 “User: alice”，访问 /post/123 会显示 “Post ID: 123″。如果你访问 /post/abc，Flask 会返回一个 404 Not Found 错误，因为 abc 不是一个整数。

HTTP 方法：GET 和 POST

Web 应用通常需要处理不同的 HTTP 请求方法，最常见的是 GET（获取资源）和 POST（提交数据）。默认情况下，Flask 路由只响应 GET 请求。你可以使用 methods 参数指定允许的方法：

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

@app.route(‘/login’, methods=[‘GET’, ‘POST’])
def login():
if request.method == ‘POST’:
# 处理 POST 请求，例如获取表单数据
# request.form 是一个类字典对象，包含表单提交的数据
username = request.form[‘username’]
password = request.form[‘password’]
# 这里可以添加验证逻辑
return f’Processing login for {username}’
else:
# 处理 GET 请求，通常是显示一个表单
return ‘Show login form’

… (其他路由和 main 部分)

“`

在上面的例子中，访问 /login 使用 GET 请求会显示 “Show login form”。如果通过一个表单以 POST 方法提交数据到 /login，就会执行 if request.method == 'POST': 下的代码块。我们将在后续的表单部分详细讨论如何处理 POST 数据。

6. 使用模板（Templates）渲染HTML

前面的例子中，我们直接在 Flask 函数中返回 HTML 字符串。对于简单的页面尚可，但对于复杂的页面，直接拼接 HTML 字符串既不方便维护，也容易出错。模板引擎就是用来解决这个问题的。

Flask 默认推荐和集成了 Jinja2 模板引擎。Jinja2 允许你编写包含特殊标记的文本文件（通常是 HTML），在运行时，这些标记会被替换为实际的数据，生成最终的 HTML 页面。

为什么需要模板？

  • 代码与内容的职责分离： Python 代码负责处理业务逻辑和数据，HTML 模板负责页面的结构和展示。
  • 可重用性： 可以创建布局模板，让其他页面继承，避免重复编写 HTML 头部、尾部等公共部分。
  • 动态内容： 轻松地将 Python 代码中的数据（变量、列表、字典等）嵌入到 HTML 中。

Jinja2 模板引擎

Jinja2 使用以下几种标记：

  • {{ variable }}: 用于输出变量或表达式的值。
  • {% control_structure %}: 用于控制流，如 if 语句、for 循环等。
  • {# comment #}: 用于添加注释，不会输出到最终的 HTML 中。

创建模板文件

Flask 会默认在应用根目录下的一个名为 templates 的子目录中查找模板文件。所以，首先在 my_flask_app 目录下创建一个 templates 文件夹：

bash
mkdir templates

然后，在 templates 文件夹中创建一个 HTML 文件，例如 index.html：

“`html






{{ title }}

Welcome to {{ page_name }}

{{ content }}

Items:

    {% for item in items %}

  • {{ item }}

    • {% endfor %}


“`

在这个模板中：
* {{ title }}, {{ page_name }}, {{ content }} 是将要从 Flask 应用传递过来的变量。
* {% for item in items %} 和 {% endfor %} 是 Jinja2 的循环结构，用于遍历 items 列表。
* <li>{{ item }}</li> 在每次循环中输出列表中的一个元素。

在 Flask 中使用模板

修改 app.py 文件，使用 render_template 函数来渲染 index.html 模板：

“`python
from flask import Flask, render_template # 需要导入 render_template 函数

app = Flask(name)

@app.route(‘/’)
def index():
# render_template() 函数会在 templates 文件夹中查找指定的模板文件
# 并将后续的关键字参数传递给模板作为变量
return render_template(‘index.html’,
title=’Homepage’,
page_name=’My Flask App’,
content=’This is some dynamic content.’,
items=[‘Item 1’, ‘Item 2’, ‘Item 3’])

… (其他路由和 main 部分)

“`

注意： 你需要确保 templates 文件夹与 app.py 文件位于同一级目录下。

现在运行 python app.py，访问 http://127.0.0.1:5000/。你应该看到一个使用 index.html 模板渲染的页面，其中的变量和列表内容都已经被替换成了 Python 代码中传递的值。

7. 处理静态文件（Static Files）

Web 应用通常需要使用 CSS 文件来控制样式，JavaScript 文件来实现客户端交互，以及图片等其他静态资源。Flask 提供了一种简单的方式来处理这些静态文件。

Flask 会默认在应用根目录下的一个名为 static 的子目录中查找静态文件。

  1. 创建静态文件目录：
    在 my_flask_app 目录下创建一个 static 文件夹：

    bash
    mkdir static

  2. 创建静态文件：
    在 static 文件夹中创建一个 CSS 文件，例如 style.css：

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

    h1 {
    color: #333;
    }

    ul {
    list-style: disc;
    margin-left: 20px;
    }
    “`

  3. 在模板中链接静态文件：
    修改 templates/index.html 文件，在 <head> 部分添加一个链接来引入 style.css：

    “`html
    <!DOCTYPE html>




    {{ title }}

    Welcome to {{ page_name }}

    {{ content }}

    <h2>Items:</h2>
<ul>
{% for item in items %}
    <li>{{ item }}</li>
{% endfor %}
</ul>



    “`

    这里我们使用了 {{ url_for('static', filename='style.css') }}。url_for() 函数用于根据函数名（这里是 Flask 内置的用于处理静态文件的视图函数 static）和参数（filename='style.css' 指定要查找的文件名）来动态生成 URL。这种方式比硬编码 /static/style.css 更好，因为如果将来静态文件的位置或处理方式发生变化，你不需要修改模板文件，只需要修改 Flask 应用的配置即可。

运行应用并访问首页，你应该能看到页面应用了 style.css 中定义的样式。

8. 处理表单数据（Forms）

Web 应用的核心功能之一就是接收用户的输入，通常通过 HTML 表单来实现。Flask 可以轻松地接收和处理表单提交的数据。

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

  1. 创建表单模板：
    在 templates 目录下创建一个 form.html 文件：

    html
    <!DOCTYPE html>
    <html lang="en">
    <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Simple Form</title>
    </head>
    <body>
    <h1>Enter Your Name</h1>
    <!--
    method="POST": 指定表单提交时使用 POST 方法
    action="{{ url_for('process_form') }}": 指定表单提交到哪个 URL
    url_for('process_form') 会查找名为 process_form 的路由函数，并生成对应的 URL
    -->
    <form method="POST" action="{{ url_for('process_form') }}">
    <label for="name">Name:</label>
    <!-- input 标签的 name 属性非常重要，Flask 会使用它来获取输入的值 -->
    <input type="text" id="name" name="user_name" required>
    <button type="submit">Submit</button>
    </form>
    </body>
    </html>

  2. 创建处理表单的 Flask 路由：
    修改 app.py，添加两个路由：一个用于显示表单（GET请求），另一个用于处理表单提交（POST请求）。

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

    app = Flask(name)

    Route for displaying the form (GET) and processing it (POST)

    @app.route(‘/form’, methods=[‘GET’, ‘POST’])
    def handle_form():
    if request.method == ‘POST’:
    # 获取表单中 name=”user_name” 的输入框的值
    user_name = request.form.get(‘user_name’) # 使用 .get() 方法更安全，如果键不存在不会报错
    if user_name:
    # 如果获取到名字，重定向到 greeting 页面
    # 将名字作为 URL 参数传递
    return redirect(url_for(‘show_greeting’, name=user_name))
    else:
    # 如果名字为空，可以返回错误信息或重新显示表单
    return “Name is required!”, 400 # 返回错误信息和状态码 400 Bad Request

    else: # request.method == 'GET'
    # 显示表单页面
    return render_template('form.html')

    Route for displaying the greeting

    @app.route(‘/greet/‘)
    def show_greeting(name):
    # 显示问候语页面
    return f’Hello, {name}!’

    … (其他路由和 main 部分)

    “`

在上面的代码中：
* @app.route('/form', methods=['GET', 'POST']): 定义 /form 路由可以处理 GET 和 POST 请求。
* if request.method == 'POST':: 检查请求方法是否为 POST。
* user_name = request.form.get('user_name'): 使用 request.form 获取 POST 提交的表单数据。request.form 是一个字典，键是输入框的 name 属性值（这里是 user_name），值是用户输入的内容。使用 .get() 方法可以避免在键不存在时出错。
* redirect(url_for('show_greeting', name=user_name)): 如果成功获取名字，使用 redirect 函数将用户重定向到 show_greeting 路由。url_for('show_greeting', name=user_name) 会生成像 /greet/Alice 这样的 URL，其中 name=user_name 作为参数传递给了 show_greeting 函数对应的路由变量。这种 Post/Redirect/Get 模式是一种常见的Web开发模式，可以避免用户刷新页面时重复提交表单。
* else:: 如果请求方法是 GET，渲染并显示 form.html 模板。
* @app.route('/greet/<name>'): 定义一个带变量的路由，接收名字作为参数。

运行应用，访问 http://127.0.0.1:5000/form。填写名字并提交，你会看到页面重定向到 /greet/你的名字 并显示问候语。

注意： 对于更复杂的表单处理和验证，推荐使用 Flask-WTF 这样的扩展库。

9. 构建URL：url_for() 函数

我们已经在模板中使用了 url_for() 函数来链接静态文件和处理表单的 action 属性。url_for() 函数是 Flask 中一个非常重要的工具。

为什么避免硬编码URL？

硬编码 URL (例如直接在模板中写 /about 或 /static/style.css) 有几个缺点：

  • 维护困难： 如果你的 URL 结构发生变化（例如 /about 改为 /info），你需要修改所有引用这个 URL 的地方（代码和模板）。
  • 可读性差： url_for('show_user_profile', username='Alice') 比硬编码 /user/Alice 更清晰地表达了 URL 的含义和来源。
  • 处理变量和参数： 对于带变量的路由，硬编码更是不切实际。

url_for() 的用法

url_for() 函数接收视图函数的名称作为第一个参数，以及任何数量的关键字参数，每个关键字参数对应 URL 规则中的变量部分。

  • url_for('index'): 生成对应 index 函数（即 @app.route('/')）的 URL，结果是 /。
  • url_for('show_user_profile', username='Peter'): 生成对应 show_user_profile 函数（即 @app.route('/user/<username>')）的 URL，结果是 /user/Peter。
  • url_for('show_post', post_id=42): 生成对应 show_post 函数（即 @app.route('/post/<int:post_id>')）的 URL，结果是 /post/42。
  • url_for('static', filename='js/main.js'): 生成对应处理静态文件的内置视图函数 static 的 URL，结果通常是 /static/js/main.js。
  • url_for('handle_form'): 生成对应 handle_form 函数（即 @app.route('/form')）的 URL，结果是 /form。
  • url_for('show_greeting', name='Alice'): 生成对应 show_greeting 函数（即 @app.route('/greet/<name>')）的 URL，结果是 /greet/Alice。

总结： 始终使用 url_for() 来生成 URL，无论是代码中还是模板中。这会让你的应用更加健壮和易于维护。

10. 调试你的 Flask 应用

在开发过程中，错误是难以避免的。Flask 的调试模式 (debug=True 在 app.run()) 为你提供了非常有用的帮助。

当调试模式开启时：

  1. 自动重载： 你修改 Python 代码后，服务器会自动检测到变化并重新加载，无需手动重启。
  2. 交互式调试器： 当应用发生错误时，浏览器中会显示一个详细的错误页面，包含了堆栈跟踪（traceback）。最强大的是，你可以点击堆栈帧（stack frame）旁边的控制台图标，进入一个交互式的 Python shell，在错误发生的上下文中检查变量的值、执行代码等，这极大地提高了调试效率。

注意： 正如之前提到的，在生产环境中绝不能开启调试模式，因为它会暴露应用的内部信息和执行任意代码的能力，存在严重的安全风险。在部署时，应该关闭 debug=True。

11. 整合应用：构建一个简单的示例

现在让我们把学到的知识点整合起来，构建一个稍微复杂一点的示例：一个简单的访客留言板（不涉及数据库，数据不持久化，仅用于演示）。

  1. 创建目录结构：
    my_guestbook_app/
    ├── venv/ (虚拟环境)
    ├── static/
    │ └── style.css
    ├── templates/
    │ ├── index.html
    │ └── greeting.html
    └── app.py

  2. app.py:

    “`python
    from flask import Flask, render_template, request, redirect, url_for

    app = Flask(name)

    模拟存储留言，重启服务器会丢失

    messages = []

    @app.route(‘/’)
    def index():
    # 显示所有留言的页面
    return render_template(‘index.html’, messages=messages)

    @app.route(‘/submit_message’, methods=[‘POST’])
    def submit_message():
    if request.method == ‘POST’:
    user_name = request.form.get(‘name’)
    message_text = request.form.get(‘message’)

        if user_name and message_text:
        messages.append({'name': user_name, 'text': message_text})
        # 提交成功后重定向回首页，显示新的留言
        return redirect(url_for('index'))
    else:
        # 处理输入不完整的情况
        return "Name and Message are required!", 400

    @app.route(‘/add’)
    def add_message_form():
    # 显示添加留言的表单页面
    return render_template(‘greeting.html’) # 复用之前的 greeting.html 作为表单页

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

  3. templates/index.html:
    （用于显示留言列表和提交表单）

    “`html
    <!DOCTYPE html>




    Guestbook

    Guestbook Messages

    {% if messages %}
    <ul>
    {% for msg in messages %}
        <li><strong>{{ msg.name }}:</strong> {{ msg.text }}</li>
    {% endfor %}
    </ul>
{% else %}
    <p>No messages yet.</p>
{% endif %}

<hr>

<h2>Leave a Message</h2>
<!-- 表单提交到 /submit_message 路由 -->
<form method="POST" action="{{ url_for('submit_message') }}">
    <div>
        <label for="name">Name:</label><br>
        <input type="text" id="name" name="name" required>
    </div>
    <div>
        <label for="message">Message:</label><br>
        <textarea id="message" name="message" rows="4" required></textarea>
    </div>
    <button type="submit">Submit Message</button>
</form>



    “`

  4. templates/greeting.html:
    （作为演示，我们直接使用 index.html 包含表单即可，不再需要独立的 greeting.html 文件了。上面代码中 @app.route('/add') 可以删除或修改，这里我们删除它，只通过 / 首页来提交留言。）

  5. static/style.css:
    （可以保持原样或稍作修改）

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

    h1, h2 {
    color: #333;
    border-bottom: 1px solid #ccc;
    padding-bottom: 5px;
    margin-top: 20px;
    }

    ul {
    list-style: none; / 取消默认列表样式 /
    padding: 0;
    }

    li {
    background-color: #fff;
    border: 1px solid #ddd;
    margin-bottom: 10px;
    padding: 10px;
    border-radius: 5px;
    }

    form div {
    margin-bottom: 15px;
    }

    label {
    display: block;
    margin-bottom: 5px;
    font-weight: bold;
    }

    input[type=”text”],
    textarea {
    width: 100%; / 让输入框和文本域占据父容器宽度 /
    padding: 8px;
    border: 1px solid #ccc;
    border-radius: 4px;
    box-sizing: border-box; / 包含 padding 和 border 在元素总宽度内 /
    }

    button {
    background-color: #5cb85c;
    color: white;
    padding: 10px 15px;
    border: none;
    border-radius: 4px;
    cursor: pointer;
    font-size: 16px;
    }

    button:hover {
    background-color: #4cae4c;
    }

    “`

运行 python app.py，访问 http://127.0.0.1:5000/。你现在可以看到一个简单的留言板页面，可以在下方填写名字和留言并提交。提交后页面会刷新，显示你刚刚添加的留言。

这个例子虽然简单，但它结合了路由、模板、静态文件、表单处理、重定向等核心概念，是你进一步学习 Flask 的良好基础。

12. 下一步：继续学习

恭喜你！你已经掌握了 Flask 的基本用法，能够构建简单的动态Web应用了。但这仅仅是开始。Flask 生态系统非常丰富，有许多强大的扩展可以帮助你构建更复杂的应用。接下来，你可以学习：

  • 数据库集成： 如何使用 SQLAlchemy 或其他 ORM 与数据库交互，实现数据的持久化。
  • 用户认证与授权： 如何实现用户注册、登录、会话管理和访问控制（例如使用 Flask-Login）。
  • 表单验证： 使用 Flask-WTF 等库进行更健壮的表单处理和验证。
  • RESTful API： 如何使用 Flask 构建 API 服务（例如使用 Flask-RESTful 或 Flask-RESTx）。
  • 应用结构： 如何组织大型 Flask 项目的代码结构（蓝图 Blueprints）。
  • 测试： 如何为你的 Flask 应用编写测试。
  • 部署： 如何将你的 Flask 应用部署到生产环境（如 Gunicorn/uWSGI + Nginx/Apache，或使用平台服务如 Heroku, Vercel）。
  • 更多 Flask 扩展： 探索 Flask 生态系统中其他有用的扩展，如 Flask-Migrate (数据库迁移)、Flask-Mail (发送邮件) 等等。

官方文档是最好的学习资源，同时也有许多优秀的在线教程和书籍可以参考。

结论

Flask 是一个优雅、灵活且功能强大的 Python Web 框架。本教程带你走过了 Flask 入门的最关键步骤，从环境搭建到构建一个简单的交互式Web页面。希望你现在对 Flask 有了一个清晰的认识，并对用它来创建更多有趣的Web应用充满信心。

记住，学习编程和框架最好的方式就是动手实践。不断尝试修改代码、添加新功能、解决遇到的问题。祝你在 Flask 的学习旅程中一切顺利！

发表评论

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

滚动至顶部