Flask 基础

Flask 基础详解：从入门到实践

1. Flask 简介与环境搭建

1.1 什么是 Flask？

Flask 被称为“微框架”，因为它只提供了 Web 应用开发的核心功能，如路由、请求处理、模板渲染等。它不像 Django 那样提供“一站式”解决方案，而是鼓励开发者选择自己需要的组件，具有更高的灵活性和自定义性。

1.2 为什么选择 Flask？

• 轻量级: Flask 代码库小巧，学习曲线平缓，容易上手。

• 灵活: Flask 核心功能简洁，易于扩展，可以根据项目需求选择合适的扩展库。

• 易于集成: Flask 可以轻松与其他 Python 库集成，如数据库 ORM、表单验证、安全组件等。

• 社区活跃: Flask 拥有庞大的社区支持，文档完善，遇到问题容易找到解决方案。

1.3 环境搭建

在开始 Flask 开发之前，我们需要搭建 Python 开发环境并安装 Flask。

步骤 1: 安装 Python

确保您的计算机上已经安装了 Python (建议 Python 3.7+)。您可以从 Python 官网 下载并安装。

步骤 2: 创建虚拟环境 (推荐)

为了隔离项目依赖，推荐使用虚拟环境。在项目目录下打开终端，执行以下命令：

# 创建虚拟环境 (venv 是虚拟环境名称，可以自定义)
python -m venv venv
# 激活虚拟环境 (不同操作系统命令不同)
# Windows:
venv\Scripts\activate
# macOS/Linux:
source venv/bin/activate
​

激活虚拟环境后，您会在终端提示符前看到 (venv) 字样，表示虚拟环境已激活。

步骤 3: 安装 Flask

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

pip install Flask
​

安装完成后，您就可以开始 Flask 开发了。

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

让我们从最简单的 "Hello, World!" 应用开始，了解 Flask 应用的基本结构。

代码示例 (app.py):

from flask import Flask
# 创建 Flask 应用实例
app = Flask(__name__)
# 定义路由和视图函数
@app.route('/')  # 根路径 '/'
def hello_world():
    return 'Hello, World!'
# 运行应用
if __name__ == '__main__':
    app.run(debug=True) # 开启调试模式
​

代码详解:

1. from flask import Flask: 导入 Flask 类。

2. app = Flask(__name__): 创建 Flask 应用实例。__name__ 参数用于指定应用模块的名称，Flask 会根据这个名称查找静态文件、模板文件等资源。

3. @app.route('/'): 使用 @app.route() 装饰器定义路由。这里将根路径 '/' 映射到 hello_world 函数。

4. def hello_world():: 定义视图函数 hello_world。当用户访问根路径时，Flask 会调用这个函数。

5. return 'Hello, World!': 视图函数返回一个字符串 'Hello, World!'，Flask 会将其作为 HTTP 响应返回给浏览器。

6. if __name__ == '__main__':: 这段代码确保应用只在直接运行时才执行 app.run()。

7. app.run(debug=True): 运行 Flask 开发服务器。debug=True 开启调试模式，方便开发时调试代码。

运行应用:

在终端中，确保您位于 app.py 文件所在的目录，并激活了虚拟环境，然后执行以下命令：

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: ...
​

这表示 Flask 开发服务器已经启动，并监听在 http://127.0.0.1:5000/ 地址。在浏览器中访问这个地址，您将看到 "Hello, World!" 的页面。

3. 路由与视图函数

路由是 Flask 应用的核心概念之一，它定义了 URL 路径与处理请求的函数（视图函数）之间的映射关系。

3.1 基本路由

我们已经看到了根路径的路由：@app.route('/')。我们可以定义更多的路由，例如：

@app.route('/about')
def about():
    return 'This is the about page.'
@app.route('/contact')
def contact():
    return 'Contact us here.'
​

现在，访问 /about 和 /contact 路径，您将看到相应的页面内容。

3.2 动态路由

有时候，我们需要在 URL 中传递参数。Flask 支持动态路由，可以使用尖括号 <> 定义 URL 变量。

@app.route('/user/<username>')
def show_user_profile(username):
    return f'User profile for: {username}'
@app.route('/post/<int:post_id>')
def show_post(post_id):
    return f'Post ID: {post_id}, type: {type(post_id)}'
​

代码详解:

• <username>: 定义一个名为 username 的 URL 变量，它会作为参数传递给 show_user_profile 函数。

• <int:post_id>: 定义一个名为 post_id 的 URL 变量，并指定类型为 int (整数)。Flask 会确保传入的参数是整数类型，否则会匹配失败。

示例访问:

• /user/john 会显示 "User profile for: john"

• /post/123 会显示 "Post ID: 123, type: <class 'int'>"

• /post/abc 会返回 404 Not Found，因为 abc 不是整数。

常用的类型转换器:

• string (默认): 接受任何不包含斜杠 / 的文本

• int: 接受整数

• float: 接受浮点数

• path: 接受包含斜杠 / 的文本 (常用于文件路径)

• uuid: 接受 UUID 字符串

3.3 HTTP 方法

默认情况下，路由只处理 GET 请求。如果需要处理其他 HTTP 方法 (如 POST, PUT, DELETE 等)，可以在 @app.route() 装饰器中指定 methods 参数。

from flask import request
@app.route('/login', methods=['GET', 'POST'])
def login():
    if request.method == 'POST':
        return 'Logged in successfully (POST)'
    else:
        return '''
            <form method="post">
                <p><input type=text name=username>
                <p><input type=password name=password>
                <p><input type=submit value=Login>
            </form>
        '''
​

代码详解:

• methods=['GET', 'POST']: 指定 /login 路由处理 GET 和 POST 请求。

• request.method: request 对象是 Flask 提供的一个全局对象，用于访问当前请求的信息。request.method 获取请求的 HTTP 方法。

• request.form: 如果请求是 POST 方法，并且 Content-Type 是 application/x-www-form-urlencoded 或 multipart/form-data，可以使用 request.form 访问表单数据 (字典类型)。

• request.args: 用于访问 URL 中的查询参数 (GET 请求参数，例如 ?name=value) (字典类型)。

• request.json: 用于访问请求体中的 JSON 数据 (如果 Content-Type 是 application/json)。

示例:

访问 /login 路径 (GET 请求) 会显示一个登录表单。提交表单 (POST 请求) 后，会显示 "Logged in successfully (POST)"。

4. 请求与响应

Flask 提供了 request 对象来处理客户端请求，并允许视图函数返回各种类型的响应。

4.1 请求对象 request

我们已经接触过 request.method，request.form，request.args。request 对象还包含其他有用的属性和方法，例如：

• request.url: 完整的请求 URL。

• request.path: 请求路径 (不包含域名和查询参数)。

• request.headers: 请求头 (字典类型)。

• request.cookies: 请求 Cookie (字典类型)。

• request.files: 上传的文件 (字典类型)。

• request.get_data(): 获取原始请求数据 (bytes 类型)。

• request.get_json(): 获取 JSON 请求数据 (如果 Content-Type 是 application/json)。

4.2 响应

视图函数可以返回多种类型的响应：

• 字符串: Flask 会将其作为 HTML 内容返回，默认 Content-Type 为 text/html; charset=utf-8。

• 元组: (response, status_code, headers) 或 (response, headers) 或 (response, status_code)。

  • response: 响应体 (字符串、bytes 或 Response 对象)。

  • status_code: HTTP 状态码 (整数，如 200, 404, 500)。

  • headers: 响应头 (字典类型)。

• Response 对象: 可以使用 flask.make_response() 或 flask.Response 类创建更灵活的响应对象，可以更精细地控制状态码、响应头、Cookie 等。

• 重定向: 使用 flask.redirect(location, status_code=302) 函数进行页面重定向。

• 中止请求: 使用 flask.abort(status_code) 函数返回特定状态码的 HTTP 错误响应 (例如 abort(404) 返回 404 Not Found)。

示例：自定义响应

from flask import make_response, jsonify, redirect, abort
@app.route('/custom_response')
def custom_response():
    response = make_response('<h2>Custom Response!</h2>')
    response.headers['X-Custom-Header'] = 'My Value'
    response.status_code = 202  # Accepted
    return response
@app.route('/json_response')
def json_response():
    data = {'message': 'Hello', 'status': 'success'}
    return jsonify(data) # 使用 jsonify 方便返回 JSON 响应
@app.route('/redirect_example')
def redirect_example():
    return redirect('/about', code=302) # 默认 302 临时重定向
@app.route('/abort_example/<int:user_id>')
def abort_example(user_id):
    if user_id != 123:
        abort(404) # 返回 404 Not Found 错误
    return f'User ID: {user_id} found!'
​

5. 模板渲染 (Jinja2)

Flask 使用 Jinja2 模板引擎来渲染动态 HTML 页面。模板允许我们将 HTML 代码和 Python 代码逻辑分离，使代码更清晰、易于维护。

5.1 创建模板文件

Flask 默认在 templates 文件夹下查找模板文件。在项目根目录下创建 templates 文件夹，并在其中创建一个 HTML 文件，例如 index.html。

示例模板 (templates/index.html):

<!DOCTYPE html>
<html>
<head>
    <title>{{ title }}</title>
</head>
<body>
    <h1>Hello, {{ name }}!</h1>
    <ul>
        {% for item in items %}
            <li>{{ item }}</li>
        {% endfor %}
    </ul>
</body>
</html>
​

代码详解:

• {{ title }}: Jinja2 变量，用双大括号 {{ }} 包裹。在渲染模板时，Flask 会将 title 变量的值替换到这里。

• {{ name }}: 另一个变量，用于显示用户名字。

• {% for item in items %}{% endfor %}: Jinja2 控制结构，用于循环。{% for ... %} 开始循环，{% endfor %} 结束循环。

• {{ item }}: 在循环中，访问每个 item 的值。

5.2 渲染模板

在视图函数中使用 flask.render_template() 函数渲染模板。

from flask import render_template
@app.route('/')
def index():
    user_data = {'name': 'Alice', 'items': ['apple', 'banana', 'cherry']}
    return render_template('index.html', title='My Home Page', **user_data)
​

代码详解:

• render_template('index.html', title='My Home Page', **user_data):

  • 第一个参数 'index.html' 是模板文件名。

  • 后续的参数是传递给模板的变量。title='My Home Page' 将变量 title 赋值为 'My Home Page'。

  • **user_data 使用字典解包，将 user_data 字典中的键值对作为变量传递给模板 (name='Alice', items=['apple', 'banana', 'cherry'])。

运行结果:

访问根路径 /，Flask 会渲染 templates/index.html 模板，并将 title, name, items 等变量替换到模板中，生成动态 HTML 页面。

5.3 模板继承

Jinja2 支持模板继承，可以创建基础模板 (layout) 并让其他模板继承，减少代码重复。

基础模板 (templates/layout.html):

<!DOCTYPE html>
<html>
<head>
    <title>{% block title %}Default Title{% endblock %}</title>
    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
</head>
<body>
    <nav>
        <a href="/">Home</a> | <a href="/about">About</a>
    </nav>
    <div class="content">
        {% block content %}
            <h1>Default Content</h1>
        {% endblock %}
    </div>
    <footer>
        <p>&copy; 2023 My Website</p>
    </footer>
</body>
</html>
​

子模板 (templates/index.html):

{% extends 'layout.html' %}
{% block title %}Home Page{% endblock %}
{% block content %}
    <h1>Welcome to the Home Page!</h1>
    <p>This is the main content of the home page.</p>
{% endblock %}
​

代码详解:

• {% extends 'layout.html' %}: 子模板 index.html 继承自 layout.html。

• {% block title %}{% endblock %} 和 {% block content %}{% endblock %}: 在基础模板 layout.html 中定义了名为 title 和 content 的 block (块)。

• 在子模板中重新定义 block: 子模板 index.html 通过 {% block title %} 和 {% block content %} 重新定义了这两个 block 的内容，会覆盖基础模板中的默认内容。

• {{ url_for('static', filename='style.css') }}: 使用 url_for() 函数生成静态文件 URL。这里用于引用 static 文件夹下的 style.css 文件。

6. 静态文件

静态文件是指不经常变化的文件，例如 CSS 文件、JavaScript 文件、图片等。Flask 默认在 static 文件夹下查找静态文件。

6.1 创建静态文件

在项目根目录下创建 static 文件夹，并在其中放置静态文件，例如 style.css。

示例 CSS 文件 (static/style.css):

body {
    font-family: sans-serif;
    margin: 20px;
}
nav {
    margin-bottom: 20px;
}
.content {
    padding: 20px;
    border: 1px solid #ccc;
}
​

6.2 引用静态文件

在模板中使用 url_for('static', filename='...') 函数生成静态文件 URL。

<link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
<img src="{{ url_for('static', filename='images/logo.png') }}" alt="Logo">
​

代码详解:

• url_for('static', filename='style.css'): 生成 static/style.css 文件的 URL。

• url_for('static', filename='images/logo.png'): 生成 static/images/logo.png 文件的 URL (假设 static 文件夹下有一个 images 子文件夹，里面有 logo.png 文件)。

Flask 会自动处理静态文件的访问，例如，如果 style.css 文件位于 static/style.css，那么可以通过 /static/style.css URL 访问它。

7. 总结与进阶

本文介绍了 Flask 的基础知识，包括环境搭建、第一个 Flask 应用、路由与视图函数、请求与响应、模板渲染和静态文件处理。通过这些基础知识，您可以构建简单的 Flask Web 应用。

进阶学习方向:

• 表单处理与验证: 使用 Flask-WTF 扩展处理表单数据和进行表单验证。

• 数据库集成: 使用 Flask-SQLAlchemy 或其他 ORM 库集成数据库。

• 用户认证与授权: 实现用户登录、注册、权限管理等功能。

• API 开发: 构建 RESTful API 服务。

• Flask 扩展: 学习和使用各种 Flask 扩展，扩展 Flask 的功能。

• 应用部署: 学习将 Flask 应用部署到生产环境 (例如使用 Gunicorn, uWSGI, Nginx 等)。

• 测试: 编写单元测试和集成测试，保证应用质量。

• 大型应用架构: 学习如何组织大型 Flask 应用，例如使用 Blueprints, 应用工厂模式等。

Flask 社区非常活跃，有丰富的文档和资源。建议您继续深入学习 Flask 官方文档和参考其他 Flask 教程和实践案例，不断提升 Flask 开发技能。

希望这篇文章能够帮助您入门 Flask 开发！