FastAPI 中文教程：Web API 开发快速上手 – wiki基地

作者： /

FastAPI 中文教程：Web API 开发快速上手

欢迎来到 FastAPI 的世界！如果您是 Python 开发者，渴望构建高性能、易于维护且能自动生成交互式文档的 Web API，那么 FastAPI 绝对是您的理想选择。它是一个现代、快速（高性能）的 Web 框架，用于构建基于标准 Python 类型提示的标准 Python API。本教程将带领您从零开始，一步步掌握 FastAPI 的核心概念和基本用法，让您快速具备开发 Web API 的能力。

1. 为什么选择 FastAPI？

在深入学习之前，我们先来了解一下 FastAPI 的优势，这能帮助您理解它为何如此受欢迎：

  • 高性能 (Performance): FastAPI 基于 Starlette (用于 Web 部分) 和 Pydantic (用于数据部分)。Starlette 是一个轻量级、高性能的 ASGI 框架，而 ASGI 是 Python 异步 Web 应用的新标准。结合 Uvicorn 这样的高性能 ASGI 服务器，FastAPI 可以达到与 Node.js 和 Go 相当的性能水平，甚至在某些测试中表现更优。
  • 开发效率高 (Fast to code): 从设计之初就考虑了开发者的便利性。通过强制使用 Python 类型提示，FastAPI 可以在运行时自动进行数据验证、序列化和文档生成，极大地减少了手动编写这些代码的时间。
  • 错误少 (Fewer bugs): 类型提示和 Pydantic 的数据模型提供了强大的数据验证能力。在数据进入您的业务逻辑之前，FastAPI 已经确保了数据的格式和类型是正确的，这能捕获大量的潜在错误，让您的代码更健壮。
  • 直观 (Intuitive): 代码结构清晰，大量依赖标准的 Python 特性（如类型提示），学习曲线相对平缓。
  • 易于使用 (Easy to use): 框架的设计非常简洁，核心概念易于理解和应用。
  • 自动生成交互式文档 (Automatic Docs): 这是 FastAPI 最令人惊叹的特性之一。只需通过类型提示定义好 API 的输入和输出，FastAPI 会基于 OpenAPI 标准自动生成精美的交互式 API 文档（Swagger UI）和另一种文档（ReDoc）。这意味着您无需额外编写或同步 API 文档，它始终与您的代码保持同步。
  • 基于开放标准 (Based on open standards): FastAPI 完全基于 OpenAPI (以前称为 Swagger) 和 JSON Schema 这些开放标准。这使得您的 API 更容易被其他工具和服务理解和集成。
  • 强大的依赖注入系统 (Dependency Injection): FastAPI 提供了一个非常强大且易于使用的依赖注入系统，使得管理数据库连接、身份验证、权限控制等横切关注点变得轻而易举，并显著提高了代码的可测试性。
  • 支持异步编程 (Async/await): FastAPI 天然支持 Python 的异步特性，可以轻松处理大量并发请求，对于 I/O 密集型任务（如数据库操作、网络请求）表现极佳。

总而言之，FastAPI 让您能够用更少的代码、更高的效率、更少的错误构建出高性能、功能完备且自带文档的 Web API。

2. 准备工作：环境搭建

在开始之前，您需要确保拥有一个干净的 Python 环境。强烈建议使用 Python 3.7 或更高版本，并使用虚拟环境来管理项目依赖。

2.1 安装 Python

请访问 Python 官网 下载并安装最新版本的 Python 3。

2.2 创建并激活虚拟环境

虚拟环境可以隔离不同项目的依赖，避免冲突。

使用 Python 内置的 venv 模块：

“`bash

在项目根目录创建名为 ‘venv’ 的虚拟环境

python -m venv venv

激活虚拟环境

Windows

.\venv\Scripts\activate

macOS/Linux

source venv/bin/activate
“`

激活虚拟环境后，您会看到终端提示符前面出现了虚拟环境的名称（例如 (venv)），表示您当前的操作都在这个独立的 Python 环境中。

2.3 安装 FastAPI 和 Uvicorn

在激活的虚拟环境中，使用 pip 安装 FastAPI 和 ASGI 服务器 Uvicorn。Uvicorn 是一个高性能的 ASGI 服务器，FastAPI 需要它来运行。我们通常安装 uvicorn[standard] 以包含一些可选的依赖，这在大多数情况下是推荐的。

bash
pip install fastapi uvicorn[standard]

至此，您的开发环境已经准备就绪。

3. 第一个 FastAPI 应用：Hello World

现在，让我们来创建您的第一个 FastAPI 应用程序。创建一个名为 main.py 的文件，并添加以下代码：

“`python

main.py

1. 从 fastapi 库导入 FastAPI 类

from fastapi import FastAPI

2. 创建一个 FastAPI 应用程序实例

这是一个核心对象，用于构建您的API

app = FastAPI()

3. 定义一个路径操作装饰器 (@app.get(“/”))

它指定了处理根路径(“/”)的GET请求的函数

@app.get(“/”)

4. 定义一个路径操作函数

当收到匹配的GET请求时，会调用这个函数

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

您可以在同一个文件中定义多个路径操作函数

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

定义一个带路径参数的GET请求

{item_id} 是一个路径参数

通过类型提示 item_id: int 告诉FastAPI这是一个整数

def read_item(item_id: int, q: str | None = None):
# 返回一个包含路径参数和查询参数的字典
return {“item_id”: item_id, “q”: q}

“`

代码解释：

  1. from fastapi import FastAPI: 导入 FastAPI 类。
  2. app = FastAPI(): 创建一个 FastAPI 类的实例。app 对象是您构建 API 的核心。
  3. @app.get("/"): 这是一个 Python 装饰器。它告诉 FastAPI，下面的函数将处理发送到应用程序根路径 (/) 的 HTTP GET 请求。FastAPI 提供了对应所有 HTTP 方法的装饰器：@app.post(), @app.put(), @app.delete(), @app.options(), @app.head(), @app.patch(), @app.trace()。
  4. def read_root():: 这是一个普通的 Python 函数，被称为路径操作函数。当用户访问 / 路径时，FastAPI 会调用这个函数。
  5. return {"Hello": "World"}: 函数返回一个 Python 字典。FastAPI 会自动将这个字典转换为 JSON 响应，并将 Content-Type 设置为 application/json。
  6. 第二个函数 read_item 演示了如何定义带路径参数（item_id）和查询参数（q）的路由。{item_id} 在路径中表示这是一个路径参数。通过函数的参数 item_id: int，我们使用 Python 类型提示指明 item_id 应该是整数。FastAPI 会自动验证收到的数据类型。q: str | None = None 定义了一个可选的字符串查询参数，其默认值为 None。

4. 运行 FastAPI 应用

现在，使用 Uvicorn 来运行您的应用。在终端中，确保您位于包含 main.py 文件的目录，并且虚拟环境已激活，然后运行以下命令：

bash
uvicorn main:app --reload

命令解释：

  • uvicorn: 运行 Uvicorn 服务器。
  • main:app: 告诉 Uvicorn 在 main.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]
INFO: Started server process [xxxxx]
INFO: Waiting for application startup.
INFO: Application startup complete.

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

5. 测试您的 API 并探索自动文档

现在，打开您的 Web 浏览器或使用工具（如 cURL、Postman、VS Code 的 REST Client 扩展）来测试您的 API。

  • 访问 http://127.0.0.1:8000: 您应该会看到 JSON 响应：{"Hello": "World"}。
  • 访问 http://127.0.0.1:8000/items/5: 您应该会看到 JSON 响应：{"item_id": 5, "q": null}。FastAPI 自动将 5 转换为了整数。
  • 访问 http://127.0.0.1:8000/items/5?q=somequery: 您应该会看到 JSON 响应：{"item_id": 5, "q": "somequery"}。

最令人兴奋的部分来了！ FastAPI 自动生成了交互式 API 文档。

  • 访问 http://127.0.0.1:8000/docs: 您会看到 Swagger UI。这是一个非常友好的界面，列出了您的所有 API 路径，您可以直接在浏览器中测试这些接口。

    • 在 Swagger UI 中，您会看到 / 和 /items/{item_id} 两个路径。
    • 点击 /items/{item_id} 展开详情。
    • 点击 “Try it out”。
    • 在 item_id 字段输入一个数字（例如 10）。
    • 在 q 字段输入一个字符串（例如 "testquery"）。
    • 点击 “Execute”。
    • 您将看到请求的 URL、cURL 命令、响应代码、响应头部以及 JSON 响应体。

  • 访问 http://127.0.0.1:8000/redoc: 您会看到另一种风格的 API 文档，通常更适合作为 API 参考手册。

这些文档是根据您的代码（特别是路径操作函数、类型提示和 Pydantic 模型）自动生成的，并且始终与您的代码保持同步。这极大地提高了开发效率和团队协作效率。

6. 处理请求数据：更进一步

前面的例子展示了路径参数和查询参数。在实际的 API 开发中，特别是对于 POST、PUT 请求，我们通常需要从请求体中接收数据，这些数据通常是 JSON 格式。FastAPI 使用 Pydantic 来优雅地处理这个问题。

6.1 使用 Pydantic 定义数据模型

Pydantic 是一个基于 Python 类型提示的数据验证和设置管理库。FastAPI 完美集成了 Pydantic。您可以定义 Pydantic BaseModel 类来表示您的数据结构。

创建一个新的文件 models.py (或者直接在 main.py 中定义，为了清晰起见，我们分文件)：

“`python

models.py

from pydantic import BaseModel
from typing import List, Optional # Optional is deprecated in Python 3.10+, use X | None

Python 3.9+ 使用 from typing import Optional

Python 3.10+ 推荐使用 类型 | None 的语法

例如 str | None

定义一个 Item 数据模型

class Item(BaseModel):
name: str
# description 可以是字符串，也可以是 None，默认为 None (可选字段)
description: str | None = None
price: float
# tax 也可以是可选的浮点数
tax: float | None = None
# 这是一个嵌套模型或一个列表
tags: List[str] = [] # 默认值为空列表

定义一个用户数据模型

class User(BaseModel):
username: str
full_name: str | None = None

“`

代码解释：

  • 我们从 pydantic 导入 BaseModel。
  • Item(BaseModel) 定义了一个名为 Item 的 Pydantic 模型，它继承自 BaseModel。
  • 模型中的每个属性都使用类型提示定义了其期望的数据类型（str, float, str | None, List[str]）。
  • 使用 | None (或 Python 3.9 及更早版本的 Optional) 和默认值 (= None, = []) 可以定义可选字段和具有默认值的字段。
  • 这些模型不仅用于数据验证，Pydantic 还会自动生成 JSON Schema，FastAPI 利用这些 Schema 来生成详细的 API 文档。

6.2 在路径操作中使用 Request Body

现在，我们在 main.py 中创建一个 POST 请求的路径操作，接收一个 Item 对象作为请求体。

修改 main.py：

“`python

main.py

from fastapi import FastAPI

导入我们刚刚定义的 Item 和 User 模型

from models import Item, User
from typing import List # 用于类型提示列表

app = FastAPI()

… (前面的 @app.get(“/”) 和 @app.get(“/items/{item_id}”) 保留)

定义一个处理POST请求的路径操作

@app.post(“/items/”)

函数参数 item: Item 表示期望请求体是一个符合 Item 模型的数据

FastAPI 会自动从请求体中读取JSON，并尝试将其转换为一个 Item 对象

def create_item(item: Item):
# 打印接收到的 Item 对象 (可选)
print(item)
# 您可以在这里对 item 进行处理，比如保存到数据库
# 返回接收到的 Item 对象作为响应
return item

一个更复杂的POST请求示例，结合路径参数和请求体

@app.post(“/users/{user_id}/items/”)
def create_user_item(user_id: int, item: Item):
# 可以在函数内访问路径参数 user_id 和 请求体中的 item 对象
return {“user_id”: user_id, “item”: item}

演示如何返回 Pydantic 模型作为响应体

@app.get(“/users/me”)
def read_user_me():
return {“username”: “fakecurrentuser”} # 注意：实际应用中应返回 User 模型实例

演示返回自定义响应模型 (虽然上面的例子也能工作，但显式定义响应模型更好)

需要导入 Response Model，不过在小例子中可以省略

from fastapi.responses import JSONResponse

from fastapi import Response # 用于更底层的控制

一个简单的PUT请求示例

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

接收路径参数 item_id 和 请求体 item (类型为 Item)

def update_item(item_id: int, item: Item):
# 在这里执行更新逻辑…
return {“item_id”: item_id, “item”: item}

“`

代码解释：

  • from models import Item: 导入在 models.py 中定义的 Item 模型。
  • @app.post("/items/"): 定义一个处理 /items/ 路径的 POST 请求。
  • def create_item(item: Item):: 定义路径操作函数。参数 item: Item 是关键。
    • item: 参数名称。
    • Item: 参数的类型提示，使用我们刚刚创建的 Pydantic 模型。
    • FastAPI 看到一个参数类型是继承自 BaseModel 的 Pydantic 模型时，它就知道这个参数应该从请求体中读取 JSON 数据，并将其解析、验证为这个模型的一个实例。
  • return item: 直接返回接收到的 Item 对象。FastAPI 会自动将其转换为 JSON 格式的响应。

测试 POST 请求：

重新启动 Uvicorn (uvicorn main:app --reload)。

访问 http://127.0.0.1:8000/docs 查看更新后的 Swagger UI。您会看到一个新的 POST /items/ 接口。

  • 点击 /items/ (POST 方法) 展开详情。
  • 点击 “Try it out”。
  • 在 “Request body” 部分，Swagger UI 会根据 Item 模型的定义自动生成一个示例 JSON 结构。

  • 修改示例 JSON，例如：

    json
    {
    "name": "My New Item",
    "description": "This is a great new item.",
    "price": 10.5,
    "tax": 1.5,
    "tags": ["tag1", "tag2"]
    }
    * 点击 “Execute”。
    * 您将看到发送的请求体和服务器返回的响应。如果数据格式正确，响应状态码应该是 200 或 201，响应体就是您发送的 JSON 数据。

数据验证的魔力：

尝试发送一个不符合 Item 模型的数据，例如：

json
{
"name": "Invalid Item",
"price": "not a number" // Price should be float
}

执行后，您将收到一个 422 Unprocessable Entity 响应，响应体中包含了详细的验证错误信息，指明 price 字段期望是数字但收到了字符串，以及 description 和 tax 是必填字段（如果我们没有设置默认值或使用 | None）。FastAPI 和 Pydantic 自动为您处理了这一切！

7. 结合 Path, Query 和 Body 参数

在同一个路径操作函数中，您可以同时使用路径参数、查询参数和请求体。FastAPI 能够根据参数的类型提示和定义方式自动识别它们来自哪里：

  • 路径参数: 定义在路径字符串中 (/items/{item_id})，并在函数参数中使用相同的名称和类型提示。
  • 查询参数: 未定义在路径字符串中，但作为函数参数定义，并使用基本类型（int, str, float, bool 等）或其组合（如 List[str]），并且没有默认值或者默认值不是 Body, Form, File 等特殊类型。它们会自动从 URL 的查询字符串中解析。
  • 请求体: 未定义在路径字符串中，但作为函数参数定义，使用继承自 BaseModel 的 Pydantic 模型作为类型提示。它会自动从请求体的 JSON 数据中解析。

修改 main.py 中的 /items/{item_id} GET 方法，使其也接受一个查询参数 q，我们已经在前面做到了。

再看 /users/{user_id}/items/ POST 方法：

python
@app.post("/users/{user_id}/items/")
def create_user_item(user_id: int, item: Item):
# 在这里执行创建用户的某个item的逻辑...
return {"user_id": user_id, "item": item}

这里 user_id: int 是路径参数，item: Item 是请求体参数。FastAPI 自动知道如何从 URL 和请求体中获取相应的数据并传递给函数。

8. 状态码

默认情况下，对于 GET、DELETE 请求，成功响应的状态码是 200 OK。对于 POST 请求，默认是 200 OK，但通常创建成功会使用 201 Created。PUT 请求通常是 200 OK 或 204 No Content。

您可以通过在路径操作装饰器中指定 status_code 参数来修改默认状态码：

“`python
from fastapi import status # 导入 status 模块，提供标准HTTP状态码常量

@app.post(“/items/”, status_code=status.HTTP_201_CREATED) # 使用 201 Created
def create_item(item: Item):
# … 创建 item 的逻辑
return item

@app.delete(“/items/{item_id}”, status_code=status.HTTP_204_NO_CONTENT) # 使用 204 No Content
def delete_item(item_id: int):
# … 删除 item 的逻辑
# 204 响应通常没有响应体
return {“message”: f”Item {item_id} deleted successfully”} # 注意：204 通常不返回body，FastAPI会警告，这里只是示例
# return Response(status_code=status.HTTP_204_NO_CONTENT) # 返回空响应体更符合204语义
“`

使用 fastapi.status 模块中的常量 (status.HTTP_200_OK, status.HTTP_201_CREATED 等) 是推荐的做法，它们比直接使用数字更具可读性。

9. 错误处理基础

FastAPI 会自动处理 Pydantic 验证错误，返回 422 Unprocessable Entity 响应。如果您想在业务逻辑中手动引发 HTTP 错误，可以使用 HTTPException：

“`python
from fastapi import HTTPException, status

@app.get(“/items/{item_id}”)
def read_item(item_id: int):
if item_id not in fake_items_db: # 假设 fake_items_db 是一个存储 item 的字典
# 抛出 HTTPException，状态码 404，附带详情信息
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=”Item not found”)
return fake_items_db[item_id]
“`

HTTPException 接受 status_code 和可选的 detail 参数，detail 会作为 JSON 响应中的错误描述。

10. 项目结构建议 (初步)

随着项目变大，将所有代码放在一个 main.py 文件中会变得难以管理。FastAPI 提供了 APIRouter 来帮助您组织代码。您可以将相关的路径操作函数分组到不同的文件中。

简单的项目结构示例：

.
├── main.py # FastAPI 应用主文件
├── models.py # Pydantic 数据模型
└── routers/ # 存放路由模块
├── __init__.py
├── items.py # 关于 item 的路由
└── users.py # 关于 user 的路由

在 routers/items.py 中：

“`python

routers/items.py

from fastapi import APIRouter, HTTPException, status
from typing import List # 如果需要列表类型提示
from models import Item # 导入数据模型

创建一个 APIRouter 实例

router = APIRouter(
prefix=”/items”, # 这个路由器下的所有路径都会加上前缀 /items
tags=[“items”], # 在文档中给这个路由器下的接口打上标签
responses={404: {“description”: “Not found”}}, # 这个路由器下接口共用的响应
)

假设一些假数据

fake_items_db = {“foo”: {“name”: “Foo”}, “bar”: {“name”: “Bar”}}

使用 router 装饰器定义路径操作

@router.get(“/”)
def read_items():
return [{“item_id”: “Foo”}, {“item_id”: “Bar”}] # 示例数据

@router.get(“/{item_id}”)
def read_item(item_id: str): # 注意这里 item_id 是字符串，对应 fake_items_db 的键
if item_id not in fake_items_db:
raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=”Item not found”)
return fake_items_db[item_id]

@router.post(“/”)
def create_item(item: Item):
# 实际应用中会将 item 保存到数据库
return item

“`

在 routers/users.py 中：

“`python

routers/users.py

from fastapi import APIRouter
from models import User # 导入用户模型

router = APIRouter(
prefix=”/users”,
tags=[“users”],
)

@router.get(“/”)
def read_users():
return [{“username”: “Rick”}, {“username”: “Morty”}]

@router.get(“/me”)
def read_user_me():
return {“username”: “fakecurrentuser”} # 示例

@router.get(“/{user_id}”)
def read_user(user_id: int):
return {“user_id”: user_id}
“`

在 main.py 中将这些路由器包含进来：

“`python

main.py

from fastapi import FastAPI

导入路由器模块

from routers import items, users

app = FastAPI()

在应用中包含路由器

这样 routers/items.py 中的所有路径操作就会被添加到主应用中

app.include_router(items.router)
app.include_router(users.router)

您仍然可以在 main.py 中定义顶层路径，例如根路径

@app.get(“/”)
def read_root():
return {“message”: “Welcome to the API”}

“`

现在，运行 uvicorn main:app --reload，访问 /docs，您会看到接口根据 tags 分类，并且 /items 和 /users 的接口都已正确注册。

11. 依赖注入 (Dependencies) 简介

FastAPI 强大的依赖注入系统是其另一个亮点。它允许您声明依赖项（可以是一个函数、一个类或其他可调用对象），FastAPI 会自动解决这些依赖并在需要时将其“注入”到路径操作函数中。这在实现以下功能时非常有用：

  • 数据库会话
  • 身份验证和授权
  • 配置加载
  • 分页逻辑
  • 共享业务逻辑

例如，实现一个简单的 API Key 认证：

“`python

main.py (或其他地方)

from fastapi import FastAPI, Depends, HTTPException, status, Header

假设这是一个存储有效 API Key 的集合

API_KEYS = [“fakeapikey”]

定义一个依赖函数，用于验证 API Key

这个函数接收一个 header 参数 X-API-Key

async def verify_api_key(x_api_key: str = Header(…, alias=”X-API-Key”)):
if x_api_key not in API_KEYS:
raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail=”Invalid API Key”)
return x_api_key # 返回验证成功的值 (可选)

app = FastAPI()

@app.get(“/protected”)

使用 Depends() 将 verify_api_key 函数声明为依赖

在调用 read_protected_data 之前，verify_api_key 会先被执行

如果 verify_api_key 抛出 HTTPException，请求会中止并返回错误响应

如果 verify_api_key 正常返回，它的返回值会传递给 api_key 参数 (这里我们没有接收)

def read_protected_data(api_key: str = Depends(verify_api_key)):
return {“message”: “This is protected data”}

您也可以在 APIRouter 中定义依赖

router = APIRouter(dependencies=[Depends(verify_api_key)])

“`

代码解释：

  • async def verify_api_key(...): 定义一个异步函数作为依赖。
  • x_api_key: str = Header(..., alias="X-API-Key"): 使用 Header 标记这个参数来自请求头部，alias="X-API-Key" 指定了头部名称。... 表示它是必需的。
  • raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid API Key"): 如果验证失败，抛出 401 未授权错误。
  • @app.get("/protected"): 定义受保护的路径。
  • api_key: str = Depends(verify_api_key): 关键部分！Depends(verify_api_key) 将 verify_api_key 函数声明为 read_protected_data 的依赖。FastAPI 会在执行 read_protected_data 之前调用 verify_api_key。如果 verify_api_key 正常返回，它的返回值（这里是验证成功的 API Key）会被传递给 read_protected_data 函数的 api_key 参数。即使您不需要在 read_protected_data 函数中使用 verify_api_key 的返回值，仅仅声明 Depends(verify_api_key) 也能确保该依赖被执行（常用于认证或权限检查）。

依赖注入是一个非常强大和灵活的特性，值得在您更深入学习 FastAPI 时花时间掌握。

12. 下一步去哪里？

恭喜您！您已经掌握了 FastAPI 的核心基础知识，包括：

  • 了解了 FastAPI 的优势。
  • 搭建了开发环境。
  • 创建并运行了第一个应用。
  • 理解了路径操作、路径参数和查询参数。
  • 使用 Pydantic 处理了请求体。
  • 看到了自动生成的交互式 API 文档。
  • 学习了如何设置状态码和处理基本错误。
  • 了解了使用 APIRouter 组织项目的初步方法。
  • 对依赖注入有了初步认识。

这仅仅是 FastAPI 功能的冰山一角。为了构建更强大、更完整的 Web API，接下来您可以继续学习：

  • 数据库集成: 如何将 FastAPI 与数据库（如 PostgreSQL, MySQL, MongoDB 等）结合使用，通常会涉及 SQLAlchemy 或其他 ORM/ODM。
  • 异步数据库操作: 如何使用 async/await 与异步数据库驱动进行交互。
  • 更高级的依赖注入: 学习 yield 依赖、类作为依赖等更高级的用法。
  • 身份验证和授权: 实现用户注册、登录、JWT 认证、OAuth2 等。
  • 表单数据: 处理 application/x-www-form-urlencoded 和 multipart/form-data 数据。
  • 文件上传: 如何接收上传的文件。
  • 中间件 (Middleware): 在请求到达路径操作之前或响应返回之后执行通用逻辑（如日志记录、CORS 处理）。
  • 后台任务 (Background Tasks): 处理不需要立即返回给客户端的任务。
  • WebSocket: 构建实时通信应用。
  • 测试: 如何为您的 FastAPI 应用编写自动化测试。
  • 部署: 如何将您的 FastAPI 应用部署到生产环境（如 Docker, Kubernetes, 云服务器等）。

总结

FastAPI 是一个极其高效且功能强大的 Python Web 框架，它利用现代 Python 特性（如类型提示）极大地提高了开发效率、代码质量和应用性能。其自动生成的交互式文档和强大的依赖注入系统更是开发者青睐它的重要原因。

本教程只是一个快速入门指南，希望能帮助您迈出第一步。最好的学习方法是动手实践，尝试构建您自己的 API 项目。

强烈建议您查阅 FastAPI 官方文档: https://fastapi.tiangolo.com/zh/ (有完善的中文文档！) 这是最权威、最详细的学习资源。

祝您在 FastAPI 的世界里开发愉快！

发表评论

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

滚动至顶部