Flask Web 框架入门：从零开始构建你的第一个应用

欢迎来到 Web 开发的世界！如果你是一位 Python 开发者，并希望涉足 Web 应用的构建，那么 Flask 是一个极好的起点。它是一个轻量级的 Python Web 框架，以其简洁、灵活和易于上手而闻名。与功能齐全的大型框架（如 Django）不同，Flask 提供了构建 Web 应用所需的核心功能，但将许多决策权留给了开发者，允许你根据项目需求自由选择组件和工具。

本文将带你深入了解 Flask 的基础知识，从环境搭建到构建一个简单的实际应用。我们将覆盖 Flask 的核心概念，包括路由、视图函数、模板渲染、请求处理、静态文件服务等。准备好了吗？让我们开始 Flask 之旅！

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

什么是 Flask？

Flask 是一个用 Python 编写的微型 Web 框架。这里的“微型”并不意味着它的功能不足，而是指 Flask 的核心非常简洁，不包含数据库抽象层（ORM）、表单验证、认证系统等开箱即用的组件。这些功能通常作为扩展提供，开发者可以根据需要自由选择和集成。

为什么选择 Flask？

简洁与灵活: Flask 的 API 设计直观易懂，代码量少。它的核心只处理 Web 应用的基本需求（请求处理和响应生成）。这种简洁性带来了极大的灵活性，你可以轻松地将 Flask 集成到现有项目中，或者根据你的喜好选择最适合的数据库、模板引擎、认证方案等。
易于学习: 对于有 Python 基础的开发者来说，Flask 的学习曲线非常平缓。你可以很快地构建并运行一个简单的 Web 应用。
强大的扩展生态: 尽管核心小巧，Flask 拥有一个庞大且活跃的社区，提供了各种高质量的扩展，涵盖了从数据库集成到用户认证、RESTful API 构建等几乎所有方面。
适合多种项目: Flask 适合构建各种规模的项目，从简单的个人博客、API 服务到复杂的大型 Web 应用。它的灵活性使得它成为构建微服务的热门选择。
良好的文档: Flask 的官方文档非常清晰和详尽，是学习和使用的重要资源。

Flask 的核心依赖:

Flask 依赖于两个主要的外部库：

Werkzeug: 一个用于构建 WSGI（Web Server Gateway Interface）应用的工具集。WSGI 是 Python 定义的一种 Web 服务器与 Web 应用之间交互的接口标准。
Jinja2: 一个功能强大且易于使用的模板引擎，用于动态生成 HTML 页面。

Flask 的核心就是将 Werkzeug 和 Jinja2 巧妙地结合在一起，并提供了一套简洁的 API 来构建 Web 应用。

2. 环境搭建与安装

在开始之前，你需要确保你的计算机上已经安装了 Python。推荐使用 Python 3.6 或更高版本。

2.1 创建虚拟环境

在开发 Python 项目时，强烈推荐使用虚拟环境。虚拟环境可以为每个项目创建一个独立的 Python 环境，避免不同项目之间的库版本冲突。

在终端中，进入你的项目目录（如果还没有，先创建一个），然后执行以下命令创建虚拟环境：

“`bash

创建一个名为 .venv 的虚拟环境

python -m venv .venv
“`

创建完成后，你需要激活虚拟环境。命令因操作系统的不同而略有差异：

macOS / Linux:
bash source .venv/bin/activate
Windows (命令提示符 cmd):
bash .venv\Scripts\activate.bat
Windows (PowerShell):
bash .venv\Scripts\Activate.ps1

激活成功后，你的终端提示符前会显示虚拟环境的名称（例如 (.venv)），表示你当前正工作在虚拟环境中。

2.2 安装 Flask

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

bash pip install Flask

这条命令会自动安装 Flask 及其依赖库（包括 Werkzeug 和 Jinja2）。

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

现在，让我们来写一个最简单的 Flask 应用。

在你的项目目录中创建一个名为 app.py 的文件（或其他你喜欢的名字），并输入以下代码：

“`python

app.py

from flask import Flask

创建一个 Flask 应用实例

name 是一个特殊的 Python 变量，代表当前模块的名称。

Flask 使用它来确定应用根目录的位置，以便找到资源文件（如模板和静态文件）。

app = Flask(name)

使用装饰器定义一个路由

当用户访问应用的根 URL (/) 时，将调用下面的函数

@app.route(‘/’)
def hello_world():
# 函数返回的字符串将作为 HTTP 响应体发送给客户端
return ‘Hello, World! 这是我的第一个 Flask 应用！’

运行应用

确保这个脚本直接运行时才执行 app.run()

if name == ‘main‘:
# debug=True 模式开启调试功能，方便开发，但不要在生产环境使用
app.run(debug=True)
“`

代码解释:

from flask import Flask: 导入 Flask 类。
app = Flask(__name__): 创建一个 Flask 应用实例。__name__ 参数告诉 Flask 你的应用在哪里。
@app.route('/'): 这是一个装饰器，它将 URL / 映射到紧随其后的函数 hello_world。这意味着当用户通过浏览器访问应用的根 URL 时，Flask 会执行 hello_world() 函数。
def hello_world():: 这是一个视图函数。它负责处理来自特定 URL 的请求并返回响应。在这个例子中，它简单地返回一个字符串。
return 'Hello, World! ...': 视图函数返回的值就是发送给用户的 HTTP 响应体。Flask 会自动将其包装成一个完整的 HTTP 响应（默认状态码 200 OK，Content-Type 为 text/html）。
if __name__ == '__main__':: 这是一个标准的 Python 结构，确保 app.run() 只在直接运行 app.py 文件时执行，而不是在被导入为模块时执行。
app.run(debug=True): 启动 Flask 内置的开发服务器。debug=True 开启了调试模式。在调试模式下，服务器会在代码修改后自动重新加载，并在发生错误时提供一个交互式的调试器。注意：调试模式不应该在生产环境中使用！

运行你的应用:

在终端中，确保你处于虚拟环境并位于项目目录下，然后运行：

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)

打开你的 Web 浏览器，访问地址 http://127.0.0.1:5000/。你应该能看到页面上显示 “Hello, World! 这是我的第一个 Flask 应用！”。

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

4. 核心概念深入

现在我们已经构建了一个最简单的应用，接下来我们将详细介绍 Flask 的核心概念。

4.1 路由 (Routing)

路由是将 URL 映射到视图函数的机制。在 Flask 中，我们使用 @app.route() 装饰器来定义路由。

基本路由:

python @app.route('/about') def about(): return '这是一个关于页面'

访问 http://127.0.0.1:5000/about 将会显示 “这是一个关于页面”。

带变量的路由:

你可以在 URL 中定义变量部分，并在视图函数中捕获这些变量。

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

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

/user/<username>: <username> 是一个变量。当访问 /user/Alice 时，username 变量的值就是 "Alice"。
/post/<int:post_id>: <int:post_id> 定义了一个名为 post_id 的变量，并指定它的类型是 int（整数）。访问 /post/123 时，post_id 的值是整数 123。如果访问 /post/abc，Flask 会返回一个 404 Not Found 错误，因为 abc 不能转换为整数。

常见的变量类型转换器包括：

string: (默认) 接受任何不包含斜线的字符串。
int: 接受正整数。
float: 接受正浮点数。
path: 类似 string，但接受斜线。
uuid: 接受 UUID 字符串。

指定 HTTP 方法:

默认情况下，路由只响应 GET 请求。你可以通过 methods 参数指定允许的 HTTP 方法，例如 GET, POST, PUT, DELETE 等。

python @app.route('/login', methods=['GET', 'POST']) def login(): if request.method == 'POST': # 处理 POST 请求的登录逻辑 return '处理登录请求' else: # 处理 GET 请求，显示登录表单 return '显示登录表单'

这里使用了 request 对象，我们将在后面详细介绍。

4.2 视图函数 (View Functions)

视图函数是处理特定 URL 请求的 Python 函数。它们接收来自客户端的请求，执行必要的逻辑（如查询数据库、处理数据等），然后返回一个响应。

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

字符串: 最简单的方式，返回的字符串会作为响应体。Flask 会设置 Content-Type 为 text/html。
元组: (response, status_code, headers) 或 (response, status_code) 或 (response, headers)。这提供了更多控制权。
- response: 响应体，可以是字符串、字节串、文件对象等。
- status_code: HTTP 状态码（如 200, 404, 500）。
- headers: 字典或列表的元组，包含额外的响应头。
  python @app.route('/custom_response') def custom_response(): # 返回一个 JSON 格式的字符串，状态码 201 Created，并指定 Content-Type return '{"message": "Created"}', 201, {'Content-Type': 'application/json'}
  对于 JSON 响应，Flask 提供了一个方便的 jsonify 函数：
  “`python
  from flask import jsonify
@app.route(‘/json_example’)
def json_example():
data = {“name”: “Alice”, “age”: 30}
return jsonify(data) # 会自动设置 Content-Type 为 application/json
3. **Response 对象:** 更高级的方式，你可以直接创建 `Response` 对象并返回。python
from flask import Response

@app.route(‘/raw_response’)
def raw_response():
resp = Response(“Hello from a Response object!”, status=200, mimetype=’text/plain’)
resp.headers[‘X-Custom-Header’] = ‘Flask is awesome’
return resp
“`

4.3 模板渲染 (Template Rendering)

直接在 Python 代码中生成 HTML 字符串非常繁琐，特别是对于复杂的页面。 Flask 使用 Jinja2 模板引擎来解决这个问题。模板是包含静态 HTML 结构和动态内容占位符的文本文件。

启用模板:

在你的项目根目录创建一个名为 templates 的文件夹。
在 templates 文件夹中创建一个 HTML 文件，例如 index.html。
在你的视图函数中导入 render_template 函数。

示例:

templates/index.html:

“`html

欢迎, {{ name }}!

这是你的第一个使用 Flask 模板渲染的页面。

{% if users %}

用户列表:

{{ user }}

{% endfor %}

{% else %}

没有用户。

{% endif %}

“`

app.py:

“`python
from flask import Flask, render_template

app = Flask(name)

@app.route(‘/’)
def index():
# 准备一些数据传递给模板
title = “主页”
username = “访客”
user_list = [“Alice”, “Bob”, “Charlie”]

# 使用 render_template 函数渲染模板
# 第一个参数是模板文件名 (相对于 templates 文件夹)
# 后续参数是将要传递给模板的变量 (关键字参数)
return render_template('index.html', page_title=title, name=username, users=user_list)

@app.route(‘/no_users’)
def no_users():
return render_template(‘index.html’, page_title=”无用户”, name=”管理员”, users=[])

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

Jinja2 语法简介:

{{ variable }}: 用于输出变量的值。
{% statement %}: 用于控制结构，如 if 条件判断、for 循环等。
{# comment #}: 模板注释，不会输出到最终的 HTML。

通过 render_template('index.html', ...)，我们将 Python 变量 title, username, user_list 传递给了 index.html 模板，在模板中可以通过 page_title, name, users 访问它们。

访问 http://127.0.0.1:5000/，你会看到根据 index.html 模板和传递的数据生成的动态页面。访问 http://127.0.0.1:5000/no_users 会显示没有用户的版本。

模板继承 (Template Inheritance):

对于有共同结构（如头部、尾部、导航栏）的页面，可以使用模板继承来避免重复代码。

创建 templates/base.html:

“`html

{% block title %}{% endblock %} – 我的应用

我的应用

{% block content %}{% endblock %}

“`

创建 templates/index.html (继承 base.html):

“`html
{% extends ‘base.html’ %}

{% block title %}主页{% endblock %}

{% block content %}

欢迎使用 Flask 应用!

这是一个继承自 base.html 的页面。

{% endblock %}
“`

在继承模板中：

{% extends 'base.html' %}: 指定该模板继承自 base.html。这必须是模板文件中的第一行。
{% block block_name %} 和 {% endblock %}: 定义一个块。子模板可以覆盖父模板中同名块的内容。父模板中的块提供了默认内容（如果子模板没有覆盖）。

这样，你就可以在 base.html 中定义通用的页面结构，然后在其他模板中只填写特定页面的内容块。

4.4 请求对象 (Request Object)

当客户端发送请求到 Flask 应用时，所有请求相关的信息都被封装在一个全局的 request 对象中。你需要从 flask 模块导入 request 来使用它。

“`python
from flask import Flask, request, render_template

app = Flask(name)

@app.route(‘/submit_form’, methods=[‘GET’, ‘POST’])
def submit_form():
if request.method == ‘POST’:
# 处理 POST 请求
# 访问表单数据
name = request.form.get(‘name’) # 获取表单字段 ‘name’ 的值
age = request.form.get(‘age’) # 获取表单字段 ‘age’ 的值
# 如果字段不存在，get() 方法返回 None，form[‘name’] 会抛出 KeyError

    # 你也可以访问 URL 中的查询参数 (Query String Parameters)
    #例如访问 /submit_form?id=123
    user_id = request.args.get('id')

    # 访问请求头部信息
    user_agent = request.headers.get('User-Agent')

    # 访问上传的文件
    # uploaded_file = request.files['myfile']

    return f'收到了 POST 请求。<br>姓名: {name}, 年龄: {age}<br>用户ID (from query): {user_id}<br>User-Agent: {user_agent}'
else:
    # 处理 GET 请求，显示表单
    return '''
        <form method="post">
            姓名: <input type="text" name="name"><br>
            年龄: <input type="text" name="age"><br>
            <input type="submit" value="提交">
        </form>
    '''

如果你想从模板中提交表单到这个路由，可以创建一个简单的模板文件

templates/form.html

姓名:

年龄:

然后在 GET 分支中返回 render_template(‘form.html’)

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

request 对象的重要属性和方法：

request.method: 当前请求的 HTTP 方法 (e.g., ‘GET’, ‘POST’).
request.form: 一个字典，包含 POST 请求的表单数据（Content-Type 为 application/x-www-form-urlencoded 或 multipart/form-data）。通常用于处理 HTML 表单提交。
request.args: 一个字典，包含 URL 中的查询参数（例如 /search?q=python 中的 q=python）。
request.values: 结合了 form 和 args。
request.json: 如果请求的 Content-Type 是 application/json，这个属性包含解析后的 JSON 数据。
request.files: 一个字典，包含上传的文件。
request.headers: 一个字典，包含请求头部信息。
request.cookies: 一个字典，包含请求中的 cookie。
request.url: 完整的请求 URL。
request.path: 请求路径部分 (不包含域名和查询参数)。

4.5 URL 构建 (URL Building)

硬编码 URL 是一个不好的习惯。如果将来某个路由的 URL 发生变化，你需要手动修改所有引用了该 URL 的地方。Flask 提供了 url_for() 函数来动态生成 URL。

url_for() 函数接收视图函数的名称作为第一个参数，以及视图函数所需的任何可变规则作为关键字参数。

示例:

假设你有以下路由：

“`python
@app.route(‘/’)
def index():
pass # …

@app.route(‘/user/‘)
def show_user_profile(username):
pass # …

@app.route(‘/post/‘)
def show_post(post_id):
pass # …
“`

你可以这样使用 url_for():

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

app = Flask(name)

@app.route(‘/’)
def index():
# 生成到 index 视图函数的 URL (即 ‘/’)
home_url = url_for(‘index’)
# 生成到 show_user_profile 视图函数的 URL，需要传递 username 参数
user_url = url_for(‘show_user_profile’, username=’Alice’)
# 生成到 show_post 视图函数的 URL，需要传递 post_id 参数
post_url = url_for(‘show_post’, post_id=123)

return f'主页 URL: {home_url}<br>爱丽丝的资料页 URL: {user_url}<br>文章 ID 123 的 URL: {post_url}'

@app.route(‘/user/‘)
def show_user_profile(username):
return f’用户: {username}’

@app.route(‘/post/‘)
def show_post(post_id):
return f’文章 ID: {post_id}’

另一个例子: 重定向到某个 URL

@app.route(‘/old_page’)
def old_page():
# 重定向到新的主页
return redirect(url_for(‘index’))

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

url_for() 的优点:

避免硬编码: 当 URL 规则改变时，你只需要修改 @app.route() 装饰器，而不需要修改 url_for() 调用。
处理特殊字符: url_for() 会自动为你处理 URL 中的特殊字符编码。
处理变量规则: 可以方便地生成带有动态参数的 URL。
生成静态文件 URL: 后面会讲到，它也用于生成静态文件的 URL。

4.6 静态文件 (Static Files)

Web 应用通常需要提供静态文件，如 CSS 样式表、JavaScript 脚本、图片等。Flask 会自动处理静态文件的服务。

约定:

在你的项目根目录创建一个名为 static 的文件夹。将你的 CSS、JS、图片文件放在这个文件夹或其子文件夹中。

在模板中引用静态文件:

在你的模板文件（如 base.html 或 index.html）中，使用 url_for() 函数来生成静态文件的 URL。

“`html

“`

url_for('static', filename='...') 会生成指向 static 文件夹下的文件的 URL。例如，如果你的应用运行在 http://127.0.0.1:5000，url_for('static', filename='css/style.css') 可能会生成 /static/css/style.css。

你需要确保在项目结构中有相应的静态文件：

your-project/ ├── app.py ├── templates/ │ ├── base.html │ └── index.html └── static/ ├── css/ │ └── style.css ├── js/ │ └── script.js └── images/ └── logo.png

Flask 内置的开发服务器会自动为你处理 /static/ URL 的请求，并在 static 文件夹中查找对应的文件。

4.7 调试模式与运行方式

前面我们使用了 app.run(debug=True) 来运行应用。虽然方便，但在现代 Flask 版本中，官方更推荐使用 flask 命令行工具来运行开发服务器。

使用 flask run:

在你的 app.py 文件中，确保你有一个名为 app 的 Flask 实例。
在终端中，确保你处于虚拟环境并位于项目目录下。
设置 FLASK_APP 环境变量指向你的应用文件（通常是 app.py 的文件名）。
- macOS / Linux:
  bash export FLASK_APP=app
- Windows (命令提示符 cmd):
  bash set FLASK_APP=app
- Windows (PowerShell):
  bash $env:FLASK_APP = "app"
（可选）设置 FLASK_ENV 环境变量为 development 以启用调试模式。
- macOS / Linux:
  bash export FLASK_ENV=development
- Windows (命令提示符 cmd):
  bash set FLASK_ENV=development
- Windows (PowerShell):
  bash $env:FLASK_ENV = "development"
运行 flask run 命令：
bash flask run

这会启动开发服务器，并且当 FLASK_ENV 设置为 development 时，会自动启用调试功能（代码修改自动重载、交互式调试器等）。

FLASK_ENV=development vs debug=True:

FLASK_ENV=development 是更现代、更全面的开发模式开启方式。它不仅开启了调试器和自动重载，还会做一些其他适合开发环境的配置（例如，错误页面更详细）。debug=True 主要是开启了调试器和自动重载。在新的 Flask 版本中，推荐使用 FLASK_ENV 来管理开发/生产环境。

调试器:

当在调试模式下应用发生错误时，浏览器会显示一个交互式的调试器页面。你可以查看错误的堆栈跟踪，并且可以在每一帧（函数调用）中打开一个 Python 控制台，检查变量的值，甚至执行 Python 代码。这是排查问题非常有用的工具。

5. 构建一个简单的 To-Do 应用 (内存版)

现在让我们将上述概念整合起来，构建一个简单的 To-Do 列表应用。为了简化，任务数据将存储在内存中，应用停止时数据会丢失。

项目结构:

todo-app/ ├── app.py └── templates/ ├── index.html └── add_task.html

app.py:

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

app = Flask(name)

内存中的任务列表

tasks = [] # 存储字符串格式的任务描述

@app.route(‘/’)
def index():
# 显示所有任务
return render_template(‘index.html’, tasks=tasks)

@app.route(‘/add’, methods=[‘GET’, ‘POST’])
def add_task():
if request.method == ‘POST’:
# 处理添加任务的 POST 请求
task_content = request.form.get(‘content’)
if task_content: # 确保任务内容不为空
tasks.append(task_content)
# 重定向回主页，避免用户刷新页面时重复提交
return redirect(url_for(‘index’))
else:
# 可以添加错误处理，这里简化只返回提示
return “任务内容不能为空！返回”
else:
# 显示添加任务的表单页面
return render_template(‘add_task.html’)

(可选) 添加删除任务的路由

@app.route(‘/delete/‘)
def delete_task(task_id):
# 注意: 这种删除方式在多用户环境下有问题，且依赖列表索引，如果任务顺序变动或删除其他任务会出错
# 仅作为演示目的
try:
if 0 <= task_id < len(tasks):
del tasks[task_id]
except IndexError:
# 任务索引不存在，忽略或返回错误
pass # 这里简单忽略

return redirect(url_for('index'))

if name == ‘main‘:
# 推荐使用 flask run 命令代替 app.run()
# 但是为了这个独立文件示例方便，我们保留它
app.run(debug=True)
“`

templates/index.html:

“`html

To-Do 列表

我的 To-Do 列表

添加新任务

{% if tasks %}

{{ loop.index }}. {{ task }}
{# loop.index 是 Jinja2 在循环中提供的当前循环次数，从 1 开始 #}
{# 添加删除链接，使用任务索引作为参数 #}
[删除]
{# loop.index0 是从 0 开始的索引 #}

{% endfor %}

{% else %}

当前没有任务。

{% endif %}

“`

templates/add_task.html:

“`html

添加任务

添加新任务

返回任务列表

“`

运行 To-Do 应用:

确保你的虚拟环境已激活。
创建上述文件和目录结构。
运行 python app.py (或者设置 FLASK_APP=app 并运行 flask run).
访问 http://127.0.0.1:5000/。

这个简单的应用演示了：

路由定义: / 和 /add 路由。
视图函数: index 和 add_task。
模板渲染: 使用 render_template 显示任务列表和表单。
请求处理: 在 add_task 中根据 request.method 处理 GET 和 POST 请求，并使用 request.form 获取表单数据。
URL 构建: 使用 url_for 生成内部链接，包括带参数的 /delete/<task_id> 链接。
重定向: 使用 redirect 函数在添加任务成功后跳转回主页，避免重复提交。

6. Flask 扩展 (Extensions)

虽然 Flask 核心很小，但其强大的扩展生态系统弥补了这一点。扩展是第三方库，它们与 Flask 集成，提供了各种常用的功能。你可以通过 pip install Flask-Extension-Name 来安装它们。

一些常用的 Flask 扩展：

Flask-SQLAlchemy: 集成 SQLAlchemy ORM，方便进行数据库操作。
Flask-WTF: 集成 WTForms，简化表单的定义、渲染和验证。
Flask-Migrate: 集成 Alembic，用于数据库模式迁移。
Flask-Login: 处理用户会话管理和认证。
Flask-RESTful / Flask-RESTX: 帮助构建 RESTful API。
Flask-Mail: 发送电子邮件。
Flask-Bootstrap: 集成 Bootstrap 前端框架，方便创建美观的界面。

使用扩展通常涉及安装扩展、在应用中初始化扩展，然后按照扩展的文档使用其提供的功能。

7. 简单提一下部署

Flask 内置的开发服务器（app.run() 或 flask run）仅适用于开发和测试。它不够健壮，无法处理大量并发请求，也不提供生产环境所需的安全性和性能特性。

在生产环境中部署 Flask 应用，你需要使用一个生产级的 WSGI 服务器，例如：

Gunicorn: (Green Unicorn)
uWSGI:

这些服务器会运行你的 Flask 应用（一个 WSGI 应用），并处理来自客户端的实际 HTTP 请求。通常，在 WSGI 服务器前面还会放置一个反向代理服务器（如 Nginx 或 Apache），用于处理静态文件、SSL 加密、负载均衡等。

部署是一个相对复杂的话题，超出了本文入门的范围，但了解你需要一个生产服务器来运行 Flask 应用是重要的第一步。

8. 为什么选择 Flask？再回顾一下

到此为止，你应该对 Flask 的核心有了基本的了解。回顾一下为什么选择 Flask：

Pythonic: Flask 的设计非常符合 Python 的习惯，代码直观易读。
微框架哲学: 它提供核心，让你自由选择其他组件。这使得 Flask 成为学习 Web 开发原理的好工具，因为你需要自己理解每个部分如何工作和集成。它也非常适合构建轻量级服务或只需要特定功能的项目。
高度灵活: 你可以使用任何数据库、模板引擎（尽管 Jinja2 是默认且推荐的）、认证方案等。
强大的生态: 丰富的扩展库可以帮你轻松添加各种高级功能。
优秀的文档和社区: 遇到问题时很容易找到帮助。

当然，Flask 并非适用于所有情况。对于需要大量开箱即用功能的复杂大型项目，像 Django 这样的全功能框架可能会更高效。但对于许多项目，或者当你希望对技术栈有更多控制权时，Flask 是一个极具吸引力的选择。

9. 总结与下一步

本文带你从零开始了解了 Flask，包括：

Flask 是什么及其优势。
如何搭建环境和安装 Flask。
构建并运行第一个 “Hello, World!” 应用。
核心概念：路由、视图函数、模板渲染、请求对象、URL 构建、静态文件服务。
使用 flask run 进行开发。
一个简单的 To-Do 应用示例。
Flask 的扩展生态和生产部署的简单概念。

这只是 Flask 世界的冰山一角。要进一步提升你的 Flask 技能，建议你：

练习: 多动手编写 Flask 应用，尝试实现不同的功能。
深入学习核心概念: 阅读 Flask 官方文档中关于请求上下文、应用上下文、信号、蓝图 (Blueprints) 等更高级主题的部分。蓝图对于构建大型应用组织代码结构非常重要。
探索扩展: 尝试使用一些常用的 Flask 扩展，如 Flask-SQLAlchemy 和 Flask-WTF，将数据库和表单处理集成到你的应用中。
阅读源码: 如果你对 Flask 的内部工作原理感到好奇，可以阅读它的源代码。
参与社区: 在 Stack Overflow 或其他论坛上提问或帮助他人。

Flask 是一个强大而优雅的工具，它可以帮助你快速有效地构建各种 Web 应用。通过持续学习和实践，你将能够充分发挥它的潜力。

祝你在 Flask 开发的道路上一切顺利！

Flask Web 框架入门：从零开始构建你的第一个应用

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

2. 环境搭建与安装

创建一个名为 .venv 的虚拟环境

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

app.py

创建一个 Flask 应用实例

name 是一个特殊的 Python 变量，代表当前模块的名称。

Flask 使用它来确定应用根目录的位置，以便找到资源文件（如模板和静态文件）。

使用装饰器定义一个路由

当用户访问应用的根 URL (/) 时，将调用下面的函数

运行应用

确保这个脚本直接运行时才执行 app.run()

4. 核心概念深入

4.1 路由 (Routing)

4.2 视图函数 (View Functions)

4.3 模板渲染 (Template Rendering)

欢迎, {{ name }}!

用户列表:

欢迎使用 Flask 应用!

4.4 请求对象 (Request Object)

如果你想从模板中提交表单到这个路由，可以创建一个简单的模板文件

templates/form.html

姓名:

年龄:

然后在 GET 分支中返回 render_template(‘form.html’)

4.5 URL 构建 (URL Building)

另一个例子: 重定向到某个 URL

4.6 静态文件 (Static Files)

4.7 调试模式与运行方式

5. 构建一个简单的 To-Do 应用 (内存版)

内存中的任务列表

(可选) 添加删除任务的路由

我的 To-Do 列表

添加新任务

6. Flask 扩展 (Extensions)

7. 简单提一下部署

8. 为什么选择 Flask？再回顾一下

9. 总结与下一步

发表评论 取消回复

发表评论取消回复