Python FastAPI 教程：从零开始学习 – wiki基地

作者： /

Python FastAPI 教程：从零开始构建高性能 API

欢迎来到 FastAPI 的世界！如果你正在寻找一种现代、快速、易于使用且功能强大的 Python 框架来构建 Web API，那么 FastAPI 是一个绝佳的选择。本教程将带你从零开始，一步步学习 FastAPI 的核心概念和用法，最终让你能够自信地构建自己的高性能 Web 服务。

引言：为什么选择 FastAPI？

在 Web 开发领域，构建 API（应用程序接口）是连接前端（如网站、移动应用）和后端服务或服务之间通信的基石。Python 拥有众多优秀的 Web 框架，如 Django、Flask 等。然而，随着技术的发展和需求的提高，开发者们开始追求更高的性能、更快的开发速度以及更好的开发体验。

FastAPI 正是为了满足这些需求而诞生的。它是一个相对年轻（但发展迅速）的 Python 框架，基于标准的 Python 类型提示构建，底层使用了 Starlette（一个轻量级 ASGI 框架）用于高性能的网络处理以及 Pydantic 用于数据验证和序列化。

FastAPI 的突出优点包括：

  1. 极高的性能: 得益于 Starlette 和 Uvicorn (或 Hypercorn/Daphne 等 ASGI 服务器)，FastAPI 的性能可以与 Node.js 和 Go 相媲美，甚至在某些基准测试中超越它们。
  2. 开发速度快: 代码量少，API 接口定义直观。
  3. 自动交互式 API 文档: FastAPI 自动生成符合 OpenAPI (以前称为 Swagger) 标准的 API 文档，并提供用户友好的 Swagger UI 和 ReDoc 界面，可以直接在浏览器中测试 API。
  4. 强大的数据验证和序列化: 使用 Pydantic，你可以用标准的 Python 类型提示定义数据模型，FastAPI 会自动处理请求数据的验证和响应数据的序列化。
  5. 类型提示支持: 充分利用 Python 的类型提示，提供优秀的编辑器支持（代码补全、错误检查），提高代码质量和可维护性。
  6. 易于学习: 语法简洁，核心概念易于掌握。
  7. 依赖注入系统: 清晰地管理依赖关系，方便测试和代码复用。

如果你对构建现代化、高性能、易于维护的 API 感兴趣，那么 FastAPI 绝对值得你投入时间学习。

准备工作：安装 Python 和必要的库

在开始之前，请确保你的计算机上已经安装了 Python 环境。FastAPI 需要 Python 3.7 或更高版本，因为它广泛使用了类型提示和异步特性。你可以从 Python 官网 下载并安装最新版本的 Python。

安装 Python 后，我们需要安装 FastAPI 和一个 ASGI 服务器。ASGI (Asynchronous Server Gateway Interface) 是 Python 异步 Web 应用的标准接口，类似于传统的 WSGI。FastAPI 是一个 ASGI 框架。

最常用的 ASGI 服务器是 Uvicorn，它速度快且易于使用。

打开你的终端或命令行工具，运行以下命令来安装 FastAPI 和带有标准依赖的 Uvicorn：

bash
pip install fastapi "uvicorn[standard]"

  • pip install fastapi: 安装 FastAPI 框架本身。
  • "uvicorn[standard]": 安装 Uvicorn 服务器。[standard] 包含了支持的功能，例如自动重载。

建议使用虚拟环境: 在开发 Python 项目时，强烈建议使用虚拟环境（如 venv 或 conda）来隔离项目依赖，避免不同项目之间的库版本冲突。

“`bash

创建虚拟环境 (以 venv 为例)

python -m venv myenv

激活虚拟环境

Windows

myenv\Scripts\activate

macOS/Linux

source myenv/bin/activate

在激活的虚拟环境中安装 FastAPI 和 Uvicorn

pip install fastapi “uvicorn[standard]”
“`

激活虚拟环境后，你的终端提示符通常会显示虚拟环境的名称（例如 (myenv)）。确保后续操作都在这个激活的环境中进行。

你的第一个 FastAPI 应用

让我们从最简单的一个例子开始：创建一个返回 “Hello: World” 的 API 接口。

创建一个新的 Python 文件，命名为 main.py (或其他你喜欢的名字)。

“`python

main.py

from fastapi import FastAPI

创建一个 FastAPI 应用实例

app 变量将是与用户所有交互的入口点

app = FastAPI()

定义一个路径操作装饰器

@app.get(“/”) 表示当接收到对根路径 “/” 的 GET 请求时，会执行下面的函数

@app.get(“/”)

定义一个路径操作函数

这个函数将被 FastAPI 用来处理上面的路径操作请求

def read_root():
# 返回一个 Python 字典
# FastAPI 会自动将字典转换为 JSON 格式的响应
return {“Hello”: “World”}
“`

这段代码做了什么？

  1. from fastapi import FastAPI: 从 fastapi 库中导入 FastAPI 类。
  2. app = FastAPI(): 创建一个 FastAPI 类的实例。这个实例就是你的 Web 应用，所有后续的配置和路由都将关联到它。
  3. @app.get("/"): 这是一个 Python 装饰器。它告诉 FastAPI，下面的函数 read_root 应该处理针对 URL 路径 / 的 GET 请求。FastAPI 支持所有标准的 HTTP 方法装饰器，如 @app.post(), @app.put(), @app.delete(), @app.options(), @app.head(), @app.patch(), @app.trace() 等。
  4. def read_root():: 定义了一个普通的 Python 函数。这个函数被称为 路径操作函数（或 端点函数），因为它与一个路径操作（由装饰器定义）关联。
  5. return {"Hello": "World"}: 函数返回一个 Python 字典。FastAPI 会自动识别这是一个字典，并将其序列化为 JSON 格式的响应，同时设置 Content-Type: application/json 响应头。

运行 FastAPI 应用

要运行这个应用，我们需要使用之前安装的 ASGI 服务器，也就是 Uvicorn。

在终端中，确保你处于之前激活的虚拟环境中，并且当前目录是 main.py 文件所在的目录。然后运行以下命令：

bash
uvicorn main:app --reload

这个命令的含义是：

  • uvicorn: 运行 uvicorn 服务器。
  • main:app:
    • main: 指的是 main.py 文件（没有 .py 后缀）。
    • :app: 指的是在 main.py 文件中创建的 FastAPI 实例对象，变量名是 app。
  • --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]
INFO: Started server running on http://127.0.0.1:8000

这表示你的应用已经在本地的 http://127.0.0.1:8000 地址上运行起来了。

测试你的第一个 API

打开你的 Web 浏览器，访问 http://127.0.0.1:8000。你应该会看到浏览器显示 JSON 格式的输出：

json
{"Hello": "World"}

恭喜！你已经成功地构建并运行了你的第一个 FastAPI 应用。

自动交互式 API 文档

FastAPI 最酷的特性之一是它自动生成的 API 文档。当你的应用运行时，你可以访问两个特殊的路径来查看这些文档：

  1. Swagger UI: 访问 http://127.0.0.1:8000/docs。
  2. ReDoc: 访问 http://127.0.0.1:8000/redoc。

打开浏览器，访问 http://127.0.0.1:8000/docs。你将看到一个漂亮的交互式页面，列出了你的所有 API 端点（目前只有一个 /）。你可以点击 / 端点展开，查看其描述（目前是函数名），甚至点击 “Try it out” 按钮来直接在浏览器中发送请求并查看响应。

这个文档是根据你的代码（特别是函数签名和类型提示）自动生成的，并且随着你添加更多的 API 接口而自动更新。这极大地提高了开发效率和前后端协作效率。

路径参数 (Path Parameters)

很多时候，我们需要从 URL 路径中捕获一些变量，例如获取某个特定用户的 ID 或某个商品的详情。FastAPI 允许你在路径中使用花括号 {} 来定义路径参数。

修改 main.py 文件：

“`python

main.py

from fastapi import FastAPI

app = FastAPI()

@app.get(“/”)
def read_root():
return {“Hello”: “World”}

定义一个路径参数 item_id

@app.get(“/items/{item_id}”)

在函数签名中声明同名的参数

使用类型提示 int，FastAPI 会自动将路径参数转换为整数，并进行数据验证

def read_item(item_id: int):
# 返回包含路径参数值的字典
return {“item_id”: item_id}

你还可以定义多个路径参数

@app.get(“/users/{user_id}/items/{item_id}”)
def read_user_item(user_id: int, item_id: str):
# 注意这里 item_id 使用了 str 类型
return {“user_id”: user_id, “item_id”: item_id}
“`

保存文件。由于你使用了 --reload 标志运行 Uvicorn，服务器应该会自动重启。

现在，你可以访问 http://1.2.7.0.0.1:8000/items/5。你应该会看到：

json
{"item_id": 5}

访问 http://127.0.0.0.1:8000/items/abc。由于 item_id 被声明为 int 类型，FastAPI 会自动进行数据验证。你会收到一个 422 Unprocessable Entity 错误响应，其中包含验证失败的详细信息。这是一个非常强大的功能，你可以免费获得数据验证而无需编写额外的代码。

访问 http://127.0.0.1:8000/users/10/items/foo。你应该会看到：

json
{"user_id": 10, "item_id": "foo"}

访问 http://127.0.0.1:8000/docs 查看自动更新的文档。你会看到新添加的 /items/{item_id} 和 /users/{user_id}/items/{item_id} 端点，并且文档中明确指出了参数的类型。

关于类型提示: FastAPI 利用 Python 的类型提示进行数据转换、验证、文档生成等。这是 FastAPI 的核心特性之一。务必为你的函数参数添加类型提示。

查询参数 (Query Parameters)

除了路径参数，我们还需要从 URL 的查询字符串中获取数据，例如 ?name=value&age=30。这些是查询参数。

在 FastAPI 中，不是路径参数的函数参数会被自动识别为查询参数。

修改 main.py：

“`python

main.py

from fastapi import FastAPI

app = FastAPI()

@app.get(“/”)
def read_root():
return {“Hello”: “World”}

@app.get(“/items/{item_id}”)
def read_item(item_id: int):
return {“item_id”: item_id}

定义带查询参数的接口

q 和 skip 是查询参数

@app.get(“/items/”)

q 是一个可选的字符串参数，默认为 None

skip 是一个带默认值的整数参数，默认为 0

limit 是一个带默认值的整数参数，默认为 10

def read_items(q: str | None = None, skip: int = 0, limit: int = 10):
# 根据查询参数的值返回不同的响应
results = {“skip”: skip, “limit”: limit}
if q:
results.update({“q”: q})
return results
“`

保存文件，等待服务器重载。

访问 http://127.0.0.1:8000/items/。由于 q 是可选的 (None 是默认值)，并且 skip 和 limit 有默认值，你会看到：

json
{"skip": 0, "limit": 10}

访问 http://127.0.0.1:8000/items/?limit=5。你会看到：

json
{"skip": 0, "limit": 5}

访问 http://127.0.0.1:8000/items/?q=somequery&skip=20。你会看到：

json
{"skip": 20, "limit": 10, "q": "somequery"}

FastAPI 同样会根据你的类型提示对查询参数进行验证。例如，如果你访问 http://127.0.0.1:8000/items/?skip=abc，你会收到 422 验证错误。

必填查询参数: 如果你不为查询参数提供默认值（包括 None），它将成为一个必填查询参数。例如 def read_items(q: str): ... 中的 q 就变成了必填。如果客户端请求 /items/ 而没有提供 q，FastAPI 会返回 422 错误。

请求体 (Request Body) 和 Pydantic 模型

对于 POST, PUT, PATCH 等请求，客户端通常会将数据放在请求体中发送给服务器，最常见的是 JSON 格式。FastAPI 使用 Pydantic 来处理请求体的解析、验证和数据建模。

首先，我们需要定义一个 Pydantic 模型来描述我们期望接收的数据结构。

修改 main.py：

“`python

main.py

from fastapi import FastAPI

导入 BaseModel

from pydantic import BaseModel

为了演示可选参数，导入 Union（或者使用 Python 3.10+ 的 | 运算符）

from typing import Union # Python < 3.10

app = FastAPI()

定义 Pydantic 模型，描述请求体的数据结构

class Item(BaseModel):
name: str # 必填字符串字段
price: float # 必填浮点数字段
# description 是可选的字符串字段，默认为 None
description: str | None = None # Python 3.10+
# description: Union[str, None] = None # Python < 3.10
# is_offer 是可选的布尔字段，默认为 False
is_offer: bool = False

@app.get(“/”)
def read_root():
return {“Hello”: “World”}

@app.get(“/items/{item_id}”)
def read_item(item_id: int):
return {“item_id”: item_id}

@app.get(“/items/”)
def read_items(q: str | None = None, skip: int = 0, limit: int = 10):
results = {“skip”: skip, “limit”: limit}
if q:
results.update({“q”: q})
return results

定义一个 POST 路径操作，用于创建 item

@app.post(“/items/”)

在函数参数中声明请求体： item: Item

FastAPI 会读取请求体，解析为 JSON，并验证数据是否符合 Item 模型

如果验证通过，创建一个 Item 对象并将其作为 item 参数传递给函数

async def create_item(item: Item):
# 你可以在这里对 item 对象进行操作，比如存入数据库
# …
# 返回接收到的 item 对象
return item

结合路径参数和请求体

@app.put(“/items/{item_id}”)
async def update_item(item_id: int, item: Item):
return {“item_id”: item_id, item.model_dump()} # model_dump() 用于将 Pydantic 模型转回字典
# return {“item_id”: item_id, item.dict()} # 兼容旧版本 Pydantic
“`

保存文件，等待服务器重载。

访问 http://127.0.0.1:8000/docs。你会看到 /items/ 端点现在有一个 POST 方法。点击展开 POST /items/，你会看到一个 “Request body” 部分，显示了 Item 模型的结构以及每个字段的类型和是否必填。这是 Pydantic 模型自动生成的 OpenAPI Schema。

点击 “Try it out”，你可以在请求体中输入 JSON 数据进行测试。例如：

json
{
"name": "Foo",
"price": 35.4,
"description": "A very nice Item",
"is_offer": true
}

点击 “Execute”，你会看到服务器返回的状态码（应该是 200 OK）和响应体，响应体就是你发送过去的数据。

尝试发送一个缺少 name 字段的请求体：

json
{
"price": 35.4
}

点击 “Execute”。你会收到一个 422 Unprocessable Entity 错误，响应体详细说明了哪个字段缺失以及原因。

同样，测试 PUT /items/{item_id} 接口，例如访问 http://127.0.0.1:8000/docs，找到 PUT /items/{item_id}，点击 “Try it out”，输入一个 item_id (例如 5) 和请求体。

json
{
"name": "Bar",
"price": 10.0
}

点击 “Execute”。你会收到响应：

json
{
"item_id": 5,
"name": "Bar",
"price": 10.0,
"description": null,
"is_offer": false
}

注意 description 和 is_offer 使用了默认值，因为你在请求体中没有提供它们。

Pydantic 的作用:

  • 数据验证: 根据 BaseModel 定义的类型和约束（虽然我们这里只用了基本类型，Pydantic 支持更复杂的验证如最小/最大值、长度、正则表达式等），自动验证请求体的数据。如果数据不符合模型，自动返回详细的 422 错误。
  • 数据转换: 尝试将接收到的数据转换为模型中定义的类型（例如，字符串 “5” 会被转换为整数 5）。
  • 数据建模: 提供清晰的数据结构定义。
  • 序列化: 将 Python 对象（包括 Pydantic 模型实例）转换为 JSON 响应。当你返回一个 Item 对象时，FastAPI 会自动使用 Pydantic 将其转换为字典，然后转换为 JSON。
  • 文档生成: 根据模型自动生成 OpenAPI Schema。

结合路径参数、查询参数和请求体

在实际开发中，一个 API 端点可能需要同时接收路径参数、查询参数和请求体。FastAPI 可以轻松地处理这种情况。你只需在路径操作函数的签名中声明所有需要的参数即可。

FastAPI 会根据参数的类型提示和位置自动判断它们是路径参数、查询参数还是请求体：

  • 如果在路径字符串中出现，就是路径参数。
  • 如果是 Pydantic 模型类型，就是请求体。
  • 如果是其他基本类型（int, str, bool, float, list, tuple, dict, set）且不在路径中，就是查询参数。
  • 如果你需要更精细的控制（例如必填查询参数、带有更多元数据的查询参数），可以使用 FastAPI 提供的 Query 和 Path 函数。
  • 如果你需要定义请求体参数的更多元数据，可以使用 Body 函数。

让我们创建一个结合所有类型的例子（虽然前面的 PUT 例子已经包含了路径参数和请求体）：

“`python

main.py (在已有的代码基础上添加)

导入 Query 和 Path

from fastapi import FastAPI, Query, Path, Body
from pydantic import BaseModel

… (Item 模型和之前的 get/post/put 方法保持不变)

结合路径参数、查询参数和请求体

使用 Path 和 Query 可以添加参数的描述、示例等元数据，用于文档生成

@app.post(“/items/{item_id}/purchase/”)
async def purchase_item(
*, # 在此之后的所有参数都必须以关键字参数形式传递，增加代码清晰度
item_id: int = Path(…, title=”The ID of the item to purchase”, gt=0), # … 表示必填，gt=0 表示值必须大于0
q: str | None = Query(None, alias=”item-query”, description=”Query string for the item”), # alias 定义查询参数在 URL 中的名称
item: Item = Body(…, example={ # example 用于文档和 Try it out
“name”: “Awesome Gadget”,
“price”: 123.45,
“description”: “This is a super awesome gadget”,
“is_offer”: False
})
):
results = {“item_id”: item_id, “item”: item}
if q:
results.update({“q”: q})
return results

另一个结合例子：带可选路径参数、必填查询参数和请求体

注意可选路径参数需要在路径字符串中也定义为可选

例如： /users/{user_id}/ 或 /users/

这通常需要两个不同的路径操作函数来处理

或者使用更高级的路由技术，但对于初学者，分开写可能更清晰

示例：必填查询参数和请求体

from fastapi import Request # 导入 Request 类型

@app.post(“/login/”)
async def login(username: str = Query(…, description=”Username for login”),
password: str = Query(…, description=”Password for login”),
data: dict = Body(…, description=”Additional login data”)):
# 在实际应用中，这里会处理登录逻辑
return {“message”: “Login received”, “username”: username, “password”: password, “data”: data}
“`

保存文件，查看 /docs 文档。你会看到新的端点，并且 Path, Query, Body 中的 title, description, example, alias, gt 等元数据都体现在了文档中，这使得你的 API 文档更加完善和易懂。

使用 Path, Query, Body 的好处：

  • 提供额外的验证（如 gt=0, min_length, max_length, regex 等）。
  • 为参数添加元数据（如 title, description, example）。
  • 定义参数别名（alias），方便在 URL 中使用不同的名称。
  • 明确区分是查询参数还是请求体（即使类型相同）。

依赖注入 (Dependencies)

依赖注入是 FastAPI 的另一个强大特性，它提供了一种在路径操作函数中声明依赖关系的方式。一个“依赖”可以是一个函数、类或任何可调用对象，FastAPI 会在执行路径操作函数之前先执行这些依赖，并将依赖的结果作为参数传递给路径操作函数。

这在以下场景中非常有用：

  • 代码重用: 多个路径操作需要相同的逻辑（如数据库连接、用户认证、权限检查）。
  • 业务逻辑分割: 将复杂的业务逻辑分解为更小的、可重用的函数。
  • 测试: 方便地模拟或替换依赖进行单元测试。
  • 管理资源: 如数据库会话的创建和关闭。

使用 Depends 函数来声明依赖。

“`python

main.py (在已有的代码基础上添加)

from fastapi import FastAPI, Depends, HTTPException, status

… (之前的导入和代码)

模拟一个简单的用户认证依赖

async def get_current_user(api_key: str = Query(…, description=”API Key for authentication”)):
# 简单模拟验证逻辑
if api_key != “fake-api-key”:
# 如果认证失败，抛出 HTTPException
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail=”Invalid API Key”,
headers={“WWW-Authenticate”: “Bearer”}, # 常见的认证头
)
# 认证成功，返回一个用户对象（这里简化为一个字典）
return {“username”: “authenticated_user”, “roles”: [“admin”]}

定义一个需要认证的路径操作

@app.get(“/protected-data/”)

声明对 get_current_user 的依赖

FastAPI 会先调用 get_current_user，将其返回值作为 current_user 参数传递给 read_protected_data

async def read_protected_data(current_user: dict = Depends(get_current_user)):
# 如果代码执行到这里，说明 get_current_user 没有抛出异常，认证成功
return {“message”: “This is protected data”, “user”: current_user}

另一个依赖例子：共享参数逻辑

async def common_parameters(q: str | None = Query(None, description=”Common query string”), skip: int = 0, limit: int = 10):
return {“q”: q, “skip”: skip, “limit”: limit}

@app.get(“/dependent-items/”)

声明对 common_parameters 的依赖

common_parameters 的参数 (q, skip, limit) 会从请求的查询参数中获取并验证

然后将 common_parameters 的返回值 (一个字典) 作为 commons 参数传递

async def read_dependent_items(commons: dict = Depends(common_parameters)):
# 可以直接使用 commons 字典中的值
return {“message”: “Using common parameters”, “params”: commons}
“`

保存文件，查看 /docs 文档。你会发现 /protected-data/ 端点在参数中多了一个 api_key (来源于 get_current_user 的 Query 声明)，并且文档显示这是一个必填参数。

点击 “Try it out”，输入 fake-api-key 作为 api_key 并执行，你会看到成功响应。如果输入其他值，会收到 401 Unauthorized 错误。

同样，/dependent-items/ 端点会显示 q, skip, limit 这三个查询参数，这些参数的定义来自于 common_parameters 依赖函数。

依赖注入使得代码结构更加清晰，逻辑更容易组织和测试。

错误处理 (Error Handling)

前面我们看到了 FastAPI/Pydantic 自动处理数据验证错误（返回 422）。对于其他类型的错误，你可以使用 HTTPException 来抛出 HTTP 响应错误。

HTTPException 需要两个主要参数：

  • status_code: HTTP 状态码 (如 400, 404, 500)。FastAPI 提供了 fastapi.status 模块，其中包含所有标准 HTTP 状态码常量，推荐使用它来提高代码可读性。
  • detail: 一个字符串或任何可序列化对象，作为响应体中的错误详情。

修改 main.py：

“`python

main.py (在已有的代码基础上添加)

from fastapi import FastAPI, Depends, HTTPException, status

… (之前的导入和代码)

示例：根据 item_id 是否存在返回不同结果

fake_items_db = [{“item_name”: “Foo”}, {“item_name”: “Bar”}, {“item_name”: “Baz”}]

@app.get(“/items/{item_id}”)
def read_item(item_id: int):
if item_id >= len(fake_items_db):
# 如果 item_id 超出范围，抛出 404 Not Found 错误
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=”Item not found”)
# 如果存在，返回对应的 item
return fake_items_db[item_id]

… (其他代码)

“`

保存文件，等待服务器重载。

访问 http://127.0.0.1:8000/items/1 (索引 1 存在)。你会看到：

json
{"item_name": "Bar"}

访问 http://127.0.0.1:8000/items/3 (索引 3 不存在)。你会收到一个 404 Not Found 错误，响应体如下：

json
{"detail": "Item not found"}

抛出 HTTPException 是在 FastAPI 中处理 HTTP 错误的标准方式。

总结与下一步

恭喜你！你已经学习了 FastAPI 的核心基础知识，包括：

  • 安装和运行 FastAPI 应用。
  • 创建第一个 API 端点。
  • 理解自动生成的 API 文档 (Swagger UI, ReDoc)。
  • 处理路径参数和查询参数。
  • 使用 Pydantic 定义请求体和响应体，并进行数据验证。
  • 利用依赖注入重用代码和管理逻辑。
  • 处理 HTTP 错误。

这只是 FastAPI 功能的冰山一角。为了进一步提升你的 FastAPI 技能，你可以继续学习以下主题：

  • 数据库集成: 如何在 FastAPI 应用中连接和操作数据库（如 SQLAlchemy, Tortoise ORM, asyncpg）。
  • 认证与授权: 实现更复杂的认证方案（如 OAuth2, JWT）和权限控制。
  • 路由: 更高级的路由技术，如 APIRouter、子应用、标签分组。
  • 后台任务: 如何执行不阻塞主请求的后台任务。
  • 中间件: 如何在请求处理流程中插入自定义逻辑（如日志记录、CORS）。
  • 测试: 如何编写针对 FastAPI 应用的单元测试和集成测试。
  • 部署: 如何将你的 FastAPI 应用部署到生产环境（如 Docker, Heroku, AWS, Google Cloud）。
  • WebSocket: 构建实时通信应用。

FastAPI 官方文档非常全面且友好，是深入学习的最佳资源：https://fastapi.tiangolo.com/

现在，最好的学习方式就是动手实践！尝试根据本教程中学到的知识，构建一个简单的项目，例如一个待办事项列表 (Todo List) API，包含创建、读取、更新、删除待办事项的功能。

祝你在 FastAPI 的学习旅程中一切顺利！

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部