👏🏻 你好！欢迎访问IT教程网，0门教程，教程全部原创，计算机教程大全，全免费！

🔥 新增教程

《黑神话 悟空》游戏开发教程，共40节，完全免费，点击学习

《AI副业教程》，完全原创教程，点击学习

发表更新软件开发 / Flask从零教程5 分钟读完 (大约816个字)

13 Flask 模板渲染之模板继承

在上一篇中，我们学习了如何在 Flask 中使用模板变量来动态渲染内容，而本篇将深入探讨 模板继承 的概念，以实现代码重用和视图的模块化。模板继承使得我们可以创建一个基础模板，然后在其基础上扩展和修改其他模板，从而避免代码重复，提高维护性。

模板继承的基本概念

在 Flask 中，模板继承允许我们定义一个基本的布局模板（base.html），然后其他模板可以从这个基本模板继承并扩展其内容。这种方式便于对整体网站风格的统一管理，比如头部、底部或其他常见元素。

创建基础模板

首先，我们需要创建一个基础模板 base.html，该模板将包括页面的基本结构，比如头部、脚部和主页内容的占位符。

以下是一个简单的 base.html 模板示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
<!DOCTYPE html>
<html lang="zh">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>{% block title %}我的网站{% endblock %}</title>
</head>
<body>
    <header>
        <h1>欢迎来到我的网站</h1>
        <nav>
            <ul>
                <li><a href="/">主页</a></li>
                <li><a href="/about">关于我们</a></li>
            </ul>
        </nav>
    </header>

    <main>
        {% block content %}
        <!-- 子模板内容将会插入这里 -->
        {% endblock %}
    </main>

    <footer>
        <p>版权所有 © 2023</p>
    </footer>
</body>
</html>

在这个模板中，我们使用了两个 block 标签分别定义了 title 和 content 的占位符。子模板可以重写这些 block，从而定制具体页面的内容。

创建子模板

接下来，我们将创建一个关于页面模板 about.html，它将继承自基础模板 base.html。你可以在 about.html 中定义特定于该页面的内容，例如：

1
2
3
4
5
6
7
8
{% extends "base.html" %}

{% block title %}关于我们{% endblock %}

{% block content %}
<h2>关于我们</h2>
<p>我们是一家专注于 Flask 教程的公司。</p>
{% endblock %}

在这个示例中，使用 extends 语句指明 about.html 模板继承自 base.html。然后，我们重写了 title 和 content 的 block，以提供特定于该页面的信息。

在 Flask 中渲染模板

现在，我们来看看如何在 Flask 应用中渲染这些模板。以下是一个简单的 Flask 应用示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
from flask import Flask, render_template

app = Flask(__name__)

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

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

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

在以上代码中，我们定义了两个路由：/ 和 /about。在 /about 的视图函数中，我们调用 render_template 渲染 about.html 模板。由于 about.html 继承了 base.html，因此会自动包含基础模板的内容。

结论

模板继承极大地提高了我们在 Flask 应用中的模板管理效率。在大型应用中，使用模板继承可以降低重复代码的数量，同时保持一致性。通过定义合理的基础模板，能够快速构建出复杂的网页结构。

在下一篇中，我们将讨论 表单处理，并介绍如何使用 Flask-WTF 库来处理和验证表单。接下来我们再深入了解如何创建和处理表单类，实现用户输入的有效管理。

分享转发

发表更新软件开发 / Flask从零教程7 分钟读完 (大约996个字)

14 表单类的内容

在前一篇文章中，我们讨论了如何使用模板渲染和模板继承来构建具有层次结构的网页。在这一部分中，我们将专注于表单处理中的表单类内容，使用 Flask-WTF 扩展来简化表单的创建和验证。通过这个系列教程，你将能够有效地处理用户输入并确保数据的安全性和有效性。

Flask-WTF 简介

Flask-WTF 是一个与 Flask 结合使用的扩展，它使得表单的处理变得简单而高效。通过定义表单类，我们可以为每个表单字段添加验证规则，并自动生成 CSRF 令牌以保护我们的网站。

安装 Flask-WTF

在开始之前，首先确保安装了 Flask-WTF。你可以使用 pip 安装它：

1
pip install Flask-WTF

创建表单类

首先，我们将创建一个简单的用户注册表单。我们会使用 Flask-WTF 中的 FlaskForm 类来定义我们的表单。

1
2
3
4
5
6
7
8
9
10
11
12
13
from flask import Flask, render_template, redirect, url_for, flash
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import DataRequired, Length, EqualTo

app = Flask(__name__)
app.config['SECRET_KEY'] = 'your_secret_key'

class RegistrationForm(FlaskForm):
    username = StringField('用户名', validators=[DataRequired(), Length(min=2, max=20)])
    password = PasswordField('密码', validators=[DataRequired(), Length(min=6, max=20)])
    confirm_password = PasswordField('确认密码', validators=[DataRequired(), EqualTo('password')])
    submit = SubmitField('注册')

在这个例子中，我们创建了一个 RegistrationForm 类，这个类包含了三个字段：username、password 和 confirm_password。每个字段都有相应的验证器，这可以确保用户输入有效的内容。

表单模板

接下来，让我们在模板中渲染这个表单。创建一个名为 register.html 的文件，内容如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>注册</title>
</head>
<body>
    <h1>注册</h1>
    <form method="POST" action="{{ url_for('register') }}">
        {{ form.hidden_tag() }}
        <div>
            {{ form.username.label }}: {{ form.username(size=32) }} 
            {% for error in form.username.errors %}
                <span style="color: red;">{{ error }}</span>
            {% endfor %}
        </div>
        <div>
            {{ form.password.label }}: {{ form.password(size=32) }}
            {% for error in form.password.errors %}
                <span style="color: red;">{{ error }}</span>
            {% endfor %}
        </div>
        <div>
            {{ form.confirm_password.label }}: {{ form.confirm_password(size=32) }}
            {% for error in form.confirm_password.errors %}
                <span style="color: red;">{{ error }}</span>
            {% endfor %}
        </div>
        <div>
            {{ form.submit() }}
        </div>
    </form>
</body>
</html>

在这个模板中，我们使用了 Flask-WTF 的 hidden_tag 方法来包含 CSRF 令牌，防止跨站请求伪造攻击。此外，我们还循环显示每个字段的错误消息，以便于用户做出相应的修改。

处理表单数据

最后，我们需要在视图函数中处理用户提交的表单数据。以下是处理用户注册的简单示例：

1
2
3
4
5
6
7
8
9
10
11
@app.route('/register', methods=['GET', 'POST'])
def register():
    form = RegistrationForm()
    if form.validate_on_submit():
        # 用户输入有效，可以进行下一步操作
        username = form.username.data
        password = form.password.data
        # TODO: 在这里保存用户信息，比如插入数据库
        flash('注册成功！请登录。', 'success')
        return redirect(url_for('login'))  # 重定向到登录页面
    return render_template('register.html', form=form)

在这个视图函数中，我们实例化了 RegistrationForm 并检查表单是否经过验证 (validate_on_submit() 方法会自动处理表单验证和 CSRF 检查)。如果验证成功，我们可以获取表单字段的值并进行相应的处理，例如将用户信息存储在数据库中。最后，我们使用 flash 函数来显示成功消息，并重定向用户到登录页面。

小结

在本节中，我们学习了如何使用 Flask-WTF 创建表单类并处理表单输入。通过定义表单类，我们可以将表单结构和验证逻辑集中在一个地方，从而提升代码的可维护性与安全性。

在下一篇文章中，我们将集中讨论如何处理提交的表单数据，包括与数据库的交互等内容，确保你的应用在处理用户输入时既安全又高效。继续关注系列教程，让我们一起深入学习 Flask 的奥秘！

分享转发

发表更新软件开发 / Flask从零教程5 分钟读完 (大约783个字)

15 Flask表单处理之处理表单的内容

在上一篇教程中，我们讨论了如何使用 Flask-WTF 创建表单类，这为我们之后处理表单提交的数据奠定了基础。在本篇中，我们将深入探讨如何接收和处理提交的表单内容。这是构建 Web 应用程序的重要组成部分，因为用户输入往往是应用程序的核心。

接收表单数据

在 Flask 中，当用户提交表单时，数据会通过 HTTP POST 请求发送到服务器。我们可以在视图函数中通过 request 对象来接收这些数据。首先，我们需要导入 Flask 和相关模块：

1
2
3
4
from flask import Flask, render_template, request, redirect, url_for
from flask_wtf import FlaskForm
from wtforms import StringField, SubmitField
from wtforms.validators import DataRequired

然后，我们可以定义一个简单的 Flask 应用程序和表单类：

1
2
3
4
5
6
app = Flask(__name__)
app.config['SECRET_KEY'] = 'your_secret_key'

class MyForm(FlaskForm):
    username = StringField('Username', validators=[DataRequired()])
    submit = SubmitField('Submit')

接下来，我们添加一个视图函数来处理表单显示和提交逻辑：

1
2
3
4
5
6
7
@app.route('/form', methods=['GET', 'POST'])
def form():
    form = MyForm()
    if form.validate_on_submit():  # 验证表单是否有效
        username = form.username.data  # 获取表单数据
        return redirect(url_for('success', username=username))  # 重定向到成功页面
    return render_template('form.html', form=form)

在上面的代码中，当表单被提交并通过验证后，我们可以使用 form.username.data 获取表单中的用户名。

处理表单内容

在实际应用中，处理表单内容通常涉及将数据存储到数据库中、发送邮件、或执行其他逻辑。在我们的案例中，我们简单地将用户名重定向到一个成功页面。

我们需要一个成功视图来显示处理后的结果：

1
2
3
@app.route('/success/<username>')
def success(username):
    return f'Hello, {username}! Your form has been submitted successfully.'

表单页面模板

为了完整地运行这个例子，我们需要一个简单的 HTML 模板来呈现我们的表单。创建一个 form.html 文件，并添加以下内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Flask Form</title>
</head>
<body>
    <h1>Input your username</h1>
    <form method="POST">
        {{ form.hidden_tag() }}
        <p>
            {{ form.username.label }}<br>
            {{ form.username(size=32) }}<br>
            {% for error in form.username.errors %}
                <span style="color: red;">[{{ error }}]</span>
            {% endfor %}
        </p>
        <p>{{ form.submit() }}</p>
    </form>
</body>
</html>

在这个模板中，我们使用了 Jinja2 模板引擎来渲染表单。{{ form.hidden_tag() }} 用于生成 CSRF 保护。表单提交后，用户将在成功页面看到他们输入的用户名。

总结

在本节中，我们学习了如何处理 Flask 表单提交的内容。通过在视图函数中接收表单数据、进行简单的处理，并将结果反馈给用户，我们搭建了一个基础的表单处理流程。在下一篇教程中，我们将聚焦于表单验证，以确保用户输入的数据有效和安全。这样，我们的应用将更加健壮和可靠。

保持关注，下一篇将深入讨论如何使用 Flask-WTF 进行表单验证！

分享转发

发表更新软件开发 / Flask从零教程7 分钟读完 (大约997个字)

16 表单处理之表单验证

在上一篇中，我们了解了如何处理表单，接下来，我们将重点讨论表单验证。在实际的 web 开发中，表单验证是非常重要的环节，确保用户提交的数据是有效和安全的。

表单验证的重要性

表单验证的目的是确保用户输入的数据符合特定的规则，以免无效或恶意的数据影响应用的安全性和稳定性。通过验证，可以避免诸如 SQL 注入、XSS 攻击等安全问题。

使用 Flask-WTF 进行表单验证

Flask 提供了一个扩展库叫做 Flask-WTF，它基于 WTForms 实现，简化了表单处理和验证的过程。首先，我们需要安装 Flask-WTF：

1
pip install flask-wtf

创建表单类

我们可以通过创建一个表单类来处理表单验证。以下是一个简单的表单类，它包含了用户的用户名和密码字段，并进行相应的验证。

1
2
3
4
5
6
7
8
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import DataRequired, Length, EqualTo

class LoginForm(FlaskForm):
    username = StringField('用户名', validators=[DataRequired(), Length(min=2, max=20)])
    password = PasswordField('密码', validators=[DataRequired()])
    submit = SubmitField('登录')

在这个例子中：

  • StringField 和 PasswordField 是表单字段，分别用于接收用户输入的用户名和密码。
  • validators 是用于验证字段内容的参数。我们的例子中：
    • DataRequired 表示该字段不能为空。
    • Length 用于限制输入的长度。

在视图中使用表单

接下来，我们将在视图函数中使用这个表单，并处理验证逻辑。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from flask import Flask, render_template, redirect, url_for, flash
from your_module import LoginForm  # 确保正确导入表单类

app = Flask(__name__)
app.secret_key = 'your_secret_key'  # 用于闪现消息的密钥

@app.route('/login', methods=['GET', 'POST'])
def login():
    form = LoginForm()  # 创建表单实例
    if form.validate_on_submit():  # 验证表单
        username = form.username.data
        password = form.password.data
        # 在这里，你可以添加数据库查询来验证用户
        flash('登录成功！', 'success')  # 显示成功消息
        return redirect(url_for('home'))  # 重定向到首页
    return render_template('login.html', form=form)

在这里，我们在 login 视图中创建了 LoginForm 的实例，并使用 validate_on_submit() 方法来检测表单是否被提交且数据有效。如果验证通过，我们可以处理实际的登录逻辑（如查询数据库用户信息），并显示成功消息。

模板中的表单

接下来，我们需要在 HTML 模板中渲染这个表单。以下是一个简单的模板代码示例（login.html）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
<!DOCTYPE html>
<html lang="zh-CN">
<head>
    <meta charset="UTF-8">
    <title>登录</title>
</head>
<body>
    <h1>用户登录</h1>
    <form method="POST">
        {{ form.hidden_tag() }}  <!-- 防止跨站请求伪造 -->
        <div>
            {{ form.username.label }} 
            {{ form.username(size=32) }}
            {% for error in form.username.errors %}
                <span style="color: red;">[{{ error }}]</span>
            {% endfor %}
        </div>
        <div>
            {{ form.password.label }}
            {{ form.password(size=32) }}
            {% for error in form.password.errors %}
                <span style="color: red;">[{{ error }}]</span>
            {% endfor %}
        </div>
        <div>
            {{ form.submit() }}
        </div>
    </form>
    {% with messages = get_flashed_messages(with_categories=True) %}
        {% if messages %}
            <ul>
            {% for category, message in messages %}
                <li class="{{ category }}">{{ message }}</li>
            {% endfor %}
            </ul>
        {% endif %}
    {% endwith %}
</body>
</html>

在这个模板中，我们使用了 Flask-WTF 提供的渲染方法来显示表单。每个表单字段后都有一个循环，用于显示任何可能的验证错误，这样可以清晰地反馈给用户。

小结

现在我们已经完成了基于 Flask-WTF 的表单验证。通过在 Flask 应用中集成表单类和验证，我们能够确保收集到的用户数据是有效且安全的。在下一个章节中，我们将进一步触及数据库操作，使用 SQLAlchemy 来处理数据存储。表单验证将为我们在数据库中的数据操作提供坚实的基础。

预告：数据库操作之使用 SQLAlchemy

敬请期待，下一篇我们将一起深入了解如何使用 SQLAlchemy 进行数据库操作，管理用户信息等重要应用。

分享转发

发表更新软件开发 / Flask从零教程8 分钟读完 (大约1244个字)

17 使用SQLAlchemy进行数据库操作

在上一篇文章中，我们讨论了表单处理和表单验证，这为我们的应用程序提供了前端数据输入的基础。而在这一篇中，我们将深入探讨使用 SQLAlchemy 进行数据库操作，为我们的 Flask 应用程序增加持久化存储的能力。我们的最终目标是能够通过数据库对应用程序的数据进行操作。

什么是 SQLAlchemy？

SQLAlchemy 是一个 SQL 工具包和对象关系映射（ORM）框架，它为 Python 提供了通用的 SQL 语言接口。通过 SQLAlchemy，我们可以使用 Python 类和对象来表示我们的数据库表和记录，从而使得数据操作更加直观和方便。

安装 SQLAlchemy

在开始之前，我们需要先安装 SQLAlchemy。可以使用以下命令：

1
pip install Flask-SQLAlchemy

Flask-SQLAlchemy 是一个与 Flask 配合使用的扩展，它简化了 SQLAlchemy 在 Flask 应用中的使用。

配置数据库

在你的 Flask 应用中，你需要配置数据库连接。下面是一个基本的示例：

1
2
3
4
5
6
7
8
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///example.db'  # 使用 SQLite 数据库
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

db = SQLAlchemy(app)

在上面的代码中，我们配置了一个 SQLite 数据库，文件名为 example.db。你可以根据需要修改为其他数据库，如 PostgreSQL 或 MySQL。

定义模型

在 SQLAlchemy 中，我们使用模型类来定义数据库表。模型类映射到数据库表，类的属性映射到表的列。以下是一个简单的用户模型示例：

1
2
3
4
5
6
7
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)  # 主键
    username = db.Column(db.String(80), unique=True, nullable=False)  # 唯一用户名
    email = db.Column(db.String(120), unique=True, nullable=False)  # 唯一邮箱

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

在这个 User 类中，我们定义了三个属性：id、username 和 email。其中 id 是主键，username 和 email 则是唯一且不能为空的。

数据库迁移

在定义完模型后，我们需要创建数据库和表。你可以通过以下命令建立数据库和表：

1
2
with app.app_context():
    db.create_all()

这段代码会根据你定义的模型生成相应的数据库表。

基本数据库操作

在使用 SQLAlchemy 进行数据库操作时，我们通常会用到 CRUD（创建、读取、更新、删除）操作。接下来我们将详细探讨每一个操作。

创建用户

我们可以通过以下方式创建一个新的用户：

1
2
3
new_user = User(username='john_doe', email='john@example.com')
db.session.add(new_user)  # 将新用户添加到会话中
db.session.commit()  # 提交会话

这段代码会在数据库中插入一条新的用户记录。

读取用户

要查询用户，我们可以使用以下方法：

1
2
user = User.query.filter_by(username='john_doe').first()  # 查询第一个符合条件的用户
print(user.email)  # 输出用户的邮箱

filter_by 方法用于筛选符合条件的数据，而 first 方法用于获取查询结果中的第一条记录。

更新用户

要更新用户信息，只需修改对象属性并提交会话，例如：

1
2
user.email = 'john.doe@example.com'  # 修改邮箱
db.session.commit()  # 提交更改

这样会将该用户的邮箱更新到新的值。

删除用户

要删除用户，可以使用以下代码：

1
2
db.session.delete(user)  # 从会话中删除用户
db.session.commit()  # 提交更改

只需从会话中删除对象并提交即可，相关记录将会被移除。

小案例：用户注册

为了更好地展示 SQLAlchemy 在实际应用中的使用，这里是一个简单的用户注册 API 的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
from flask import request, jsonify

@app.route('/register', methods=['POST'])
def register():
    data = request.get_json()
    username = data['username']
    email = data['email']

    if User.query.filter_by(username=username).first() is not None:
        return jsonify({'message': '用户已存在!'}), 400
    
    new_user = User(username=username, email=email)
    db.session.add(new_user)
    db.session.commit()
    
    return jsonify({'message': '用户注册成功!', 'username': username}), 201

在这个 register 路由中，我们接收 POST 请求的 JSON 数据，检查用户是否已存在，并进行相应的创建操作。

结语

至此，我们简单地介绍了如何在 Flask 应用中使用 SQLAlchemy 进行数据库操作，从配置数据库到基本的 CRUD 操作。通过实践这些内容，你将能够为你的 Flask 应用程序处理数据存储与管理。在下一篇文章中，我们将进一步深入 CRUD 操作的细节，探索更复杂的数据库查询和操作。希望本篇文章内容对你有所帮助！

分享转发

发表更新软件开发 / Flask从零教程7 分钟读完 (大约982个字)

18 数据库操作之基本 CRUD 操作

在上一篇文章中，我们介绍了如何使用 SQLAlchemy 进行数据库操作，了解了基础的 ORM（对象关系映射）概念。本篇将继续深入数据库的操作内容，重点讲解基本的 CRUD（创建、读取、更新、删除）操作。后续将会讨论数据库迁移内容。因此，了解基本的 CRUD 操作对我们更加高效地进行数据库管理至关重要。

一、什么是 CRUD 操作？

CRUD 是指在数据库中进行的四种基本操作：

  • Create：创建新的记录
  • Read：读取已有的记录
  • Update：更新现有的记录
  • Delete：删除记录

在 Flask 中，我们将利用 SQLAlchemy 来实现这些操作，确保我们的数据持久化存储在数据库中。

二、环境准备

在开始之前，请确保你已经安装了 Flask 和 SQLAlchemy。你可以使用以下命令安装：

1
pip install Flask Flask-SQLAlchemy

接下来，我们将创建一个简单的 Flask 应用，并配置 SQLAlchemy。

创建 Flask 应用

首先，我们需要创建一个基本的 Flask 应用，结构如下：

1
2
3
4
/my_flask_app
│
├── app.py
└── models.py

app.py 文件

在 app.py 中，我们将设置 Flask 应用和数据库。

1
2
3
4
5
6
7
8
9
from flask import Flask
from flask_sqlalchemy import SQLAlchemy

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///test.db'  # 使用 SQLite 数据库
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
db = SQLAlchemy(app)

from models import User  # 导入模型

models.py 文件

在 models.py 中，我们将定义我们的数据库模型。

1
2
3
4
5
6
7
8
9
from app import db

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

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

三、基本的 CRUD 操作

创建（Create）

要创建新的记录，我们可以使用模型的实例化方法，并调用 db.session.add() 和 db.session.commit() 来保存到数据库。

1
2
3
4
5
def create_user(username, email):
    new_user = User(username=username, email=email)
    db.session.add(new_user)
    db.session.commit()
    return new_user

读取（Read）

读取记录可以使用 query 方法。我们可以获取所有用户或者查找特定的用户。

1
2
3
4
5
def get_all_users():
    return User.query.all()

def get_user_by_id(user_id):
    return User.query.get(user_id)

更新（Update）

更新记录需要先查询到该记录，然后修改属性，最后提交更改。

1
2
3
4
5
6
7
def update_user(user_id, new_username, new_email):
    user = User.query.get(user_id)
    if user:
        user.username = new_username
        user.email = new_email
        db.session.commit()
    return user

删除（Delete）

删除记录同样需要查询到记录后进行删除。

1
2
3
4
5
6
def delete_user(user_id):
    user = User.query.get(user_id)
    if user:
        db.session.delete(user)
        db.session.commit()
    return user

四、示例应用

现在我们将这些 CRUD 方法整合到一个简单的 Flask 路由中，演示如何在应用中使用这些操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@app.route('/create/<username>/<email>')
def create(username, email):
    user = create_user(username, email)
    return f'Created user: {user.username}'

@app.route('/users')
def users():
    users = get_all_users()
    return '<br>'.join([user.username for user in users])

@app.route('/update/<int:user_id>/<new_username>/<new_email>')
def update(user_id, new_username, new_email):
    user = update_user(user_id, new_username, new_email)
    return f'Updated user: {user.username}' if user else 'User not found!'

@app.route('/delete/<int:user_id>')
def delete(user_id):
    user = delete_user(user_id)
    return f'Deleted user: {user.username}' if user else 'User not found!'

五、总结

在本篇中，我们成功实现了基本的 CRUD 操作，使用 Flask 与 SQLAlchemy 进行数据的持久化操作。通过创建、读取、更新和删除用户信息，我们可以更好地管理我们的数据。

下篇文章将继续深入数据库操作，我们将学习如何进行数据库迁移，帮助我们在开发过程中管理和变更数据库结构。感谢你的阅读，期待下次再见！

分享转发

发表更新软件开发 / Flask从零教程7 分钟读完 (大约1115个字)

19 Flask数据库迁移操作教程

在上一节中，我们学习了Flask的基本数据库操作，包括如何进行CRUD（创建、读取、更新、删除）操作。继承上篇，今天我们将深入探讨Flask中的数据库迁移，确保我们能高效地管理数据库架构的变化。

什么是数据库迁移？

数据库迁移是应用程序数据架构变更的过程，它允许我们在不丢失数据的情况下，对数据库进行结构上的修改。比如，当我们需要添加新的字段、删除不再需要的字段，或者更改字段的数据类型时，数据库迁移变得尤为重要。

在Flask中，我们通常使用Flask-Migrate来处理数据库迁移。Flask-Migrate是SQLAlchemy的一个Flask扩展，基于Alembic库，能够自动生成迁移脚本并进行应用。

安装Flask-Migrate

首先，确保我们已经安装了Flask-Migrate。我们可以通过pip安装：

1
pip install Flask-Migrate

配置Flask-Migrate

在我们的Flask项目中，我们需要进行一些配置。同时，假设你已经设置好了Flask和SQLAlchemy。

1
2
3
4
5
6
7
8
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db'
db = SQLAlchemy(app)
migrate = Migrate(app, db)

在这里，Migrate接受Flask应用和SQLAlchemy数据库实例，以便后续进行数据库迁移操作。

初始化迁移环境

首次对数据库进行迁移之前，我们需要初始化迁移环境。可以通过以下命令在命令行中完成：

1
flask db init

这将在项目目录中创建一个migrations文件夹，里面存放迁移脚本和配置。

创建迁移

现在我们可以进行初始的数据库迁移。假设我们有一个User模型，如下所示：

1
2
3
4
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(150), nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)

我们需要创建数据库并生成相应的迁移。我们可以运行命令：

1
flask db migrate -m "Initial migration"

这将会检测到User模型的变化并生成一个迁移脚本，记录下User表的创建。

应用迁移

在生成迁移脚本后，我们需要将这些变更应用到数据库中。我们运行以下命令：

1
flask db upgrade

这一步将会基于之前创建的迁移脚本更新数据库，一旦完成，User表就会在数据库中创建成功。

修改模型并进行迁移

假设我们决定在User模型中添加一个age字段。我们需要修改模型代码如下：

1
2
3
4
5
class User(db.Model):
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(150), nullable=False)
    email = db.Column(db.String(120), unique=True, nullable=False)
    age = db.Column(db.Integer, nullable=True)  # 新增的字段

此时，再次运行迁移命令：

1
flask db migrate -m "Add age field to User model"

随后，我们应用迁移：

1
flask db upgrade

这将会更新数据库，新增age字段。

查看迁移历史

如果想查看已执行的迁移历史，可以使用以下命令：

1
flask db history

这个命令会列出所有的迁移版本及信息。

回退迁移

如果我们发现某次迁移出现问题，Flask-Migrate也支持回退迁移。只需运行：

1
flask db downgrade -1

这会将最新的迁移回退一步。如果想要回退到特定的版本，可以使用版本号替代-1。

总结

在本篇教程中，我们学习了如何在Flask中设置和使用Flask-Migrate进行数据库迁移。这个过程确保了在对数据库结构进行更改时，我们的数据能够安全地迁移。在实际应用中，数据库架构的调整是非常常见的，熟练掌握数据库迁移可以大大提高我们的开发效率。

在下一节中，我们将讨论用户认证，具体集中在用户注册的实现。

希望你对本次的数据库迁移操作感到满意！如有任何疑问，随时可以提问。

分享转发

发表更新软件开发 / Flask从零教程7 分钟读完 (大约987个字)

20 用户注册

在本篇中，我们将讨论如何在 Flask 应用中实现用户注册功能。这个功能将以之前的数据库迁移为基础，我们也将为后续的用户登录功能做好准备。我们会通过实例进行讲解，以便于理解和应用。

环境准备

首先，确保你已经创建了一些必要的文件和目录，并且将 SQLAlchemy 和 Flask-Migrate 安装到你的虚拟环境中。如果你还没有设置这些，可以参照以下命令：

1
pip install Flask Flask-SQLAlchemy Flask-Migrate

创建用户模型

在之前的数据库迁移中，我们已经设置了 Flask 应用以及数据库配置。现在，我们将创建一个用户模型，以便存储用户的数据。

1
2
3
4
5
6
7
8
9
10
11
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

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

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

在上述代码中，我们定义了一个 User 类，它继承自 db.Model。此模型包含三个字段：

  • id: 用户的唯一标识。
  • username: 用户名，要求唯一且不能为空。
  • password_hash: 用于存储加密后的密码。

创建用户注册表单

接下来，我们将创建一个用于用户注册的表单。我们将使用 Flask-WTF 来简化表单处理。

首先，安装 Flask-WTF：

1
pip install Flask-WTF

然后，创建一个表单文件 forms.py：

1
2
3
4
5
6
7
8
9
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField
from wtforms.validators import DataRequired, EqualTo

class RegistrationForm(FlaskForm):
    username = StringField('Username', validators=[DataRequired()])
    password = PasswordField('Password', validators=[DataRequired()])
    confirm_password = PasswordField('Confirm Password', validators=[DataRequired(), EqualTo('password')])
    submit = SubmitField('Register')

在这个表单中，我们创建了三个字段：

  • username: 用户名，不能为空。
  • password: 密码，不能为空。
  • confirm_password: 确认密码，以确保用户输入相同的密码。

注册视图函数

现在，我们来实现用户注册的视图。我们将在 app.py 文件中添加注册处理逻辑。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
from flask import Flask, render_template, redirect, url_for, flash
from forms import RegistrationForm
from models import db, User
from werkzeug.security import generate_password_hash

app = Flask(__name__)
app.config['SECRET_KEY'] = 'your_secret_key'
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///site.db'
db.init_app(app)

@app.route('/register', methods=['GET', 'POST'])
def register():
    form = RegistrationForm()
    if form.validate_on_submit():
        hashed_password = generate_password_hash(form.password.data, method='sha256')
        new_user = User(username=form.username.data, password_hash=hashed_password)
        db.session.add(new_user)
        db.session.commit()
        flash('Registration successful! You can now log in.', 'success')
        return redirect(url_for('login'))  # 假设我们有一个登录视图
    return render_template('register.html', form=form)

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

在 register 视图中，我们首先实例化 RegistrationForm，然后检查表单是否通过验证。如果验证通过，使用 generate_password_hash 对用户的密码进行加密，并创建一个新用户对象。最后，将用户存入数据库，并重定向到登录页。

创建注册模板

最后，我们需要一个 HTML 模板来渲染注册表单。创建文件 register.html，并添加以下内容：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<!doctype html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Register</title>
</head>
<body>
    <h1>Register</h1>
    <form method="POST">
        {{ form.hidden_tag() }}
        <p>
            {{ form.username.label }}<br>
            {{ form.username(size=32) }}<br>
            {% for error in form.username.errors %}
                <span style="color: red;">[{{ error }}]</span>
            {% endfor %}
        </p>
        <p>
            {{ form.password.label }}<br>
            {{ form.password(size=32) }}<br>
            {% for error in form.password.errors %}
                <span style="color: red;">[{{ error }}]</span>
            {% endfor %}
        </p>
        <p>
            {{ form.confirm_password.label }}<br>
            {{ form.confirm_password(size=32) }}<br>
            {% for error in form.confirm_password.errors %}
                <span style="color: red;">[{{ error }}]</span>
            {% endfor %}
        </p>
        <p>{{ form.submit() }}</p>
    </form>
</body>
</html>

在这个模板中，我们使用了 Flask-WTF 提供的表单渲染，确保显示任何验证错误。

小结

在本篇中，我们完成了用户注册功能的实现。用户输入的密码会通过 SHA-256 算法进行加密，增强了安全性。用户注册后会被重定向到登录页面，接下来我们将在下篇中实现用户登录功能。

如果你有任何问题或需要更多帮助，请随时提问！

分享转发

发表更新软件开发 / Flask从零教程7 分钟读完 (大约1094个字)

21 用户认证之用户登录

在上一篇中，我们讨论了用户注册的过程，确保用户能够创建一个账户并将其信息存储在数据库中。现在，我们将继续这个主题，探讨用户登录的实现。这是用户认证中至关重要的部分，因为只有经过验证的用户才能访问系统的特定资源。

用户登录概述

用户登录流程的主要目的是让用户通过提供其凭据（如用户名和密码）来验证其身份。成功登录后，服务器会创建一个会话，通常使用Flask-Login扩展来管理用户会话和权限。

主要步骤

  1. 创建登录表单：构建用户登录的表单。
  2. 验证用户凭据：检查用户提供的凭据是否正确。
  3. 建立会话：一旦用户验证通过，创建用户会话。
  4. 处理登出：提供退出会话的功能。

一、创建登录表单

首先，我们需要创建一个登录表单。我们可以使用Flask-WTF扩展来简化表单的创建和验证。

以下是一个简单的登录表单示例：

1
2
3
4
5
6
7
8
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('登录')

二、验证用户凭据

接下来，我们需要编写一个视图函数来处理登录逻辑。我们将接收来自登录表单的请求，验证用户的凭据并在数据库中查找用户信息。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
from flask import Flask, render_template, redirect, url_for, flash
from flask_login import LoginManager, login_user
from yourdatabase import User  # 引入您的数据库模型
from yourforms import LoginForm

app = Flask(__name__)
login_manager = LoginManager(app)
login_manager.login_view = 'login'  # 当未认证用户试图访问受保护的路由时的重定向路由

@app.route('/login', methods=['GET', 'POST'])
def login():
    form = LoginForm()
    if form.validate_on_submit():
        user = User.query.filter_by(username=form.username.data).first()
        if user and user.verify_password(form.password.data):  # 假设您在 User 模型中实现了 verify_password 方法
            login_user(user)  # 使用 login_user 进行登录
            return redirect(url_for('index'))  # 登录成功重定向至首页
        else:
            flash('用户名或密码错误，请重试。')
    return render_template('login.html', form=form)

在上述代码中，我们首先创建一个登录路由，如果用户提交表单（validate_on_submit），我们会检查数据库中是否存在该用户以及密码是否正确。

三、建立会话

使用 Flask-Login 的 login_user 函数会创建一个用户会话，允许用户在后续请求中保持身份验证状态。Flask-Login 也负责管理用户的会话超时、持久化和其他相关功能。

1
2
3
4
5
6
7
8
9
from flask_login import UserMixin

class User(UserMixin, db.Model):  # 用户模型
    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(150), unique=True, nullable=False)
    password_hash = db.Column(db.String(128))

    def verify_password(self, password):
        return check_password_hash(self.password_hash, password)  # 你需要引入相应的函数来检查密码

四、处理登出

实现登出功能非常简单，我们可以定义一个登出路由来注销用户会话。

1
2
3
4
5
6
from flask_login import logout_user

@app.route('/logout')
def logout():
    logout_user()  # 登出用户
    return redirect(url_for('login'))  # 重定向至登录页面

总结

在这一部分中，我们实现了基本的用户登录功能，包括创建登录表单、验证用户凭据、建立用户会话及处理登出。本节的实现建立在用户注册的基础之上，下一篇将讨论管理用户权限的相关内容，以确保登录用户的权限控制。

通过将用户的登录逻辑与后续权限功能结合起来，我们可以构建出一个健全的用户认证系统。这是建立任何Web应用程序时不可或缺的一部分，确保用户数据的安全性和私密性。在实施这些功能时，还要注意安全性，使用户的密码和个人信息不被泄露。

请准备好进入下一篇，深入讨论用户权限的管理和控制。

分享转发

发表更新软件开发 / Flask从零教程8 分钟读完 (大约1162个字)

22 用户认证之用户权限

在上一篇文章中，我们介绍了用户登录的实现方式，讲解了如何使用 Flask 登录用户并管理用户会话。在这一篇中，我们将聚焦于用户权限认证的实现，确保我们的应用能够限制用户的访问范围，从而保护敏感数据和操作。

权限的概念

在任何Web应用程序中，权限控制是至关重要的。通过对不同用户角色和权限的管理，应用可以限制用户访问特定资源或执行特定操作。通常，一个用户可以拥有以下角色：

  • 管理员（Admin）：可以访问所有功能，包括用户管理。
  • 普通用户（User）：可以访问公共功能，但不能进行敏感操作。
  • 访客（Guest）：只读权限，不能进行任何更改。

权限模型实现

在 Flask 中，我们可以轻松地实现这样的权限模型。为此，我们通常需要以下几个步骤：

  1. 定义用户角色和权限。
  2. 在用户模型中添加角色字段。
  3. 创建权限检查装饰器。
  4. 保护视图函数。

步骤 1: 定义用户角色和权限

首先，我们可以在应用中定义一些常用的角色。这里我们采用简单的字符串来表示角色：

1
2
3
4
5
ROLES = {
    "ADMIN": "admin",
    "USER": "user",
    "GUEST": "guest"
}

步骤 2: 在用户模型中添加角色字段

接下来，我们需要在用户数据模型中添加一个 role 字段。在此示例中，我们使用 SQLAlchemy 来定义用户模型：

1
2
3
4
5
6
7
8
9
10
11
12
from flask_sqlalchemy import SQLAlchemy

db = SQLAlchemy()

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(200), nullable=False)
    role = db.Column(db.String(50), default=ROLES['USER'])  # 用户角色，默认为用户

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

步骤 3: 创建权限检查装饰器

为了方便地检查用户的权限，我们可以创建一个自定义的装饰器。这个装饰器将会验证当前登录用户是否有足够的权限来访问某个视图函数。

1
2
3
4
5
6
7
8
9
10
11
12
from functools import wraps
from flask import g, redirect, url_for

def role_required(role):
    def decorator(f):
        @wraps(f)
        def decorated_function(*args, **kwargs):
            if g.user.role != role:
                return redirect(url_for('unauthorized'))  # 如果没有权限，则重定向
            return f(*args, **kwargs)
        return decorated_function
    return decorator

步骤 4: 保护视图函数

一旦我们定义了权限装饰器，就可以在视图函数上使用它了。以下是如何使用 @role_required 装饰器限制某个视图只能由管理员访问：

1
2
3
4
5
6
7
8
@app.route('/admin')
@role_required(ROLES['ADMIN'])
def admin_dashboard():
    return "欢迎来到管理员面板"

@app.route('/unauthorized')
def unauthorized():
    return "您没有权限访问此页面", 403

所有没有管理员权限的用户访问 /admin 路由时都会被重定向到 /unauthorized 页面。

案例：综合应用

假设我们想建立一个简单的 Flask 应用，其中各类用户都有不同的权限。以下是一个完整的示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
from flask import Flask, g, redirect, url_for, render_template, request
from flask_sqlalchemy import SQLAlchemy
from flask_login import LoginManager, login_user, logout_user, UserMixin, login_required

app = Flask(__name__)
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///users.db'
app.secret_key = 'your_secret_key'
db = SQLAlchemy(app)
login_manager = LoginManager(app)

class User(UserMixin, db.Model):
    # 用户模型见前文
    ...

# 在此插入用户认证函数和权限装饰器

@login_manager.user_loader
def load_user(user_id):
    return User.query.get(int(user_id))

@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:  # 实际中使用加密的密码
            login_user(user)
            return redirect(url_for('admin_dashboard'))
    return render_template('login.html')

if __name__ == '__main__':
    db.create_all()
    app.run(debug=True)

这一完整的示例使我们能够创建用户，通过角色进行权限控制。注意，在实际项目中，强烈建议对密码进行加密处理，使用库如 werkzeug.security 来保证安全性。

结论

在本篇文章中，我们详细讨论了如何在 Flask 应用中实现用户权限认证。这包括定义用户角色、在数据库中添加相应字段、使用装饰器检查权限以及保护视图函数。接下来的文章我们将进一步探讨如何定义 RESTful API，以便为我们的用户提供更为灵活和现代化的接口。希望大家继续关注！

分享转发

发表更新软件开发 / Flask从零教程6 分钟读完 (大约971个字)

23 定义RESTful API

在本篇教程中，我们将深入探讨如何在Flask中定义RESTful API。这一点对于开发现代Web应用程序非常重要，因为RESTful API使得前后端分离成为可能，并且提供了一种标准化的方式来管理数据。

什么是RESTful API？

RESTful API是一种基于REST（Representational State Transfer）架构风格的API，它使用HTTP协议来操作资源。每个资源通过URI（统一资源标识符）来唯一标识，API用户可以使用HTTP方法（如GET、POST、PUT、DELETE）来对这些资源执行不同的操作。

设计API的基础

在设计RESTful API之前，我们需要明确几个关键概念：

  1. 资源：资源是我们API所管理的数据。在一个用户管理系统中，可能有用户、文章、评论等资源。例如，用户的URI可以是/users/{id}，文章的URI可以是/posts/{id}。

  2. HTTP方法：用于对资源执行操作的标准方法。

    • GET：获取资源
    • POST：创建新资源
    • PUT：更新现有资源
    • DELETE：删除资源

  3. 状态码：HTTP响应状态码用于指示请求的结果。例如：

    • 200 OK：请求成功
    • 201 Created：成功创建资源
    • 404 Not Found：请求的资源未找到
    • 500 Internal Server Error：服务器错误

示例：创建用户的RESTful API

下面我们将通过一个简单的例子来展示如何定义一个RESTful API来管理用户。

首先，我们需要安装Flask和Flask-RESTful库：

1
pip install Flask Flask-RESTful

接下来，我们创建一个简单的Flask应用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
from flask import Flask, jsonify, request
from flask_restful import Api, Resource

app = Flask(__name__)
api = Api(app)

# 示例数据：用户列表
users = []

class User(Resource):
    def get(self, user_id):
        """获取特定用户的信息"""
        user = next((user for user in users if user['id'] == user_id), None)
        if user:
            return jsonify(user)
        return jsonify({'message': 'User not found'}), 404

    def post(self):
        """创建新用户"""
        user = request.json
        user['id'] = len(users) + 1  # 简单的ID生成策略
        users.append(user)
        return jsonify({'message': 'User created', 'user': user}), 201

    def put(self, user_id):
        """更新特定用户的信息"""
        user = next((user for user in users if user['id'] == user_id), None)
        if user:
            updated_data = request.json
            user.update(updated_data)
            return jsonify({'message': 'User updated', 'user': user})
        return jsonify({'message': 'User not found'}), 404

    def delete(self, user_id):
        """删除特定用户"""
        global users
        users = [user for user in users if user['id'] != user_id]
        return jsonify({'message': 'User deleted'})

# 设置API路由
api.add_resource(User, '/users', '/users/<int:user_id>')

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

代码解析

  1. 我们首先创建了一个Flask应用和一个Flask-RESTful API实例。
  2. users列表用来保存用户数据。
  3. User类定义了各种HTTP方法，以操作用户资源：
    • get方法用于获取指定ID的用户信息。
    • post方法用于创建新用户，并返回新用户的信息及状态码201。
    • put方法用于更新用户信息。
    • delete方法用于删除指定用户。

测试API

我们可以使用工具如Postman或curl来测试创建、获取、更新和删除用户的API。例如：

  • 创建用户：
1
curl -X POST http://127.0.0.1:5000/users -H "Content-Type: application/json" -d '{"name": "John Doe", "email": "john@example.com"}'
  • 获取用户：
1
curl http://127.0.0.1:5000/users/1
  • 更新用户：
1
curl -X PUT http://127.0.0.1:5000/users/1 -H "Content-Type: application/json" -d '{"email": "john.doe@example.com"}'
  • 删除用户：
1
curl -X DELETE http://127.0.0.1:5000/users/1

小结

在这一节中，我们定义了一个基本的用户管理RESTful API，这为后续的用户认证和权限验证打下了基础。你可以根据业务需求扩展更多的资源和功能。

在下一篇中，我们将讨论RESTful API中的请求与响应，进一步优化我们的API设计和实现。

分享转发

发表更新软件开发 / Flask从零教程7 分钟读完 (大约989个字)

24 Flask RESTful API 请求与响应

在上一篇文章中，我们讨论了什么是 RESTful API 以及如何定义 API。本篇将更深入地探讨如何处理 HTTP 请求与响应，这是构建 RESTful API 的核心部分。我们将通过一个简单的示例来演示如何在 Flask 中处理请求和返回响应。

处理请求

在 Flask 中，处理 HTTP 请求非常简单。我们可以通过定义视图函数来接收不同的 HTTP 方法（如 GET、POST、PUT 和 DELETE）。使用 @app.route() 装饰器，我们可以将 URL 路径与相应的视图函数关联起来。

示例代码

让我们创建一个简单的 Flask 应用，处理关于书籍的 RESTful API。以下代码展示了如何创建一个简单的书籍存储服务，支持 GET 和 POST 请求。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
from flask import Flask, jsonify, request

app = Flask(__name__)

# 模拟数据库
books = []

@app.route('/books', methods=['GET'])
def get_books():
    return jsonify(books), 200

@app.route('/books', methods=['POST'])
def add_book():
    new_book = request.get_json()
    if not new_book or 'title' not in new_book or 'author' not in new_book:
        return jsonify({'error': 'Bad Request', 'message': 'Missing title or author'}), 400
    books.append(new_book)
    return jsonify(new_book), 201

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

代码讲解

  1. 获取书籍 (GET /books):

    • 当客户端发起 GET 请求时，get_books 视图函数会被调用，它返回包含所有书籍的 JSON 响应，状态码为 200。
    • 使用 jsonify 来生成响应，它会自动将 Python 字典转换为 JSON 格式。

  2. 添加新书 (POST /books):

    • 当客户端发送 POST 请求时，add_book 视图函数会被触发。我们使用 request.get_json() 来获取请求体中的 JSON 数据。
    • 代码检查请求体中是否包含 title 和 author 字段。如果缺少这些字段，则返回 400 Bad Request 响应。
    • 如果验证通过，则将新书加入 books 列表，并返回新书的 JSON 数据，状态为 201 Created。

处理响应

在处理响应时，Flask 允许我们灵活地设置返回的状态码和返回的内容。通常，一个良好的 RESTful API 应该保证返回适当的 HTTP 状态码，以便客户端知道请求是否成功。

状态码与响应示例

  • 成功响应:
    • 对于成功的 GET 或 POST 请求，我们通常返回 200 OK 或 201 Created。
  • 错误响应:
    • 如果客户端请求的资源不存在，返回 404 Not Found。
    • 对于不合法的请求参数，返回 400 Bad Request。

我们可以通过修改先前的代码来包含这些场景。

完整示例代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@app.route('/books/<int:book_id>', methods=['GET'])
def get_book(book_id):
    if 0 <= book_id < len(books):
        return jsonify(books[book_id]), 200
    else:
        return jsonify({'error': 'Not Found', 'message': 'Book does not exist'}), 404

@app.route('/books/<int:book_id>', methods=['DELETE'])
def delete_book(book_id):
    if 0 <= book_id < len(books):
        deleted_book = books.pop(book_id)
        return jsonify(deleted_book), 200
    else:
        return jsonify({'error': 'Not Found', 'message': 'Book does not exist'}), 404

解释新增内容

  1. 获取单本书籍 (GET /books/):

    • 根据传入的 book_id 返回特定的书籍，如果书籍不存在，则返回 404 Not Found 响应。

  2. 删除书籍 (DELETE /books/):

    • 该路由允许删除指定 ID 的书籍。如果 ID 有效，则从列表中移除相应的书籍并返回该书籍的 JSON 数据；如果无效，则返回 404 Not Found。

小结

在本篇教程中，我们深入探讨了 Flask 中 RESTful API 的请求与响应。我们学会了如何处理客户端发来的请求，如何返回合适的响应以及如何结合 HTTP 状态码来提高 API 的可用性。

在下一篇文章中，我们将讨论如何为 RESTful API 实施版本控制，从而确保 API 的向后兼容性及易于未来扩展。如果你对 API 的设计和实现有更多的好奇，欢迎继续跟随我们的系列教程！

分享转发

×