Flask 教程：使用 Python 构建 Web 应用

2025-3-17

Flask 教程：使用 Python 构建 Web 应用

1. 简介：Flask 与 Web 开发

在当今互联网时代，Web 应用无处不在。无论是简单的博客、在线商店，还是复杂的社交平台、数据分析工具，它们都离不开 Web 开发技术。Python 作为一门功能强大且易于学习的编程语言，在 Web 开发领域也占有重要地位。Flask 就是一个基于 Python 的微型 Web 框架，以其简洁、灵活和可扩展性而广受开发者喜爱。

什么是 Flask？

Flask 是一个使用 Python 编写的轻量级 Web 应用框架。它被称为“微型”框架，是因为它保持核心简单而易于扩展。Flask 不强制要求特定的项目结构或依赖项，这使得开发者可以自由选择最适合自己项目的工具和库。然而，“微型”并不意味着功能不足，Flask 提供了构建强大 Web 应用所需的基本组件，并且可以通过丰富的扩展来增强功能。

Flask 的优势：

  • 简单易学： Flask 的核心 API 设计简洁明了，学习曲线平缓，即使是初学者也能快速上手。
  • 灵活可控： Flask 不做过多假设，开发者可以自由选择数据库、模板引擎、表单处理库等组件，构建高度定制化的应用。
  • 扩展性强： Flask 拥有庞大的扩展生态系统，涵盖了各种功能，如用户认证、数据库集成、API 开发、邮件发送等。
  • 强大的社区支持： Flask 拥有活跃的社区，遇到问题时可以方便地找到帮助和资源。
  • 适用于各种规模的项目： 无论是构建小型个人项目，还是大型企业级应用，Flask 都能胜任。

本教程目标：

本教程将带你从零开始，逐步学习 Flask 的核心概念和常用功能，并通过一个实际的项目示例，让你掌握使用 Flask 构建 Web 应用的基本技能。完成本教程后，你将能够：

  • 理解 Flask 的基本工作原理。
  • 创建 Flask 应用并处理 HTTP 请求。
  • 使用模板引擎渲染动态内容。
  • 连接数据库并进行数据操作。
  • 实现用户注册、登录和会话管理。
  • 部署 Flask 应用到服务器。

2. 准备工作：环境搭建

在开始编写 Flask 应用之前，我们需要先搭建好开发环境。

2.1 安装 Python

Flask 是基于 Python 的，所以首先需要安装 Python。建议安装 Python 3.6 或更高版本。你可以从 Python 官网下载并安装适合你操作系统的 Python 版本。

2.2 创建虚拟环境（推荐）

为了避免不同项目之间的依赖冲突，强烈建议使用虚拟环境来隔离每个项目的依赖。你可以使用 Python 自带的 venv 模块或第三方工具如 virtualenv 来创建虚拟环境。

使用 venv 创建虚拟环境：

  1. 打开命令行终端（Windows）或终端（macOS/Linux）。
  2. 导航到你的项目目录。

  3. 运行以下命令创建虚拟环境（假设虚拟环境名称为 venv）：

    bash
    python3 -m venv venv

  4. 激活虚拟环境：

    • Windows:

      bash
      venv\Scripts\activate

    • macOS/Linux:

      bash
      source venv/bin/activate

    激活虚拟环境后，命令行提示符前会显示虚拟环境的名称，表示你已进入虚拟环境。

2.3 安装 Flask

在虚拟环境激活的状态下，使用 pip 命令安装 Flask：

bash
pip install Flask

安装完成后，你可以通过以下命令验证 Flask 是否安装成功：

bash
python -m flask --version

如果显示 Flask 的版本号，则表示安装成功。

3. 第一个 Flask 应用：Hello, World!

现在，让我们来创建第一个 Flask 应用，一个经典的 "Hello, World!" 程序。

  1. 创建项目目录： 在你喜欢的位置创建一个新的文件夹，作为你的项目目录（例如 my_flask_app）。

  2. 创建应用文件： 在项目目录中创建一个名为 app.py 的 Python 文件。

  3. 编写代码： 在 app.py 文件中输入以下代码：

    ```python
    from flask import Flask

    app = Flask(name)

    @app.route("/")
    def hello_world():
    return "Hello, World!"

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

  4. 代码解释：

    • from flask import Flask: 导入 Flask 类。
    • app = Flask(__name__): 创建 Flask 应用实例。__name__ 是一个特殊的 Python 变量，表示当前模块的名称。
    • @app.route("/"): 使用装饰器将 hello_world 函数与 URL 路径 / 绑定。当用户访问网站根目录时，Flask 会调用 hello_world 函数。
    • def hello_world():: 定义一个名为 hello_world 的函数，它返回字符串 "Hello, World!"。
    • if __name__ == "__main__":: 确保只有在直接运行 app.py 文件时才启动 Flask 开发服务器。
    • app.run(debug=True): 启动 Flask 开发服务器，并开启调试模式。调试模式下，代码修改后会自动重新加载，并提供更详细的错误信息。

  5. 运行应用：

    在命令行终端中，确保你位于项目目录 (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)
    * Restarting with stat
    * Debugger is active!
    * Debugger PIN: xxx-xxx-xxx

    这表示 Flask 开发服务器已启动，并在本地的 5000 端口监听请求。

  6. 访问应用：

    打开你的 Web 浏览器，在地址栏输入 http://127.0.0.1:5000/ 或 http://localhost:5000/，然后回车。你应该会看到浏览器中显示 "Hello, World!"。

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

4. 路由和视图函数

在 Flask 中，路由负责将 URL 请求映射到相应的处理函数（称为视图函数）。

4.1 路由基础

Flask 使用 @app.route() 装饰器来定义路由。装饰器的参数指定了 URL 路径，以及可选的 HTTP 方法（如 GET、POST 等）。

```python
from flask import Flask

app = Flask(name)

@app.route("/")
def index():
return "

首页

"

@app.route("/about")
def about():
return "

关于我们

"

@app.route("/contact", methods=["GET", "POST"])
def contact():
if request.method == "POST":
# 处理 POST 请求
return "提交成功"
else:
# 处理 GET 请求
return "联系我们"

if name == "main":
app.run(debug=True)
``
在这个例子中,定义了三个路由:
*/: 对应index函数,返回首页内容.
*/about:对应about函数,返回关于页面内容.
*/contact:对应contact`函数,支持GET和POST两种方法,根据请求方法的不同返回不同的内容

4.2 动态路由

Flask 支持在 URL 中使用变量，构建动态路由。

```python
from flask import Flask

app = Flask(name)

@app.route("/user/")
def show_user_profile(username):
# 显示用户的个人资料
return f"User {username}"

@app.route("/post/")
def show_post(post_id):
# 显示文章内容
return f"Post {post_id}"

if name == "main":
app.run(debug=True)
``
在上面的例子中,使用了两种类型的变量:
*: 字符串类型,匹配任何字符串.
*`: 整数类型,只匹配整数.

Flask还支持其他类型的URL变量,如:
* float: 浮点数
* path: 路径,可以包含斜杠
* uuid: UUID字符串

4.3 URL 构建

Flask 提供了 url_for() 函数来构建 URL。它接受视图函数的名称作为第一个参数，以及任意数量的关键字参数（对应于 URL 中的变量部分）。

```python
from flask import Flask, url_for

app = Flask(name)

@app.route("/")
def index():
return "首页"

@app.route("/user/")
def profile(username):
return f"{username} 的个人资料"

with app.test_request_context():
print(url_for("index")) # 输出: /
print(url_for("profile", username="John Doe")) # 输出: /user/John%20Doe
```

使用 url_for() 的好处是，如果以后修改了 URL 规则，你不需要手动更新所有链接，只需修改路由定义即可。

5. 模板引擎：Jinja2

在实际的 Web 应用中，我们很少直接在视图函数中返回 HTML 代码。通常，我们会使用模板引擎来将 HTML 代码与 Python 代码分离，使代码更易于维护和管理。

Flask 默认使用 Jinja2 模板引擎。Jinja2 提供了强大的模板语法，可以方便地在 HTML 中嵌入 Python 变量和逻辑。

5.1 创建模板

在项目目录中创建一个名为 templates 的文件夹。Flask 会自动在这个文件夹中查找模板文件。

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

```html




首页

欢迎来到{{ name }}的网站！

现在是 {{ current_time }}


```

5.2 渲染模板

在 app.py 中，使用 render_template() 函数来渲染模板：

```python
from flask import Flask, render_template
import datetime

app = Flask(name)

@app.route("/")
def index():
name = "John Doe"
current_time = datetime.datetime.now()
return render_template("index.html", name=name, current_time=current_time)

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

render_template() 函数的第一个参数是模板文件的名称，后面的参数是传递给模板的变量。在模板中，可以使用 {{ variable }} 来访问这些变量。

5.3 模板继承

Jinja2 支持模板继承，可以创建基础模板（通常包含网站的通用结构），然后让其他模板继承并扩展基础模板。

创建一个名为 base.html 的基础模板：

```html




{% block title %}{% endblock %}

网站标题


{% block content %}{% endblock %}

© 2023 版权所有


```

然后，让 index.html 继承 base.html：

```html
{% extends "base.html" %}

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

{% block content %}

欢迎来到{{ name }}的网站！

现在是 {{ current_time }}

{% endblock %}
```

{% extends "base.html" %} 表示继承 base.html 模板。{% block title %} 和 {% block content %} 定义了两个块，分别用于替换基础模板中的相应块。

6. 静态文件

Web 应用通常需要提供静态文件，如 CSS、JavaScript、图片等。Flask 默认将静态文件放在名为 static 的文件夹中。

  1. 创建 static 文件夹： 在项目目录中创建一个名为 static 的文件夹。

  2. 添加静态文件： 将你的 CSS、JavaScript、图片等文件放入 static 文件夹中。

  3. 在模板中引用静态文件： 使用 url_for() 函数生成静态文件的 URL。

    例如，在 static 文件夹中有一个名为 style.css 的 CSS 文件，你可以在模板中这样引用它：

    html
    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">

    对于 static 文件夹中的 images/logo.png 图片，你可以这样引用它：

    html
    <img src="{{ url_for('static', filename='images/logo.png') }}">

7. 表单处理

Web 应用经常需要处理用户提交的表单数据。Flask 提供了 request 对象来访问请求数据，包括表单数据。

7.1 创建表单

在 templates 文件夹中创建一个名为 login.html 的文件，内容如下：

```html




登录

登录





``
这个表单包含两个字段:用户名(username)和密码(password`),提交方法为POST.

7.2 处理表单数据

在 app.py 中，编写处理表单数据的视图函数：

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

app = Flask(name)

@app.route("/login", methods=["GET", "POST"])
def login():
if request.method == "POST":
username = request.form["username"]
password = request.form["password"]
# 在这里验证用户名和密码
if username == "admin" and password == "password":
return redirect(url_for("index")) # 登录成功，重定向到首页
else:
return "用户名或密码错误" # 登录失败
else:
return render_template("login.html")

@app.route("/")
def index():
return "

首页

"

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

在这个例子中:

  • request.method 用于判断请求方法是 GET 还是 POST。
  • request.form 是一个字典，包含了表单提交的数据。
  • redirect(url_for("index")) 用于重定向到首页。

7.3 使用 WTForms（可选）

手动处理表单数据比较繁琐，容易出错。推荐使用 WTForms 库来简化表单处理。

  1. 安装 WTForms：

    bash
    pip install WTForms

  2. 创建表单类：

    ```python
    from flask_wtf import FlaskForm
    from wtforms import StringField, PasswordField, SubmitField
    from wtforms.validators import DataRequired

    class LoginForm(FlaskForm):
    username = StringField("用户名", validators=[DataRequired()])
    password = PasswordField("密码", validators=[DataRequired()])
    submit = SubmitField("登录")
    ```

  3. 在视图函数中使用表单：

    ```python
    from flask import Flask, render_template, request, redirect, url_for
    from flask_wtf.csrf import CSRFProtect #引入CSRFProtect

    导入表单类

    from forms import LoginForm #假设表单类定义在forms.py文件中

    app = Flask(name)
    app.config["SECRET_KEY"] = "your_secret_key" # 设置密钥
    csrf = CSRFProtect(app) #实例化CSRFProtect

    @app.route("/login", methods=["GET", "POST"])
    def login():
    form = LoginForm()
    if form.validate_on_submit():
    username = form.username.data
    password = form.password.data
    # 在这里验证用户名和密码
    if username == "admin" and password == "password":
    return redirect(url_for("index"))
    else:
    return "用户名或密码错误"
    return render_template("login_wtf.html", form=form)

    @app.route("/")
    def index():
    return "

    首页

    "

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

    • app.config["SECRET_KEY"] 用于设置密钥，防止跨站请求伪造（CSRF）攻击。
    • WTForms 会自动生成包含 CSRF 令牌的隐藏字段。
    • form.validate_on_submit() 用于验证表单数据是否有效。
    • form.username.data 和 form.password.data 分别获取用户名和密码字段的值。

  4. 在模板中渲染表单：

    html
    <!DOCTYPE html>
    <html>
    <head>
    <title>登录</title>
    </head>
    <body>
    <h1>登录</h1>
    <form method="post">
    {{ form.hidden_tag() }} {# 渲染 CSRF 令牌 #}
    {{ form.username.label }} {{ form.username }}<br><br>
    {{ form.password.label }} {{ form.password }}<br><br>
    {{ form.submit }}
    </form>
    </body>
    </html>

    • {{ form.hidden_tag() }} 用于渲染 CSRF 令牌。
    • {{ form.username.label }} 和 {{ form.username }} 分别渲染用户名标签和输入框。

WTForms 还提供了其他功能，如自定义验证器、文件上传等。

8. 数据库集成

大多数 Web 应用都需要与数据库交互，存储和检索数据。Flask 可以与各种数据库集成，如 SQLite、MySQL、PostgreSQL、MongoDB 等。

本教程以 SQLite 为例，介绍 Flask 与数据库的集成。

8.1 安装 Flask-SQLAlchemy

Flask-SQLAlchemy 是一个 Flask 扩展，简化了 Flask 与 SQLAlchemy 的集成。SQLAlchemy 是一个流行的 Python SQL 工具包和对象关系映射器（ORM）。

bash
pip install Flask-SQLAlchemy

8.2 配置数据库

在 app.py 中，配置数据库连接：

```python
from flask import Flask, render_template, request, redirect, url_for
from flask_sqlalchemy import SQLAlchemy

app = Flask(name)
app.config["SQLALCHEMY_DATABASE_URI"] = "sqlite:///mydatabase.db" # 使用 SQLite 数据库
app.config["SQLALCHEMY_TRACK_MODIFICATIONS"] = False # 关闭追踪对象的修改，提高性能
db = SQLAlchemy(app)

后面的代码省略

``SQLALCHEMY_DATABASE_URI指定了数据库连接字符串,这里使用了SQLite数据库,数据库文件名为mydatabase.db.SQLALCHEMY_TRACK_MODIFICATIONS设置为False` 可以关闭 SQLAlchemy 对对象修改的追踪，提高性能（在不需要追踪修改的情况下）。

8.3 定义模型

使用 Flask-SQLAlchemy，你可以通过定义 Python 类来表示数据库表。

```python

接上面的代码

class User(db.Model):
id = db.Column(db.Integer, primary_key=True)
username = db.Column(db.String(80), unique=True, nullable=False)
password = db.Column(db.String(120), nullable=False)

def __repr__(self):
    return f"<User {self.username}>"

```

这个例子定义了一个名为 User 的模型，对应于数据库中的 users 表。它有三个字段：

  • id: 整数类型，主键。
  • username: 字符串类型，唯一且不能为空。
  • password: 字符串类型，不能为空。

__repr__ 方法用于在调试时显示对象的字符串表示。

8.4 创建数据库表

在 Python 交互式 shell 中（确保虚拟环境已激活），运行以下代码创建数据库表：

```python
from app import app, db # 导入 app 和 db 对象

with app.app_context():
db.create_all()
```

这会在项目目录中创建一个名为 mydatabase.db 的 SQLite 数据库文件，并创建 users 表。

8.5 数据库操作

现在，你可以在视图函数中进行数据库操作了。

```python

接上面的代码

@app.route("/register", methods=["GET", "POST"])
def register():
if request.method == "POST":
username = request.form["username"]
password = request.form["password"]
# 检查用户名是否已存在
user = User.query.filter_by(username=username).first()
if user:
return "用户名已存在"
# 创建新用户
new_user = User(username=username, password=password)
db.session.add(new_user)
db.session.commit()
return redirect(url_for("login"))
else:
return render_template("register.html")

@app.route("/login", methods=["GET", "POST"])
def login():
if request.method == "POST":
username = request.form["username"]
password = request.form["password"]
# 查询用户
user = User.query.filter_by(username=username).first()
if user and user.password == password:
return redirect(url_for("index"))
else:
return "用户名或密码错误"
else:
return render_template("login.html")

if name == "main":
app.run(debug=True)
``
这段代码添加了/register路由,用于用户注册,/login`用于用户登录:
* 注册时,首先检查用户名是否存在,如果存在则返回错误信息,否则创建新用户并添加到数据库.
* 登录时,根据用户名查询用户,如果用户存在且密码正确,则登录成功,重定向到首页.

Flask-SQLAlchemy 提供了丰富的 API 来进行数据库查询、更新、删除等操作。你可以参考 Flask-SQLAlchemy 文档了解更多信息。

9. 会话管理

Web 应用通常需要跟踪用户的登录状态。Flask 提供了 session 对象来管理会话。

9.1 设置密钥

在使用会话之前，你需要设置一个密钥。密钥用于加密会话数据，防止篡改。

python
app.config["SECRET_KEY"] = "your_secret_key" # 设置一个安全的密钥

9.2 使用会话

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

... 其他导入

@app.route("/login", methods=["GET", "POST"])
def login():
if request.method == "POST":
username = request.form["username"]
password = request.form["password"]
user = User.query.filter_by(username=username).first()
if user and user.password == password:
session["user_id"] = user.id # 将用户 ID 存储在会话中
return redirect(url_for("index"))
else:
return "用户名或密码错误"
else:
return render_template("login.html")

@app.route("/logout")
def logout():
session.pop("user_id", None) # 从会话中移除用户 ID
return redirect(url_for("index"))

@app.route("/")
def index():
if "user_id" in session:
user = User.query.get(session["user_id"])
return f"

欢迎，{user.username}！

"
else:
return "

首页

"
```

在这个例子中：

  • 登录成功后，将用户 ID 存储在 session 中。
  • 退出登录时，从 session 中移除用户 ID。
  • 在首页视图函数中，检查 session 中是否有用户 ID，如果有，则显示欢迎信息。

Flask 会话默认使用 cookie 来存储数据。cookie 是存储在用户浏览器中的小型文本文件。Flask 会对 cookie 中的会话数据进行加密，以防止篡改。

10. 部署

开发完成后，你需要将 Flask 应用部署到服务器上，以便用户可以通过互联网访问。

有多种部署 Flask 应用的方法，这里介绍两种常用的方法：

10.1 使用 Gunicorn 和 Nginx

Gunicorn 是一个 WSGI HTTP 服务器，用于运行 Python Web 应用。Nginx 是一个高性能的 Web 服务器，通常用作反向代理，将请求转发给 Gunicorn。

  1. 安装 Gunicorn 和 Nginx：

    ```bash
    pip install gunicorn
    sudo apt-get install nginx # Ubuntu/Debian

    或

    sudo yum install nginx # CentOS/RHEL
    ```

  2. 启动 Gunicorn：

    在项目目录中，运行以下命令启动 Gunicorn：

    bash
    gunicorn --workers 3 --bind 0.0.0.0:8000 app:app

    • --workers 3: 指定 Gunicorn 使用 3 个工作进程。
    • --bind 0.0.0.0:8000: 指定 Gunicorn 监听的地址和端口。
    • app:app: 指定 Flask 应用实例的位置（app 是你的 app.py 文件名，app 是 Flask 应用实例的名称）。

  3. 配置 Nginx：

    创建一个 Nginx 配置文件（例如 /etc/nginx/sites-available/my_flask_app）：

    ```nginx
    server {
    listen 80;
    server_name your_domain.com; # 替换为你的域名或服务器 IP

    location / {
    proxy_pass http://127.0.0.1:8000;  # 将请求转发给 Gunicorn
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
}

location /static {
    alias /path/to/your/project/static;  # 替换为你的静态文件目录的绝对路径
}

    }
    ```

    • listen 80: 指定 Nginx 监听 80 端口（HTTP 默认端口）。
    • server_name: 指定你的域名或服务器 IP。
    • proxy_pass: 将请求转发给 Gunicorn。
    • proxy_set_header: 设置请求头，以便 Gunicorn 获取正确的信息。
    • location /static: 配置 Nginx 直接提供静态文件，提高性能。

    创建符号链接，启用 Nginx 配置：

    bash
    sudo ln -s /etc/nginx/sites-available/my_flask_app /etc/nginx/sites-enabled/

    重启 Nginx：

    bash
    sudo systemctl restart nginx

  4. 使用 systemd 管理 Gunicorn（可选）
    可以配置systemd 来管理 Gunicorn 进程，实现开机自启和进程守护。
    创建一个 systemd 服务文件（例如 /etc/systemd/system/my_flask_app.service）：

    ```ini
[Unit]
Description=Gunicorn instance to serve my_flask_app
After=network.target

[Service]
User=your_user  # 替换为你的用户名
Group=www-data
WorkingDirectory=/path/to/your/project  # 替换为你的项目目录的绝对路径
Environment="PATH=/path/to/your/project/venv/bin"  # 替换为你的虚拟环境的 bin 目录的绝对路径
ExecStart=/path/to/your/project/venv/bin/gunicorn --workers 3 --bind unix:my_flask_app.sock -m 007 app:app

[Install]
WantedBy=multi-user.target

```

* `User` 和 `Group`: 指定运行 Gunicorn 的用户和组。
* `WorkingDirectory`: 指定 Gunicorn 的工作目录。
* `Environment`: 设置环境变量，指定虚拟环境的路径。
* `ExecStart`: 指定启动 Gunicorn 的命令。这里使用了 Unix 套接字（`my_flask_app.sock`）来与 Nginx 通信，可以提高性能。

修改 Nginx 配置，使用 Unix 套接字：

```nginx
server {
    listen 80;
    server_name your_domain.com;

    location / {
        proxy_pass http://unix:/path/to/your/project/my_flask_app.sock;  # 使用 Unix 套接字
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }

    location /static {
        alias /path/to/your/project/static;
    }
}

```

    重新加载 systemd 配置并启动服务：
```bash
sudo systemctl daemon-reload
sudo systemctl start my_flask_app
sudo systemctl enable my_flask_app #设置开机自启

```

10.2 使用 Docker

Docker 是一种容器化技术，可以将 Flask 应用及其依赖项打包到一个独立的容器中，方便部署和移植。

  1. 创建 Dockerfile：

    在项目目录中创建一个名为 Dockerfile 的文件，内容如下：

    ```dockerfile
    FROM python:3.9 # 使用 Python 3.9 镜像

    WORKDIR /app # 设置工作目录

    COPY requirements.txt . # 复制依赖文件
    RUN pip install --no-cache-dir -r requirements.txt # 安装依赖

    COPY . . # 复制项目代码

    CMD ["gunicorn", "--workers", "3", "--bind", "0.0.0.0:8000", "app:app"] # 启动 Gunicorn
    ```

    • FROM: 指定基础镜像。
    • WORKDIR: 设置工作目录。
    • COPY: 复制文件。
    • RUN: 运行命令。
    • CMD: 指定容器启动时执行的命令。

  2. 创建 requirements.txt：

    在项目目录中创建一个名为 requirements.txt 的文件，列出你的项目依赖：

    ```
    Flask
    Flask-SQLAlchemy
    WTForms
    gunicorn

    其他依赖

    ```

  3. 构建 Docker 镜像：

    在项目目录中，运行以下命令构建 Docker 镜像：

    bash
    docker build -t my-flask-app .

    • -t my-flask-app: 给镜像命名为 my-flask-app。

  4. 运行 Docker 容器：

    bash
    docker run -d -p 8000:8000 my-flask-app

    • -d: 在后台运行容器。
    • -p 8000:8000: 将容器的 8000 端口映射到主机的 8000 端口。

现在，你可以通过访问主机的 8000 端口来访问你的 Flask 应用。

你可以将 Docker 镜像上传到 Docker Hub 或私有仓库，方便在其他服务器上部署。

11. 总结与展望

本教程详细介绍了 Flask 的核心概念和常用功能，包括路由、模板引擎、静态文件、表单处理、数据库集成、会话管理和部署。通过一个实际的项目示例，你学习了如何使用 Flask 构建一个基本的 Web 应用。

Flask 是一个功能强大且灵活的 Web 框架，你可以通过丰富的扩展来增强其功能。以下是一些常用的 Flask 扩展：

  • Flask-Login： 提供用户认证功能。
  • Flask-Mail： 提供邮件发送功能。
  • Flask-RESTful： 简化 RESTful API 的开发。
  • Flask-Admin： 提供后台管理界面。
  • Flask-SocketIO： 提供 WebSocket 支持，实现实时通信。

Flask 社区非常活跃，你可以通过 Flask 官网、Stack Overflow、GitHub 等渠道找到丰富的学习资源和帮助。

希望本教程能帮助你入门 Flask Web 开发。祝你学习愉快，构建出色的 Web 应用！

版权声明：
作者：admin
链接：https://hostlocvps.com/2025/03/17/flask-%e6%95%99%e7%a8%8b%ef%bc%9a%e4%bd%bf%e7%94%a8-python-%e6%9e%84%e5%bb%ba-web-%e5%ba%94%e7%94%a8/
文章版权归作者所有，未经允许请勿转载。
THE END
还在烦恼C盘空间？这篇教你如何清理和避免 C 盘满。
<<上一篇
HTTP 429 Too Many Requests：全面解析与应对策略
下一篇>>
相关推荐
Z-Library最全镜像站列表（中国大陆）
Oracle Corporation：全面介绍与分析
C++在线编译运行：立即获取结果，无需安装！ (关键词 + 优势)
"could not open a connection to your authentication agent" 错误：原因与解决方法
Ubuntu系统优化和卡顿解决
【UDP协议】最全面的UDP协议介绍
Elasticsearch 开发者必读：GitHub 代码库结构与协作规范
ChatGPT API详解：开发者如何接入ChatGPT功能
OpenSSL详解：原理、应用与安全指南
1 美元换算菲律宾比索：快速查询与汇率更新