Flask 3 保姆级教程（一）：快速上手

一、创建项目

PyCharm 中新建项目

创建完成后会出现这么个项目

以下是代码解析：

# 导入了 Flask 类
from flask import Flask

# 创建了一个 Flask web 应用的实例，并将其赋值给变量 app
# __name__ 是一个特殊的 Python 变量，它表示当前模块的名字。在大多数情况下，如果你直接运行这个脚本，__name__ 的值会是 '__main__'
# 传递 __name__ 给 Flask 的构造函数有助于 Flask 找到在哪里查找模板、静态文件等
app = Flask(__name__)


# 这是一个装饰器，它告诉 Flask 当用户访问应用的根 URL（例如 http://localhost:5000/）时，应该调用哪个函数来处理这个请求
@app.route('/')
# 定义函数，当 Flask 收到一个与 @app.route('/') 装饰器关联的 URL 请求时，它会调用这个函数
def hello_world():
    return 'Hello World!'


if __name__ == '__main__':
    # 如果脚本是作为主程序运行（即 __name__ 的值是 '__main__'），那么这行代码会启动 Flask 的开发服务器，并监听默认的端口（通常是 5000）
    app.run()

运行脚本：

二、开启调试模式

为什么要开启调试模式

1. 如果开启了DEBUG模式，那么在代码中如果抛出了异常，在浏览器的页面中可以看到具体的错误信息，以及具体的错误代码位置。方便开发者调试。

2. 如果开启了DEBUG模式，那么以后在`Python'代码中修改了任何代码，只要按`ctrl+s``flask`就会自动的重新记载整个网站。不需要手动点击重新运行。

PyCharm 中开启 Debug 模式：

三、设置局域网内公开访问

开启这个选项后，所处同一局域网内的主机都能访问本机的项目

四、修改端口

如图

五、路由

5.1 添加路由

使用 route() 装饰器来把函数绑定到 URL：

from flask import Flask


app = Flask(__name__)


@app.route('/')
def index():
    return '关注博主'


@app.route('/hello')
def hello_world():
    return 'Hello World'


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

5.2 路由变量名规则

通过把 URL 的一部分标记为 <variable_name> 就可以在 URL 中添加变量。标记的部分会作为关键字参数传递给函数

通过使用 <converter:variable_name> ，可以选择性的加上一个转换器，为变量指定规则

from flask import Flask


app = Flask(__name__)


@app.route('/')
def index():
    return '关注博主'


# string（默认值）接受任何不包含斜杠的文本
@app.route('/hello')
def hello_world():
    return 'Hello World'


# int 接受正整数
@app.route('/post/<int:post_id>')
def show_post(post_id):
    return f'Post {post_id}'


# float 接受正浮点数
@app.route('/get/<float:get_id>')
def show_get(get_id):
    return f'Get {get_id}'


# path 类似 string ，但可以包含斜杠
@app.route('/path/<path:subpath>')
def show_subpath(subpath):
    return f'Subpath {subpath}'


# uuid 接受 UUID 字符串


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

5.3 使用函数构建 URL

url_for函数用于生成URL。它可以接受一个视图函数的名称作为参数，并返回与该视图函数关联的URL

from flask import Flask, url_for

app = Flask(__name__)


@app.route('/')
def index():
    return 'Hello, Flask!'


@app.route('/user/<username>')
def user_profile(username):
    return f'Profile page of {username}'


@app.route('/post/<int:post_id>')
def show_post(post_id):
    return f'Post {post_id}'


@app.route('/login')
def login():
    return 'Login page'


# 创建一个测试请求上下文
# 测试请求上下文是为了模拟应用程序处理请求时的上下文环境。它允许我们在没有实际请求的情况下测试和调试路由函数的逻辑
with app.test_request_context():
    print(url_for('index'))  # 输出：/
    print(url_for('user_profile', username='john'))  # 输出：/user/john
    print(url_for('show_post', post_id=1))  # 输出：/post/1
    print(url_for('login'))  # 输出：/login

在上面的例子中，我们定义了几个路由函数，每个函数都有一个唯一的名称。通过url_for函数，我们可以根据这些函数的名称生成对应的URL

5.4 HTTP 方法

默认情况下，一个路由只回应 GET 请求。可以使用 route() 装饰器的 methods 参数来处理不同的 HTTP 方法

from flask import Flask
from flask import request

app = Flask(__name__)

@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        # 处理POST请求的逻辑
        return 'Login success!'
    else:
        # 处理GET请求的逻辑
        return 'Please login'

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

上例中把路由的所有方法都放在同一个函数中，当每个方法都使用一些共同的数据时，这样是有用的

六、静态文件

Flask 也能做好这项工作。只要在您的包或模块旁边创建一个名为 static 的文件夹就行了。静态文件位于应用的 /static 中

from flask import Flask, url_for

app = Flask(__name__)


@app.route('/')
def index():
    html_url = url_for('static', filename='index.html')
    return f'<a href="{html_url}">点击链接跳转</a>'


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

七、渲染模板

使用 render_template() 方法可以渲染模板，您只要提供模板名称和需要作为参数传递给模板的变量就行了

注意：Flask 会在 templates 文件夹内寻找模板

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <h1>{{ name }}</h1>
    <h2>{{ age }}</h2>
    <h3>{{ sex }}</h3>
</body>
</html>

from flask import Flask
from flask import render_template

app = Flask(__name__)


@app.route('/')
def index():
    return render_template('index.html', name='Morant', age=19, sex='男')


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

八、请求数据

8.1 请求对象

首先，确保已经安装了Flask-WTF扩展包，它用于处理表单数据。可以使用pip install Flask-WTF进行安装

通过使用 method 属性可以操作当前请求方法，通过使用 form 属性处理表单数据（在 POST 或者 PUT 请求中传输的数据）

<!DOCTYPE html>
<html lang="en">
<head>
    <title>Flask Form</title>
</head>
<body>
    <h1>Flask Form Example</h1>
    <form method="POST" action="/">
        {{ form.csrf_token }}
        {#    一行代码用于渲染表单对象的name字段及其对应的标签。form.name.label表示name字段的标签，form.name表示name字段的输入框。
        通过这个语法，模板引擎会将标签和输入框的HTML代码渲染到页面中，并在它们之间添加冒号进行分隔    #}
        {{ form.name.label }}: {{ form.name }}
        {{ form.submit }}
    </form>
</body>
</html>

from flask import Flask, render_template, request
from flask_wtf import FlaskForm
from wtforms import StringField, SubmitField

app = Flask(__name__)

# 设置了一个秘密密钥（SECRET_KEY）。秘密密钥是用于保护表单数据的重要配置
app.config['SECRET_KEY'] = 'secret_key'


# 继承自 FlaskForm 类
# FlaskForm类是wtforms库中Form类的子类，它扩展了Form类的功能，使其与Flask框架更好地集成
class MyForm(FlaskForm):
    # 创建一个名为Name的文本输入字段
    # 如果在HTML模板中使用{{ form.name.label }}来渲染该字段的标签，那么在浏览器中将显示一个带有文本Name的标签
    name = StringField('Name')

    # 创建一个标签为Submit的提交按钮字段
    # 在HTML模板中，可以使用{{ form.submit }}来渲染该字段，该字段将在浏览器中显示为一个提交按钮，文本为Submit
    submit = SubmitField('Submit')


@app.route('/', methods=['GET', 'POST'])
def index():
    form = MyForm()

    # validate_on_submit方法的作用是在表单提交的情况下进行验证
    if form.validate_on_submit():
        name = form.name.data
        return f'Hello, {name}!'

    # 这行代码将表单对象传递给模板，将模板渲染为最终的HTML响应，并将其返回给客户端
    return render_template('index.html', form=form)


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

8.2 文件上传

用 Flask 处理文件上传很容易，只要确保不要忘记在您的 HTML 表单中设置 enctype="multipart/form-data" 属性就可以了

补充知识点：

request.files是Flask框架中的一个特殊字典，用于存储通过表单上传的文件。它允许您在处理HTTP请求时访问上传的文件

当使用enctype="multipart/form-data"属性将表单的编码类型设置为多部分表单时，Flask将自动解析请求中的文件数据，并将它们存储在request.files字典中

request.files是一个可迭代的字典，其中键是表单中文件输入字段的名称，值是对应的文件对象。您可以通过键访问特定的文件对象，例如request.files['file']将返回名为file的文件对象

每个文件对象都有一些有用的属性，例如filename表示上传文件的原始文件名，stream表示文件的字节流，content_type表示文件的MIME类型等

<!DOCTYPE html>
<html>
<head>
    <title>File Upload</title>
</head>
<body>
    <h1>File Upload</h1>
    <form action="/upload" method="POST" enctype="multipart/form-data">
        <input type="file" name="file">
        <input type="submit" value="Upload">
    </form>
</body>
</html>

from flask import Flask, render_template, request
from werkzeug.utils import secure_filename
import os

app = Flask(__name__)


@app.route('/')
def index():
    # 渲染模板
    return render_template('index.html')


@app.route('/upload', methods=['POST'])
def upload_file():
    # 检查请求中是否存在名为file的文件。它通过查看request.files字典来检查文件是否存在
    if 'file' not in request.files:
        return 'No file uploaded', 400

    file = request.files['file']

    if file.filename == '':
        return 'No file selected', 400

    if file:
        # secure_filename()函数是Flask框架中的一个实用函数，用于将文件名转换为安全的文件名格式
        filename = secure_filename(filename)
        # 使用file.save()方法将文件保存到服务器上的指定目录中
        file.save(os.path.join('uploads', filename))
        return 'File uploaded successfully'

    return 'File upload failed', 500


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

8.3 Cookie

要访问 cookies ，可以使用 cookies 属性。可以使用响应对象的 set_cookie 方法来设置 cookies

from flask import Flask, request, make_response

app = Flask(__name__)


@app.route('/')
def index():
    # make_response('Cookie has been set!')是Flask框架中用于创建响应对象的函数
    # 它接受一个参数作为响应的内容，并返回一个包含该内容的响应对象
    # make_response('Cookie has been set!')创建了一个响应对象，响应的内容是字符串'Cookie has been set!'
    # 这个响应对象将被返回给客户端，作为对请求的响应
    resp = make_response('Cookie has been set!')
    # 设置 Cookie
    # 它接受两个参数，第一个参数是cookie的名称，第二个参数是cookie的值
    resp.set_cookie('username', 'Morant')
    return resp


@app.route('/get_cookie')
def get_cookie():
    # 从请求中获取cookie
    username = request.cookies.get('username')
    return f'Username: {username}'


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

九、重定向和错误

使用redirect()函数可以重定向。使用 abort() 可以更早退出请求，并返回错误代码

使用 erroehander() 装饰器可以定制出错页面

<!DOCTYPE html>
<html lang="en">
<head>
    <title>File Upload</title>
</head>
<body>
    <h1>重定向和自定义错误</h1>
</body>
</html>

from flask import Flask, redirect, url_for, abort, render_template

app = Flask(__name__)


@app.route('/')
def index():
    # 重定向到另一个路由
    return redirect(url_for('hello'))


@app.route('/hello')
def hello():
    try:
        # 当num为0时，中止请求并返回状态码为400的错误响应
        num = 0
        result = 10 / num
        return f'10 divided by {num} is {result}'
    except ZeroDivisionError:
        # 捕获ZeroDivisionError异常并返回自定义的错误页面
        # 在这个例子中，return abort(400)会中止当前请求，并返回状态码为400的错误响应
        return abort(400)


# errorhandler(400)是Flask框架中用于处理指定状态码错误的装饰器
# 在这个例子中，@app.errorhandler(400)装饰器将下面的bad_request函数注册为处理状态码为400的错误的函数
@app.errorhandler(400)
# # 在这个例子中，bad_request函数会渲染一个名为index.html的模板，并返回该模板的响应。同时，使用状态码400来表示该响应
def bad_request(error):
    # 自定义400错误页面
    return render_template('index.html'), 400


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

十、响应

在Flask中，当视图函数返回一个值时，它会自动转换为一个响应对象，用于向客户端返回数据。根据返回值的不同类型，会有不同的转换规则：

1. 如果返回值是一个响应对象，那么它会直接被返回。
2. 如果返回值是一个字符串，那么它会被转换为一个带有默认参数的响应对象，包含该字符串作为响应主体，状态码为 200 OK，并且内容类型为text/html。
3. 如果返回值是一个迭代器或生成器，那么它会被视为一个流式响应，将字符串或字节逐步返回给客户端。
4. 如果返回值是一个字典或列表，Flask会调用`jsonify()`函数来创建一个响应对象，将字典或列表转换为JSON格式。
5. 如果返回值是一个元组，那么元组中的项目可以提供额外的信息。元组必须至少包含一个项目，可以是`(response, status)`、`(response, headers)`或`(response, status, headers)`形式。其中，status的值会覆盖默认的状态码，headers是一个包含额外头部值的列表或字典。
6. 如果以上规则都不适用，Flask会假设返回值是一个有效的WSGI应用程序，并将其转换为一个响应对象。

如果想在视图函数内部对响应对象进行更精细的控制，可以使用`make_response()`函数来创建响应对象，并对其进行设置。

10.1 返回响应对象

在这个例子中，视图函数response使用make_response()函数创建了一个自定义的响应对象resp。然后，它将该响应对象直接返回给客户端，Flask会将其发送给客户端作为响应

from flask import Flask, make_response

app = Flask(__name__)


@app.route('/')
def response():
    # 创建自定义响应对象
    resp = make_response('Hello, Flask!')
    resp.headers['Content-Type'] = 'text/plain'
    resp.status_code = 200
    return resp


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

10.2 返回字符串

当访问根目录/时，视图函数hello返回一个字符串"Hello, Flask!"

Flask会自动将该字符串转换为一个响应对象，状态码为200 OK，内容类型为text/html，并将该字符串作为响应主体返回给客户端

from flask import Flask

app = Flask(__name__)


@app.route('/')
def hello():
    return "Hello, Flask!"


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

10.3 返回迭代器或生成器

在这个例子中，视图函数stream返回一个迭代器/生成器generate。这个生成器通过使用yield关键字逐步生成响应的字符串内容。Flask会将每个生成的字符串立即发送给客户端，使得响应成为一个流式响应

from flask import Flask

app = Flask(__name__)


@app.route('/')
def stream():
    def generate():
        yield 'Hello,'
        yield 'Flask!'

    return generate()


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

注意，生成器函数在第一次迭代时从函数体的开始处执行，然后在遇到第一个 yield 时暂停。在后续的迭代中，它从上一次暂停的 yield 语句之后继续执行，直到遇到下一个 yield，或者函数结束

10.4 返回字典或列表

当访问根目录/时，视图函数data返回一个字典{'name': 'John', 'age': 25}。Flask会自动调用jsonify()函数将字典转换为JSON格式，并创建一个响应对象来返回给客户端

from flask import Flask, jsonify

app = Flask(__name__)


@app.route('/')
def data():
    return {'name': 'John', 'age': 25}


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

10.5 返回元组

当访问根目录/时，视图函数response返回一个元组('Hello, Flask!', 201)。元组中的第一个项目是响应主体，第二个项目是状态码。Flask会根据这个元组创建一个响应对象，并将其返回给客户端

from flask import Flask

app = Flask(__name__)


@app.route('/')
def response():
    return 'Hello, Flask!', 201


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

10.6 使用 make_response() 函数

当访问根目录/时，视图函数response使用make_response()函数创建一个响应对象，并对其进行设置。在这个例子中，我们手动设置了响应主体、内容类型和状态码，并将该响应对象返回给客户端

from flask import Flask, make_response

app = Flask(__name__)


@app.route('/')
def response():
    resp = make_response('Hello, Flask!')
    resp.headers['Content-Type'] = 'text/plain'
    resp.status_code = 200
    return resp


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

10.7 使用 jsonify() 函数

当视图函数返回一个字典或列表时，可以使用jsonify()函数将其转换为JSON格式，并创建一个响应对象返回给客户端。下面是一个使用jsonify()函数的案例：

from flask import Flask, jsonify

app = Flask(__name__)


@app.route('/')
def data():
    data = {'name': 'John', 'age': 25}
    return jsonify(data)


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

十一、会话

使用会话之前您必须设置一个密钥

from flask import Flask, session, redirect, url_for

app = Flask(__name__)
app.secret_key = 'your_secret_key'


@app.route('/')
def index():
    session['username'] = 'Morant'
    return 'Session is set!'


@app.route('/profile')
def profile():
    if 'username' in session:
        return f"Welcome, {session['username']}!"
    else:
        return redirect(url_for('index'))


@app.route('/logout')
def logout():
    session.pop('username', None)
    return 'Logged out!'


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

在这个例子中，我们首先设置了一个密钥secret_key，用于加密会话数据。然后，当访问根目录/时，视图函数index将用户名John存储在会话中的username键中。

接下来，当访问/profile时，视图函数profile将检查会话中是否存在username键。如果存在，它会欢迎用户，并显示用户名。否则，它会重定向到index视图函数来设置会话。

最后，当访问/logout时，视图函数logout会从会话中删除username键，以模拟用户注销操作。

通过使用会话，我们可以在不同的请求之间存储和访问数据，以实现用户认证、保持登录状态等功能。

十二、闪现消息

flash()函数用于在视图函数中闪现一条消息，这条消息可以在后续的请求中被读取和显示

而get_flashed_messages()函数用于在模板中获取并操作这些消息

<!DOCTYPE html>
<html lang="en">
<head>
    <title>File Upload</title>
</head>
<body>
    <h1>Profile</h1>
    {% for message in messages %}
        <p>{{ message }}</p>
    {% endfor %}
</body>
</html>

from flask import Flask, flash, redirect, render_template, url_for, get_flashed_messages

app = Flask(__name__)
app.secret_key = 'your_secret_key'


@app.route('/')
def index():
    flash('This is a flashed message!')
    return redirect(url_for('profile'))


@app.route('/profile')
def profile():
    messages = get_flashed_messages()
    return render_template('index.html', messages=messages)


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

在这个例子中，当访问根目录/时，视图函数index使用flash()函数来闪现一条消息，然后它会重定向到profile视图函数

在profile视图函数中，使用get_flashed_messages()函数来获取闪现的消息，然后将这些消息传递给模板profile.html进行显示

在模板profile.html中，可以使用Jinja2的模板语法来遍历并显示消息

十三、日志

在这个例子中，我们定义了一个根路由/，当访问该路由时，会记录不同级别的日志信息。

通过app.logger.debug()、app.logger.info()、app.logger.warning()和app.logger.error()函数，我们可以分别记录调试、信息、警告和错误级别的日志信息

from flask import Flask

app = Flask(__name__)

@app.route('/')
def index():
    app.logger.debug('This is a debug message')
    app.logger.info('This is an info message')
    app.logger.warning('This is a warning message')
    app.logger.error('This is an error message')
    return 'Logged messages'

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