FastAPI 入门与实战：构建现代、高性能的 Web 应用

随着 Python 在 Web 开发领域的日益流行，各种框架层出不穷。FastAPI 作为后起之秀，凭借其极高的性能、易用性、基于标准（如 OpenAPI 和 JSON Schema）的特性以及自动文档生成等优点，迅速赢得了开发者的青睐。

如果你正在寻找一个现代、高效、能充分利用 Python 3.6+ 特性来构建 API 的框架，那么 FastAPI 绝对值得你深入学习。

本文将带你从零开始，详细了解 FastAPI 的核心概念和基本用法，并通过实战示例，让你快速掌握构建一个功能完善的 Web API 的能力。

文章目录

FastAPI 简介与核心优势
- 什么是 FastAPI？
- 为什么选择 FastAPI？（性能、易用性、标准、文档、类型提示）
环境准备
- 安装 Python
- 创建虚拟环境
- 安装 FastAPI 和 Uvicorn
第一个 FastAPI 应用：Hello World
- 编写代码
- 运行应用
- 访问应用
- 理解基础结构
路径操作 (Path Operations)
- HTTP 方法 (GET, POST, PUT, DELETE 等)
- 定义路径操作函数
- 路径参数 (Path Parameters)
- 类型提示 (Type Hints) 的力量
请求体 (Request Body)
- 使用 Pydantic BaseModel
- 定义数据模型
- 在路径操作中使用请求体
- 数据验证与序列化
查询参数 (Query Parameters)
- 定义查询参数
- 可选参数与默认值
- 类型提示在查询参数中的应用
组合使用：路径、查询和请求体
- 在一个函数中接收多种参数
- FastAPI 如何自动区分
响应模型 (Response Model)
- 使用 response_model 参数
- 控制响应数据结构
- 自动文档更新
依赖注入 (Dependency Injection)
- 什么是依赖注入？
- Depends 的用法
- 共享逻辑与代码复用
- 依赖的嵌套
自动交互式 API 文档 (Swagger UI / ReDoc)
- 如何访问文档
- 文档的自动生成原理
- 测试 API
错误处理 (Error Handling)
- 抛出 HTTPException
- 自定义异常处理器 (简述)
进阶话题预览 (简述)
- 安全性 (OAuth2, JWT)
- 数据库集成 (SQLAlchemy, ORM)
- 后台任务
- 测试 (TestClient)
总结与展望

1. FastAPI 简介与核心优势

什么是 FastAPI？

FastAPI 是一个现代、快速（高性能）的 web 框架，用于构建基于标准 Python 类型提示的 API。它由 Tiangolo 开发，并凭借其出色的性能和开发者体验，迅速成为 Python Web 开发领域的热门选择。

FastAPI 构建于以下三个强大的库之上：

Starlette: 用于构建高性能 ASGI 应用程序。FastAPI 的所有 Web 部分都由 Starlette 处理。
Pydantic: 用于数据验证和设置管理。FastAPI 大量使用 Pydantic 来处理请求数据的解析、验证和响应数据的序列化。
Typer: 用于构建命令行接口。虽然 Typer 不是构建 Web API 的直接部分，但 FastAPI 的很多设计哲学和对类型提示的利用，与 Typer 一脉相承。

FastAPI 完全支持异步编程 (async/await)，这使得它在处理高并发请求时表现出色。

为什么选择 FastAPI？

选择 FastAPI 有诸多令人信服的理由：

高性能: 得益于 Starlette 和 Pydantic，FastAPI 是目前 Python Web 框架中性能最高的之一，仅次于 Starlette 本身（FastAPI 基于 Starlette）。其性能可以与 Node.js 和 Go 等框架相媲美。
开发速度快: 利用 Python 类型提示，FastAPI 可以自动完成许多任务，减少样板代码，提高开发效率。
更少的 Bug: 数据验证和序列化是自动且强制执行的，能有效减少因数据格式错误导致的 Bug。
易学易用: 框架设计直观，文档清晰详尽。
基于标准: 完全兼容 OpenAPI (之前称为 Swagger) 用于构建 API 文档，兼容 JSON Schema 用于数据定义。这意味着你可以使用各种现有的工具（如 Swagger UI, Redoc）来与你的 API 交互。
自动文档: 基于 OpenAPI 标准，FastAPI 会自动生成交互式的 API 文档（Swagger UI 和 ReDoc），无需额外编写和维护。
强大的类型提示支持: FastAPI 大量利用 Python 3.6+ 的类型提示，这不仅使得代码更易读、易于维护，还能让编辑器提供更好的自动补全和代码检查功能。
依赖注入系统: 内置强大易用的依赖注入系统，方便管理逻辑和共享组件。

2. 环境准备

开始之前，你需要确保安装了 Python 3.6+。推荐使用最新的 Python 版本，因为 FastAPI 充分利用了较新版本的特性。

为了保持项目环境的干净，强烈建议使用虚拟环境。

安装 Python: 如果没有安装，请访问 Python 官网下载并安装适合你操作系统的版本。
创建虚拟环境:
- 在项目目录中打开终端。
- 运行命令：python -m venv venv (在 macOS/Linux) 或 py -m venv venv (在 Windows)。这会在当前目录下创建一个名为 venv 的文件夹。
激活虚拟环境:
- 在 macOS/Linux: source venv/bin/activate
- 在 Windows (Cmd): venv\Scripts\activate.bat
- 在 Windows (PowerShell): venv\Scripts\Activate.ps1
  激活后，你的终端提示符前应该会显示 (venv)。
安装 FastAPI 和 Uvicorn:
- uvicorn 是一个高性能的 ASGI 服务器，用于运行 FastAPI 应用。
- 运行命令：pip install fastapi "uvicorn[standard]"
- "uvicorn[standard]" 会安装 Uvicorn 的标准版本，包含一些有用的依赖，如 websockets 和 python-multipart。

现在，你已经具备了运行 FastAPI 应用所需的所有条件。

3. 第一个 FastAPI 应用：Hello World

让我们来创建一个最简单的 FastAPI 应用。

在一个文件中（例如 main.py）写入以下代码：

“`python

main.py

from fastapi import FastAPI

创建 FastAPI 应用实例

app = FastAPI()

定义一个路径操作装饰器

@app.get(“/”)

定义一个路径操作函数

async def read_root():
return {“Hello”: “World”}
“`

代码解释：

from fastapi import FastAPI: 导入 FastAPI 类。
app = FastAPI(): 创建一个 FastAPI 实例。这个 app 实例将是整个应用的核心对象。
@app.get("/"): 这是一个路径操作装饰器。它告诉 FastAPI，紧随其后的函数负责处理针对根路径 (/) 的 GET 请求。
async def read_root():: 这是一个路径操作函数。当收到对根路径的 GET 请求时，这个函数会被调用。我们使用 async def 是因为 FastAPI 支持异步，虽然在这个简单的例子中不是必须的，但养成习惯有助于后续开发。
return {"Hello": "World"}: 路径操作函数返回一个 Python 字典。FastAPI 会自动将这个字典转换为 JSON 响应。

运行应用：

打开终端，确保你处于虚拟环境且在 main.py 文件所在的目录，然后运行：

bash uvicorn main:app --reload

命令解释：

uvicorn: 调用 Uvicorn 服务器。
main:app: 指定 Uvicorn 应该加载哪个应用。main 是你的 Python 文件名（不带 .py），app 是你在该文件中创建的 FastAPI 实例的变量名。
--reload: 启用自动重载。当你修改代码并保存时，服务器会自动重启，这在开发过程中非常方便。

如果一切正常，你会看到类似以下的输出：

INFO: Will watch for changes in these directories: ['/path/to/your/project'] INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) INFO: Started reloader process [xxxxx] using statreload INFO: Started server process [yyyyy] INFO: Waiting for application startup. INFO: Application startup complete.

访问应用：

打开你的 Web 浏览器，访问 http://127.0.0.1:8000。你应该会看到一个页面显示：

json {"Hello": "World"}

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

4. 路径操作 (Path Operations)

路径操作定义了你的 API 如何响应特定的 URL 路径和 HTTP 请求方法。

HTTP 方法：

常见的 HTTP 方法包括：

GET: 从服务器获取资源。通常用于读取数据。
POST: 向服务器提交数据，创建新资源。
PUT: 向服务器提交数据，更新现有资源（通常是完全替换）。
DELETE: 从服务器删除资源。
PATCH: 向服务器提交数据，部分更新现有资源。
OPTIONS, HEAD, TRACE, CONNECT: 不常用，但 FastAPI 也支持。

在 FastAPI 中，你使用 @app.<method>("path") 装饰器来定义对应 HTTP 方法的路径操作。

定义路径操作函数：

“`python
@app.post(“/items/”)
async def create_item():
return {“message”: “Item created”}

@app.get(“/items/”)
async def read_items():
return [“Item 1”, “Item 2”]

@app.put(“/items/{item_id}”)
async def update_item(item_id: int):
return {“item_id”: item_id, “message”: “Item updated”}
“`

路径参数 (Path Parameters):

有时候，你需要从 URL 路径中提取一部分作为参数，例如 /items/5 中的 5。这被称为路径参数。

在 FastAPI 中，你可以在路径中用花括号 {parameter_name} 定义路径参数：

python @app.get("/items/{item_id}") async def read_item(item_id): return {"item_id": item_id}

类型提示 (Type Hints) 的力量:

现在，让我们看看 FastAPI 如何利用 Python 的类型提示让开发更高效、更安全。

修改上面的例子，给 item_id 加上类型提示 int:

python @app.get("/items/{item_id}") async def read_item(item_id: int): return {"item_id": item_id}

FastAPI 会根据这个类型提示做以下几件事：

数据转换: 当收到请求时，它会尝试将路径参数 item_id 的值（它总是字符串）转换为 int 类型。
数据验证: 如果转换失败（例如，客户端请求了 /items/abc），FastAPI 会自动返回一个带有 422 Unprocessable Entity 状态码的错误响应，告诉你数据无效。你不需要手动编写验证代码。
文档生成: 类型提示也会被用于生成 OpenAPI 文档，明确说明 item_id 应该是一个整数。
编辑器支持: 你的代码编辑器（如 VS Code, PyCharm）可以利用类型提示提供更好的自动补全和静态代码分析。

你可以在路径参数中使用各种标准 Python 类型，如 str, int, float, bool, uuid.UUID, datetime.datetime, datetime.date, datetime.time, datetime.timedelta 等。

你还可以为路径参数定义默认值，使其成为可选的。例如，item_id: int = 0。

5. 请求体 (Request Body)

GET 请求通常没有请求体，但 POST, PUT, PATCH 请求通常会携带数据，比如用于创建或更新资源的 JSON 数据。

FastAPI 使用 Pydantic 库来处理请求体。Pydantic 允许你使用 Python 类来定义数据的结构和类型，并提供强大的数据验证功能。

安装 Pydantic: 我们已经在步骤 2 中通过 pip install fastapi 间接安装了 Pydantic，因为它是 FastAPI 的依赖。
定义数据模型: 使用 Pydantic 的 BaseModel 创建一个类来描述请求体的数据结构。

“`python

main.py (在顶部导入 Pydantic 的 BaseModel)

from typing import Optional # 用于定义可选字段
from pydantic import BaseModel

定义请求体数据模型

class Item(BaseModel):
name: str
description: Optional[str] = None # description 是可选的，默认值为 None
price: float
tax: Optional[float] = None

… 其他代码 …

`` **解释：** *class Item(BaseModel):: 定义一个名为Item的类，它继承自pydantic.BaseModel。 * 字段名和类型提示 (name: str,price: float等) 定义了预期的 JSON 数据的键和值的类型。 * 使用Optional[str]和= None表示该字段是可选的，如果客户端未提供，则默认值为None`。
在路径操作中使用请求体: 在路径操作函数的参数中，使用你定义的 Pydantic 模型作为类型提示。

“`python

main.py (接着上面的代码)

@app.post(“/items/”)
async def create_item(item: Item):
# item 参数将是 Item 类的一个实例
# FastAPI 和 Pydantic 已经自动：
# 1. 从请求体中读取 JSON 数据
# 2. 将 JSON 数据转换为 Item 对象
# 3. 验证数据的结构和类型
# 如果验证失败，FastAPI 会自动返回 422 错误
```
item_dict = item.model_dump() # 将 Pydantic 对象转换为字典 (旧版本用 .dict())
if item.tax:
    price_with_tax = item.price + item.tax
    item_dict.update({"price_with_tax": price_with_tax})

return item_dict
```
… 其他代码 …

`` **解释：** *item: Item: FastAPI 看到参数item的类型提示是继承自BaseModel的Item，就知道这个参数应该从请求体中获取。 * 当你收到一个POST /items/请求，并且请求体是 JSON 数据时，FastAPI 会使用 Pydantic 来解析并验证 JSON 数据。如果数据有效，就会创建一个Item类的实例，并将其作为item参数传递给create_item` 函数。

你可以在 Swagger UI 文档页面（通常是 /docs）看到 POST /items/ 接口，它会显示预期的请求体结构（基于 Item 模型），并且你可以直接在文档中尝试发送请求，包括发送无效数据，看看 FastAPI 如何处理验证错误。

6. 查询参数 (Query Parameters)

查询参数是 URL 中 ? 后面的键值对，例如 /items/?skip=0&limit=10。它们通常用于过滤、分页或提供额外信息。

在 FastAPI 中，查询参数也是通过路径操作函数的参数来定义的。只要参数不是路径参数，并且没有类型提示为 BaseModel（或其他请求体模型），FastAPI 就会将其视为查询参数。

“`python

main.py

… (之前的导入和 app 实例) …

@app.get(“/items/”)
async def read_items(skip: int = 0, limit: int = 10):
# skip 和 limit 是查询参数
# 如果请求是 /items/?skip=20&limit=50
# skip 的值将是 20 (整数)，limit 的值将是 50 (整数)
return {“skip”: skip, “limit”: limit}

… 其他代码 …

“`

解释：

skip: int = 0: 定义一个名为 skip 的查询参数。
- 类型提示 int 告诉 FastAPI 尝试将其转换为整数，并进行验证。
- = 0 提供了默认值，这意味着 skip 是一个可选的查询参数，如果客户端不提供，其值为 0。
limit: int = 10: 定义另一个可选查询参数 limit，默认值为 10。

必选查询参数：

如果你想让查询参数成为必选的，只需不给它设置默认值：

python @app.get("/items_required_query/") async def read_items_required(item_id: int): # item_id 是一个必选的查询参数 # 请求 /items_required_query/?item_id=123 是有效的 # 请求 /items_required_query/ 会返回 422 错误 return {"item_id": item_id}

你也可以使用 Query() 来提供额外的验证或元数据（如描述、别名等），尽管对于简单的必选/可选和类型提示来说，直接设置默认值已经足够。

7. 组合使用：路径、查询和请求体

在一个路径操作函数中同时接收路径参数、查询参数和请求体是非常常见的。FastAPI 会根据参数的类型提示和默认值自动判断它们应该来自哪里。

优先级通常是：

路径参数: 在路径字符串中定义的花括号参数。
请求体: 如果参数的类型是继承自 BaseModel 的类，则来自请求体。在一个请求操作中，通常只有一个参数被定义为请求体，尽管可以使用 Body() 来明确指定多个。
查询参数: 其他所有没有默认值的参数，或者带有简单类型（非 BaseModel）且有默认值的参数，都视为查询参数。

示例：

“`python

main.py

… (之前的导入和 BaseModel) …

假设 Item 类已定义

@app.put(“/items/{item_id}”)
async def update_item(item_id: int, q: str | None = None, item: Item | None = None):
# item_id: int -> 路径参数，必选
# q: str | None = None -> 查询参数，可选 (等同于 Optional[str] = None)
# item: Item | None = None -> 请求体，可选 (等同于 Optional[Item] = None)

results = {"item_id": item_id}
if q:
    results.update({"q": q})
if item:
    # 如果提供了请求体，将其内容更新到结果中
    results.update({"item": item.model_dump()})

return results

… 其他代码 …

`` 这个例子演示了在一个PUT请求中： *item_id作为路径参数。 *q作为可选查询参数。 *item` 作为可选请求体。

FastAPI 会智能地解析这些参数并传递给 update_item 函数。

8. 响应模型 (Response Model)

默认情况下，FastAPI 会将你的 Python 返回值（如字典、Pydantic 模型实例、列表等）转换为 JSON 响应。

使用 response_model 参数可以在路径操作装饰器中定义预期的响应数据结构。这有几个好处：

文档: 明确告诉 API 的消费者响应数据的结构。
数据过滤/塑形: 如果你的路径操作函数返回的数据比 response_model 定义的多，FastAPI 会自动过滤掉那些 response_model 中没有的字段。这有助于避免敏感数据泄露。
验证: 虽然不如请求体验证严格，但如果返回的数据类型与 response_model 不兼容，可能会报错。

示例：

“`python

main.py

… (导入和 BaseModel) …

假设我们有一个创建 Item 的请求体模型 ItemRequest (与 Item BaseModel 相同或不同)

假设我们希望响应数据模型只包含 name 和 price 字段

class ItemResponse(BaseModel):
name: str
price: float

假设 ItemRequest = Item (使用上面定义的 Item 类作为请求体模型)

@app.post(“/items/”, response_model=ItemResponse)
async def create_item(item: Item):
# 假设这里处理创建逻辑，并返回完整的 item 数据
# FastAPI 在返回响应前，会自动将这个 Item 对象转换为 JSON，
# 并根据 response_model=ItemResponse 过滤和塑形数据
# 只有 name 和 price 会出现在最终的响应中
return item # 这里返回完整的 Item 对象

@app.get(“/items/{item_id}”, response_model=ItemResponse | None) # 响应可能是一个 ItemResponse 或 None
async def read_item(item_id: int):
# 假设这里从数据库获取 Item
# item_data = get_item_from_db(item_id)
item_data = {“name”: “Foo”, “description”: “A very nice Item”, “price”: 35.4} # 模拟获取数据

if item_data:
    # 返回的数据包含 description，但因为 response_model 是 ItemResponse，
    # description 将被过滤掉
    return item_data # FastAPI 会将 dict 转换为 ItemResponse
else:
    return None # 如果找不到，返回 None (对应 response_model 的 Optional)

… 其他代码 …

“`

在这个例子中，尽管 create_item 函数返回了完整的 Item 对象（包含 description 和 tax），但由于 response_model=ItemResponse 的设置，最终的 JSON 响应只会包含 name 和 price 字段。

9. 依赖注入 (Dependency Injection)

依赖注入是 FastAPI 最强大的特性之一。它允许你定义“依赖项”——可以被路径操作函数或其他依赖项使用的函数或类实例。FastAPI 会负责调用这些依赖项，并将它们的返回值作为参数传递给依赖它们的函数。

这对于以下场景非常有用：

代码复用: 共享数据库连接、配置设置、认证逻辑等。
逻辑分离: 将复杂的逻辑分解成小的、可测试的单元。
测试: 方便地用模拟对象替换真实的依赖项进行单元测试。

依赖项可以是函数或类。最简单的形式是一个函数。

“`python

main.py

… (导入和 BaseModel) …

from fastapi import Depends, FastAPI, HTTPException, status # 需要导入 Depends, HTTPException, status

定义一个简单的依赖函数

async def get_query_token(token: str | None = None):
# token 是一个查询参数，必选
if token is None:
# 如果没有提供 token，抛出异常
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=”Not authenticated”)
return token

定义另一个依赖函数，它依赖于 get_query_token

async def get_current_user(token: str = Depends(get_query_token)):
# 在实际应用中，这里会根据 token 去查用户
# 为了演示，我们只返回 token
return {“token”: token}

使用依赖项

@app.get(“/users/me/”)
async def read_users_me(current_user: dict = Depends(get_current_user)):
# FastAPI 会先调用 get_current_user
# get_current_user 会先调用 get_query_token
# get_query_token 验证并返回 token
# token 传递给 get_current_user
# get_current_user 返回 {“token”: token}
# {“token”: token} 传递给 read_users_me 的 current_user 参数
return current_user

… 其他代码 …

“`

解释：

Depends(get_query_token): 这告诉 FastAPI get_current_user 函数依赖于 get_query_token 函数的返回值。FastAPI 会在调用 get_current_user 之前先调用 get_query_token。
Depends(get_current_user): 这告诉 FastAPI read_users_me 函数依赖于 get_current_user 函数的返回值。
FastAPI 的依赖注入系统会自动解决依赖链条（read_users_me -> get_current_user -> get_query_token），并按正确的顺序调用这些函数。
依赖函数可以像路径操作函数一样定义参数（路径参数、查询参数、Header、Cookie、Body 等），FastAPI 也会自动解析和验证这些参数。
依赖函数可以使用 async def 或 def。

依赖注入是构建大型、复杂应用的关键，它使得代码结构清晰、模块化、易于测试。

10. 自动交互式 API 文档 (Swagger UI / ReDoc)

FastAPI 的一大亮点是它能够基于你的代码自动生成完整的 API 文档。这些文档是交互式的，你可以直接在浏览器中测试你的 API。

当你运行 FastAPI 应用时，访问以下 URL：

http://127.0.0.1:8000/docs: 这是由 Swagger UI 提供的交互式 API 文档。
http://127.0.0.1:8000/redoc: 这是由 ReDoc 提供的另一种风格的 API 文档。

这些文档是根据你的路径操作、参数的类型提示、Pydantic 模型以及 response_model 等信息自动生成的，并且完全符合 OpenAPI 标准。这意味着你可以将它们导出为 JSON 或 YAML 文件，并在其他工具中使用。

你可以在 Swagger UI 中看到每个路径、支持的 HTTP 方法、期望的参数（路径、查询、请求体）、参数的类型、是否必选、以及预期的响应结构。你甚至可以直接在界面上填写参数并发送请求，查看真实的响应。

这是 FastAPI 极大地提高了开发效率和协作效率的功能之一。

11. 错误处理 (Error Handling)

当出现错误时，你可能希望返回特定的 HTTP 状态码和错误信息。FastAPI 提供了 HTTPException 来处理这种情况。

“`python

main.py

… (导入和 BaseModel) …

from fastapi import Depends, FastAPI, HTTPException, status # 确保导入 HTTPException 和 status

定义一个模拟数据

items = {“foo”: “The Foo Fighters”, “bar”: “Bar Fighters”}

@app.get(“/items/{item_id}”)
async def read_item(item_id: str):
if item_id not in items:
# 如果 item_id 不存在，抛出 HTTPException
# status_code=404 表示 Not Found
# detail 是错误信息，会包含在 JSON 响应体中
raise HTTPException(status_code=404, detail=”Item not found”)
return {“item”: items[item_id]}

… 其他代码 …

“`

解释：

from fastapi import HTTPException, status: 导入 HTTPException 和 status（status 是一个方便的模块，提供了各种标准 HTTP 状态码）。
raise HTTPException(status_code=404, detail="Item not found"): 抛出一个 HTTPException 异常。FastAPI 会捕获这个异常，并返回一个 HTTP 响应，状态码为 404，响应体是一个 JSON 对象 {"detail": "Item not found"}。

除了 HTTPException，FastAPI 还可以配置自定义的异常处理器，来处理特定类型的异常（包括你自己的自定义异常），并返回定制的响应。

12. 进阶话题预览 (简述)

本文涵盖了 FastAPI 的核心概念和基本用法，但 FastAPI 的功能远不止于此。以下是一些你可以进一步探索的进阶话题：

安全性: 实现用户认证 (Authentication) 和授权 (Authorization)，FastAPI 支持多种安全方案，如 OAuth2 (包括密码流、Bearer Token)、API Key、Cookie 等，并与依赖注入系统无缝集成。
数据库集成: FastAPI 本身不包含 ORM，但可以轻松地与 SQLAlchemy、Tortoise ORM、Peewee 等各种数据库库集成。依赖注入是管理数据库会话的常用方式。
后台任务: 使用 @app.on_event("startup") 和 @app.on_event("shutdown") 处理应用启动和关闭事件；使用 BackgroundTasks 在发送响应后执行一些任务。
测试: FastAPI 提供了 TestClient，可以方便地使用 pytest 等测试框架对你的 API 端点进行集成测试。
中间件 (Middleware): 在请求被路径操作函数处理之前或响应发送回客户端之后，执行一些逻辑，例如日志记录、CORS 处理、会话管理等。
配置: 如何优雅地管理应用的配置，例如使用 Pydantic 的 Settings 管理环境变。
子应用 (Sub-applications) 和路由器 (APIRouter): 构建大型应用时，可以将不同的路径分组到不同的路由器中，然后将它们挂载到主应用上，保持代码的组织性。
WebSocket: 支持构建 WebSocket 应用。
表单数据和文件上传: 处理 application/x-www-form-urlencoded 和 multipart/form-data 类型的请求体。

13. 总结与展望

本文详细介绍了 FastAPI 的基础知识，包括环境搭建、创建第一个应用、路径操作、参数处理（路径、查询、请求体）、响应模型、依赖注入以及自动文档等核心特性。

通过这些内容，你应该已经对如何使用 FastAPI 构建一个现代、高性能的 Web API 有了清晰的认识。FastAPI 凭借其对 Python 类型提示的深度利用、强大的 Pydantic 集成、基于标准的自动文档以及出色的性能，成为了构建 API 的绝佳选择。

这仅仅是 FastAPI 世界的冰山一角。鼓励你继续探索官方文档，了解更高级的特性，如安全、数据库集成、测试和部署。

开始使用 FastAPI 构建你的下一个 Web 应用吧！你将体验到前所未有的开发效率和乐趣。

FastAPI 入门与实战：构建现代、高性能的 Web 应用

1. FastAPI 简介与核心优势

2. 环境准备

3. 第一个 FastAPI 应用：Hello World

main.py

创建 FastAPI 应用实例

定义一个路径操作装饰器

定义一个路径操作函数

4. 路径操作 (Path Operations)

5. 请求体 (Request Body)

main.py (在顶部导入 Pydantic 的 BaseModel)

定义请求体数据模型

… 其他代码 …

main.py (接着上面的代码)

… 其他代码 …

6. 查询参数 (Query Parameters)

main.py

… (之前的导入和 app 实例) …

… 其他代码 …

7. 组合使用：路径、查询和请求体

main.py

… (之前的导入和 BaseModel) …

假设 Item 类已定义

… 其他代码 …

8. 响应模型 (Response Model)

main.py

… (导入和 BaseModel) …

假设我们有一个创建 Item 的请求体模型 ItemRequest (与 Item BaseModel 相同或不同)

假设我们希望响应数据模型只包含 name 和 price 字段

假设 ItemRequest = Item (使用上面定义的 Item 类作为请求体模型)

… 其他代码 …

9. 依赖注入 (Dependency Injection)

main.py

… (导入和 BaseModel) …

定义一个简单的依赖函数

定义另一个依赖函数，它依赖于 get_query_token

使用依赖项

… 其他代码 …

10. 自动交互式 API 文档 (Swagger UI / ReDoc)

11. 错误处理 (Error Handling)

main.py

… (导入和 BaseModel) …

定义一个模拟数据

… 其他代码 …

12. 进阶话题预览 (简述)

13. 总结与展望

发表评论 取消回复

发表评论取消回复