Python Web框架选择指南：Django、Flask与FastAPI核心对比与实战

如果你刚开始学习 Python Web 开发，面对 Django、Flask 和 FastAPI 这三个名字，大概率会陷入选择困难：我该从哪个开始？哪个“最好”？哪个学了能找到工作？

网上很多文章会告诉你：Django 大而全，Flask 小而美，FastAPI 性能高。但这只是标签，对新手做决策帮助有限。标签背后，是三种截然不同的开发哲学和适用场景。选错框架，可能意味着你要花大量时间学习用不上的功能，或者在项目后期才发现框架根本撑不起你的需求。

这篇文章不会简单罗列三个框架的优缺点。我会从一个更实际的角度出发：根据你想做什么、你现在是谁，以及你未来想成为谁，来帮你做出选择。我们将深入每个框架的“基因”，看它们如何塑造了不同的项目形态、团队协作方式和职业路径。更重要的是，我会用可运行的代码示例，带你快速体验每个框架的“核心开发感觉”，让你在动手之后，真正明白哪个更适合你。

1. 这篇文章真正要解决的问题：如何根据你的目标选择 Web 框架？

选择 Web 框架，本质上是选择一套约束和一套工具。这个选择，至少影响你接下来几个月的开发体验，甚至影响项目的成败。

为什么这个问题如此重要？因为 Python 的这三个主流 Web 框架，代表了三种不同的“预设答案”。Django 假设你需要一个完整的、开箱即用的 CMS 或管理后台；Flask 假设你只需要一个轻量的 HTTP 路由核心，其他自己组装；FastAPI 则假设你正在构建一个对性能、API 文档和类型安全有要求的现代后端服务。

很多新手会犯一个错误：听说某个框架“火”或者“性能强”，就盲目选择。结果可能是，你想快速做个博客，却用 FastAPI 从零开始折腾用户认证和后台管理；或者，你想做一个高性能的微服务 API，却选择了 Django，然后为它的“重”而苦恼。

本文要帮你理清的核心判断是：

• Django：你的目标是快速构建一个功能完整、包含后台管理的 Web 应用（如内容管理系统、电商平台、社交网站）。你愿意接受框架的“约定大于配置”，以换取极高的开发效率。
• Flask：你的目标是学习 Web 开发原理，或者构建一个高度定制化、架构由你完全掌控的应用。你享受“自己造轮子”的过程，或者项目本身非常简单。
• FastAPI：你的目标是构建一个高性能的、面向现代前端（如 Vue/React）或移动端的 API 服务。你重视开发体验、自动生成的 API 文档，并且希望利用 Python 的类型提示来减少错误。

接下来，我们将深入每个框架，从核心概念到一行代码，让你看清它们的真实面貌。

2. 基础概念与核心原理：三种哲学，三条道路

在深入代码之前，理解每个框架的设计哲学至关重要。这决定了你使用它时的“思维方式”。

2.1 Django： “全功能电池”的哲学

Django 信奉“开箱即用”。它提供了一个完整的、高度集成的解决方案，包含了 Web 开发中绝大多数常用组件：对象关系映射（ORM）、用户认证系统、后台管理界面、表单处理、缓存、国际化等。它采用MTV（Model-Template-View）模式，这是一种对经典 MVC 的变体。

• Model： 定义数据结构，与数据库交互。Django ORM 非常强大，你几乎不用写原生 SQL。
• Template： 负责渲染前端 HTML 页面。
• View： 处理业务逻辑，作为 Model 和 Template 之间的桥梁。

Django 的核心是“约定大于配置”。它有一套默认的项目结构、命名规则和工作流程。你遵循它，就能获得极高的开发效率；你想挑战它，就会感到处处掣肘。它适合构建“传统”的、以内容为核心的 Web 应用。

2.2 Flask： “微内核”的哲学

Flask 的核心极其轻量，它只提供了路由、请求/响应上下文和模板引擎等最基础的功能。其他一切——数据库ORM、表单验证、用户认证——都需要通过扩展（Extension）来添加。Flask 采用了一种“显式优于隐式”的设计。

• 核心微小： 一个简单的 Flask 应用可能只有几十行代码。
• 高度灵活： 你可以自由选择数据库工具（SQLAlchemy, Peewee）、认证库、甚至异步框架。
• 架构自由： 没有强制的项目结构，你可以按自己喜欢的方式组织代码。

Flask 适合那些清楚自己需要什么，并且愿意（或需要）自己动手组装的开发者。它是学习 Web 原理的绝佳工具，也是构建轻量级 API 或定制化程度极高的应用的利器。

2.3 FastAPI： “现代 API 优先”的哲学

FastAPI 是一个相对较新的框架，它建立在 Starlette（一个高性能异步框架）和 Pydantic（一个基于 Python 类型提示的数据验证库）之上。它的设计目标非常明确：快速构建高性能的 API，并提供卓越的开发者体验。

• 基于 Python 类型提示： 你可以用 Python 原生的类型注解来定义请求和响应的数据结构，FastAPI 会自动进行数据验证、序列化和生成 OpenAPI 文档。
• 原生异步支持： 内置对async/await语法的支持，可以轻松处理高并发 I/O 操作。
• 自动交互式 API 文档： 运行后自动生成 Swagger UI 和 ReDoc 文档，前端开发者可以立即查看和测试接口。

FastAPI 的哲学是“声明式”和“开发者友好”。它假设你正在构建一个前后端分离的现代应用，后端的主要职责是提供清晰、健壮、高性能的 API。

为了更直观地对比，我们看下表：

3. 环境准备与前置条件

在开始编写代码之前，我们需要一个干净的 Python 环境。强烈建议使用虚拟环境来隔离不同项目的依赖。

3.1 创建并激活虚拟环境

你可以使用venv（Python 3.3+ 内置）或conda。这里以venv为例：

# 1. 为我们的对比项目创建一个新目录并进入 mkdir python-web-frameworks-demo && cd python-web-frameworks-demo # 2. 创建虚拟环境，环境文件夹名为 `venv` python -m venv venv # 3. 激活虚拟环境 # 在 Windows 上： venv\Scripts\activate # 在 macOS/Linux 上： source venv/bin/activate # 激活后，命令行提示符前通常会显示 `(venv)`

3.2 安装框架核心包

我们将分别安装三个框架。你可以一次性安装，但为了环境清晰，建议按需安装。

# 安装 Django pip install django # 安装 Flask pip install flask # 安装 FastAPI 以及用于运行它的 ASGI 服务器 Uvicorn pip install fastapi uvicorn # 安装完成后，可以查看版本 pip show django flask fastapi

现在，环境已经就绪。让我们通过最经典的 “Hello, World!” 来感受三个框架最基础的写法。

4. 核心流程拆解：从“Hello World”看框架差异

一个最简单的 Web 应用核心流程是：接收一个 HTTP 请求，然后返回一个 HTTP 响应。我们来看看三个框架如何实现这个流程。

4.1 Flask：极简主义的典范

Flask 的实现是最直观的。创建一个 Python 文件，几行代码就能跑起来。

步骤 1：创建应用实例

# hello_flask.py from flask import Flask app = Flask(__name__) # 创建 Flask 应用实例

__name__参数帮助 Flask 确定应用的位置，用于定位静态文件等资源。

步骤 2：定义路由和视图函数

@app.route('/') # 使用装饰器将 URL 路径 '/' 与下面的函数绑定 def hello_world(): return 'Hello, World from Flask!'

在 Flask 中，一个函数处理一个（或一类）请求，这个函数被称为“视图函数”。@app.route()装饰器建立了 URL 规则和视图函数的映射关系。

步骤 3：启动开发服务器

if __name__ == '__main__': app.run(debug=True) # 启动内置的开发服务器，debug模式便于调试

将上述代码保存为hello_flask.py，然后在命令行运行：

python hello_flask.py

访问http://127.0.0.1:5000，你就能看到 “Hello, World from Flask!”。

Flask 的核心感觉：直接、明了。你清楚地知道请求从哪里来（路由），到哪里去（视图函数），响应是什么（return 语句）。这种透明感是 Flask 最大的魅力之一。

4.2 Django：结构化的起点

Django 强调项目结构。即使是 “Hello World”，也需要遵循它的组织方式。

步骤 1：创建 Django 项目Django 项目是一个包含多个应用的容器。

django-admin startproject hello_django . # 注意最后的 `.`，表示在当前目录创建项目

这条命令会生成一个标准的 Django 项目结构，包含manage.py（项目管理脚本）和hello_django/目录（项目配置）。

步骤 2：创建一个 Django 应用在 Django 中，功能被组织成一个个“应用”（app）。我们创建一个名为greeting的应用。

python manage.py startapp greeting

这会生成greeting/目录，里面包含了模型（models.py）、视图（views.py）等文件。

步骤 3：编写视图（View）打开greeting/views.py：

# greeting/views.py from django.http import HttpResponse def hello_world(request): # 视图函数必须接收一个 request 参数 return HttpResponse("Hello, World from Django!")

步骤 4：配置 URL 路由Django 的 URL 配置是集中式的。首先在应用 (greeting) 内创建urls.py：

# greeting/urls.py from django.urls import path from . import views # 从当前目录导入 views 模块 urlpatterns = [ path('', views.hello_world, name='hello'), # 将根路径映射到 hello_world 视图 ]

然后，需要将这个应用的 URL 配置包含到项目的总路由中。修改hello_django/urls.py：

# hello_django/urls.py from django.contrib import admin from django.urls import path, include # 导入 include urlpatterns = [ path('admin/', admin.site.urls), path('', include('greeting.urls')), # 包含 greeting 应用的 URLs ]

步骤 5：运行开发服务器

python manage.py runserver

访问http://127.0.0.1:8000，看到 “Hello, World from Django!”。

Django 的核心感觉：规范、有组织。即使是一个简单的功能，也被放在了预设好的结构里（项目→应用→视图→URL配置）。这种结构在小型项目中可能显得繁琐，但在大型项目中是维持秩序的关键。

4.3 FastAPI：声明式的现代 API

FastAPI 的写法很像 Flask，但融入了现代 Python 特性。

步骤 1：创建应用实例

# hello_fastapi.py from fastapi import FastAPI app = FastAPI() # 创建 FastAPI 应用实例

步骤 2：定义路径操作（Path Operation）

@app.get("/") # 使用装饰器，并明确指定 HTTP 方法为 GET async def hello_world(): # 可以使用普通的同步函数，也支持 async def return {"message": "Hello, World from FastAPI!"}

注意，我们返回了一个 Python 字典。FastAPI 会自动将其转换为 JSON 格式的响应，并设置正确的Content-Type: application/json头。

步骤 3：启动 ASGI 服务器FastAPI 本身只是一个框架，需要 ASGI 服务器来运行。我们使用安装好的 Uvicorn。

uvicorn hello_fastapi:app --reload # `hello_fastapi` 是文件名（不含.py） # `app` 是文件中的 FastAPI 实例变量名 # `--reload` 表示代码修改后自动重启，仅用于开发

访问http://127.0.0.1:8000，你会看到一个 JSON 响应：{"message":"Hello, World from FastAPI!"}。

更酷的是：访问http://127.0.0.1:8000/docs，你会看到一个完整的、可交互的 Swagger UI API 文档！这是 FastAPI 自动为你生成的。

FastAPI 的核心感觉：高效、现代、开发者友好。通过类型提示，它让 API 的输入输出变得清晰且安全，并免费赠送了高质量的交互式文档。异步支持让它天生适合 I/O 密集型任务。

5. 完整示例与代码实现：构建一个简单的用户查询 API

“Hello World” 过于简单。让我们用一个更实际的例子来对比：构建一个/users/{user_id}的 GET 接口，根据用户 ID 返回用户信息（模拟从数据库查询）。

我们将看到三个框架在处理路由参数、数据验证和响应方面的不同。

5.1 Flask 实现

Flask 需要手动从请求上下文中获取路径参数，并进行类型转换和错误处理。

# flask_user_api.py from flask import Flask, jsonify, abort app = Flask(__name__) # 模拟一个“数据库” fake_db = { 1: {"id": 1, "name": "Alice", "email": "alice@example.com"}, 2: {"id": 2, "name": "Bob", "email": "bob@example.com"}, } @app.route('/users/<int:user_id>', methods=['GET']) def get_user(user_id): """ 根据用户ID获取用户信息 :param user_id: 路径中的用户ID，Flask会尝试转换为int """ user = fake_db.get(user_id) if user is None: # 手动返回404错误和JSON响应 abort(404, description=f"User with id {user_id} not found") return jsonify(user) # 使用jsonify帮助构建JSON响应 if __name__ == '__main__': app.run(debug=True)

关键点分析：

• 路由定义<int:user_id>中的int是转换器，Flask 会尝试将路径参数转换为整数，如果失败会返回 404。
• 需要手动检查用户是否存在，并调用abort()返回错误。
• jsonify()函数将字典转换为带有正确 HTTP 头的 JSON 响应。

运行与测试：

python flask_user_api.py # 测试有效请求 curl http://127.0.0.1:5000/users/1 # 测试无效请求 curl -v http://127.0.0.1:5000/users/999

5.2 Django 实现

Django 的实现涉及视图、URL 配置，并且通常使用更“正式”的序列化方式（虽然简单情况下可以直接用JsonResponse）。

步骤 1：在greeting应用中创建新视图

# greeting/views.py (追加内容) from django.http import JsonResponse, Http404 def get_user(request, user_id): """ 根据用户ID获取用户信息 """ fake_db = { 1: {"id": 1, "name": "Alice", "email": "alice@example.com"}, 2: {"id": 2, "name": "Bob", "email": "bob@example.com"}, } try: user = fake_db[user_id] except KeyError: raise Http404(f"User with id {user_id} not found") return JsonResponse(user)

步骤 2：配置 URL 路由修改greeting/urls.py：

# greeting/urls.py from django.urls import path from . import views urlpatterns = [ path('', views.hello_world, name='hello'), path('users/<int:user_id>/', views.get_user, name='get_user'), # 注意路径结尾的 `/` ]

Django 的路径转换器<int:user_id>与 Flask 类似。

步骤 3：运行测试确保项目运行在http://127.0.0.1:8000。

# 测试有效请求 curl http://127.0.0.1:8000/users/1/ # 测试无效请求 curl -v http://127.0.0.1:8000/users/999/

Django 的特点：流程清晰但步骤较多。错误处理通过抛出Http404异常，Django 会将其转换为标准的 404 页面（在 API 场景下可能需要定制）。返回 JSON 需要使用JsonResponse。

5.3 FastAPI 实现

FastAPI 的写法非常简洁，并且充分利用了类型提示。

# fastapi_user_api.py from fastapi import FastAPI, HTTPException from pydantic import BaseModel from typing import Optional app = FastAPI() # 使用 Pydantic 模型定义响应的数据结构 class UserOut(BaseModel): id: int name: str email: str # 模拟数据库 fake_db = { 1: {"id": 1, "name": "Alice", "email": "alice@example.com"}, 2: {"id": 2, "name": "Bob", "email": "bob@example.com"}, } @app.get("/users/{user_id}", response_model=UserOut) async def get_user(user_id: int): # 类型提示：user_id 必须是 int """ 根据用户ID获取用户信息。 - **user_id**: 用户唯一标识符 """ user = fake_db.get(user_id) if user is None: # 抛出 HTTPException，FastAPI 会将其转换为对应的 JSON 错误响应 raise HTTPException(status_code=404, detail=f"User with id {user_id} not found") return user if __name__ == "__main__": import uvicorn uvicorn.run(app, host="0.0.0.0", port=8000)

关键点分析：

1. 路径参数与类型验证：在函数参数中直接声明user_id: int。FastAPI 会自动从路径中提取user_id并尝试转换为整数。如果客户端传入abc，FastAPI 会自动返回一个包含详细错误信息的 422 响应。
2. 响应模型：response_model=UserOut告诉 FastAPI，这个接口的返回值应该符合UserOut这个 Pydantic 模型。FastAPI 会用这个模型来：
   • 验证你的返回数据（确保有id,name,email字段且类型正确）。
   • 序列化数据为 JSON。
   • 在自动生成的 API 文档中清晰地展示响应的数据结构。
3. 错误处理：使用HTTPException，非常直观。
4. 交互式文档：运行后访问/docs，你会看到这个接口的完整描述，包括参数类型、响应模型，并且可以直接在浏览器里点击“Try it out”进行测试！

运行与测试：

uvicorn fastapi_user_api:app --reload # 测试有效请求 curl http://127.0.0.1:8000/users/1 # 测试类型错误请求（FastAPI 自动处理验证） curl -v http://127.0.0.1:8000/users/abc # 测试资源不存在 curl -v http://127.0.0.1:8000/users/999

对比小结：

• Flask：需要手动处理参数转换和错误响应，灵活但代码量稍多。
• Django：流程规范，适合集成在大型的 MTV 项目中，但为纯 API 服务时部分功能显得冗余。
• FastAPI：声明式写法，代码最简洁，自动化的验证、序列化和文档生成是巨大优势，尤其适合前后端协作。

6. 运行结果与效果验证

通过上面的示例，我们已经看到了运行结果。这里我们重点对比一下三个框架在开发体验和产出物上的不同，这往往是选择框架时更重要的考量。

6.1 开发服务器与热重载

• Flask/Django：使用内置的同步开发服务器（如app.run()或runserver），支持热重载（修改代码后自动重启），调试信息直观。
• FastAPI：需要使用外部 ASGI 服务器（如 Uvicorn、Hypercorn）。uvicorn --reload同样提供热重载。由于基于异步，在高并发模拟下表现更好。

6.2 API 文档

• Flask：无内置文档。需要集成flasgger、flask-restx或flask-apispec等扩展来生成 Swagger 文档。
• Django：无内置 API 文档。通常使用django-rest-framework(DRF) 来构建 API，DRF 自带可浏览的 API 和简单的文档。纯 Django 需要额外工具。
• FastAPI：开箱即用的自动交互式文档（Swagger UI 和 ReDoc）。这是 FastAPI 的杀手锏之一，极大提升了前后端联调效率。

6.3 数据验证与序列化

• Flask：需要手动验证请求数据（如使用request.get_json()然后检查字段），手动序列化响应数据（jsonify）。灵活性高，但容易写出冗余和不一致的代码。
• Django：对于 API，通常使用 DRF 的Serializer来进行强大的验证和序列化。纯 Django 处理 JSON 较为原始。
• FastAPI：基于Pydantic 模型，在函数签名中声明输入输出类型即可完成验证和序列化。这是最现代、最 Pythonic 的方式，能有效利用 IDE 的智能提示和类型检查。

验证建议：亲自运行一遍上述代码，尤其体验一下 FastAPI 的/docs页面。这种“编码即文档”的体验，是选择框架时一个非常实际的加分项。

7. 常见问题与排查思路

在实际使用中，你会遇到各种问题。下表列出了一些初学者常见问题及其排查方向。

8. 最佳实践与工程建议

选择一个框架只是开始，如何用好它才是关键。以下是一些针对每个框架的工程化建议。

8.1 Django 最佳实践

1. 遵循“应用”概念：将不同功能模块拆分成独立的 Django 应用（如users,orders,products）。这有助于代码复用和团队协作。
2. 善用 Django Admin：对于内部数据管理后台，Django Admin 是神器。通过自定义ModelAdmin类，可以快速打造功能强大的管理界面。
3. 使用 Class-Based Views (CBV)：对于复杂的视图逻辑，使用基于类的视图可以提高代码复用性。Django 提供了ListView,DetailView,CreateView等通用视图。
4. 配置分离：使用django-environ或 Python 的configparser来管理不同环境（开发、测试、生产）的配置，避免将敏感信息硬编码在settings.py中。
5. 静态文件与媒体文件：开发时使用django.contrib.staticfiles，生产环境务必使用 Nginx 或 CDN 来服务静态文件，并将MEDIA_ROOT指向可靠的存储。

8.2 Flask 最佳实践

1. 使用 Application Factory 模式：不要在全域范围内创建app实例。使用工厂函数create_app()来创建，这便于创建多个应用实例（用于测试）、延迟加载配置和扩展。

   # app/__init__.py from flask import Flask from .config import Config def create_app(config_class=Config): app = Flask(__name__) app.config.from_object(config_class) # 初始化扩展 from .extensions import db, migrate db.init_app(app) migrate.init_app(app, db) # 注册蓝图 from .users import bp as users_bp app.register_blueprint(users_bp, url_prefix='/api/users') return app

2. 使用蓝图（Blueprint）组织代码：当项目变大时，使用蓝图将路由分组，使结构更清晰。
3. 统一管理扩展：在一个单独的文件（如extensions.py）中初始化所有第三方扩展（如 Flask-SQLAlchemy, Flask-Migrate, Flask-Login），避免循环导入。
4. 配置管理：使用类继承的方式管理配置（如Config,DevelopmentConfig,ProductionConfig），并通过环境变量加载敏感信息。

8.3 FastAPI 最佳实践

1. 充分利用依赖注入系统：FastAPI 的依赖注入（Depends）非常强大，可以用于共享数据库会话、验证权限、获取当前用户等。这能让你的视图函数更简洁、更可测试。

   from fastapi import Depends, FastAPI, HTTPException from sqlalchemy.orm import Session app = FastAPI() # 依赖项函数，用于获取数据库会话 def get_db(): db = SessionLocal() try: yield db finally: db.close() @app.get("/users/{user_id}") async def read_user(user_id: int, db: Session = Depends(get_db)): user = db.query(User).filter(User.id == user_id).first() if user is None: raise HTTPException(status_code=404, detail="User not found") return user

2. 使用 Pydantic 模型进行严格的输入输出定义：不要偷懒使用普通的字典。为每个主要的输入和输出定义 Pydantic 模型，这能保证 API 契约的清晰和安全。
3. 异步处理 I/O 密集型操作：如果你的操作涉及网络请求、文件读写、数据库查询（使用支持异步的驱动，如asyncpg,aiomysql），务必使用async def和await来提升并发性能。
4. 版本化你的 API：从项目开始就考虑 API 版本管理，可以在路径中（如/api/v1/users）或使用 FastAPI 的APIRouter来组织不同版本的路由。

8.4 通用建议

• 日志记录：无论哪个框架，都要配置好日志（如 Python 标准库的logging模块），记录请求、错误和关键业务信息。
• 异常处理：实现全局异常处理器，将未捕获的异常转化为友好的 JSON 错误响应，避免泄露内部堆栈信息。
• 测试：为你的 API 编写单元测试和集成测试。Flask/Django 有内置测试客户端，FastAPI 可以使用TestClient。
• 安全性：永远不要信任客户端输入。做好 SQL 注入防护（使用 ORM 或参数化查询）、XSS 防护（模板引擎通常已处理）、CSRF 防护（Django 内置，Flask 需扩展）以及适当的身份认证和授权。

9. 总结与后续学习方向

回到最初的问题：Django, Flask, FastAPI，我该选哪个？

最终的判断可以归结为：

• 如果你想快速构建一个功能齐全、带管理后台的网站，并且不介意学习一套完整的、有“主见”的框架，选 Django。它的“全功能电池”理念能让你在初期飞速前进。学习路线：Django 官方教程 → MTV 模型深入 → Django REST framework (用于构建 API) → 部署。
• 如果你想深入理解 Web 工作原理，或者你的项目非常独特、需要高度定制的架构，选 Flask。它给你最大的自由，但也要求你做出更多选择。学习路线：Flask 官方文档 → 蓝图组织项目 → 选择一个 ORM (如 SQLAlchemy) → 选择身份验证扩展 → 部署。
• 如果你主要构建现代的前后端分离应用，提供 JSON API，并且看重开发效率、类型安全和自动文档，选 FastAPI。它是为这个场景而生的。学习路线：FastAPI 官方教程 → Pydantic 模型 → 依赖注入 → 异步数据库操作 → 部署。

对于初学者，我的建议是：从 Flask 开始。它的轻量能让你不被复杂的框架概念淹没，专注于理解 HTTP、路由、请求/响应循环这些 Web 开发的核心。当你用 Flask 手动组装过数据库、表单、用户登录之后，你会更深刻地理解 Django 那些“内置电池”的价值，也会更欣赏 FastAPI 在 API 领域的精妙设计。

下一步你可以做什么？

1. 深入你选择的框架：阅读其官方文档，这是最好的学习资料。
2. 构建一个完整的项目：比如一个简单的博客系统（包含用户、文章、评论）。用你选择的框架实现它，你会遇到并解决一系列实际问题。
3. 学习相关的生态系统：
   • Django：学习 Django REST framework (DRF) 来构建 API。
   • Flask：学习 SQLAlchemy (ORM)、Flask-Login (认证)、Flask-WTF (表单)。
   • FastAPI：学习 SQLAlchemy 或 Tortoise-ORM (异步 ORM)、OAuth2 与 JWT 认证。
4. 关注部署和性能：学习如何使用 Gunicorn/uWSGI + Nginx 部署 Django/Flask，如何部署 FastAPI (通常用 Uvicorn + Gunicorn + Nginx)，并了解基本的性能调优。

框架是工具，没有绝对的优劣，只有是否适合。希望这篇文章提供的视角和实操示例，能帮助你做出更明智的选择，并顺利开启你的 Python Web 开发之旅。建议收藏本文，在后续的学习中遇到困惑时，可以回来重温这三个框架的核心差异与设计哲学。