fastapi · YuriiMotov · Jun 9, 2026 · Jun 9, 2026 · Jun 9, 2026
diff --git a/docs/zh/docs/advanced/wsgi.md b/docs/zh/docs/advanced/wsgi.md
@@ -1,48 +1,48 @@
-# 包含 WSGI - Flask，Django，其它 { #including-wsgi-flask-django-others }
+# 集成 WSGI - Flask、Django 等 { #including-wsgi-flask-django-others }
 
-您可以挂载 WSGI 应用，正如您在 [子应用 - 挂载](sub-applications.md)、[在代理之后](behind-a-proxy.md) 中所看到的那样。
+你可以像在 [子应用 - 挂载](sub-applications.md)、[在代理后](behind-a-proxy.md) 里那样挂载 WSGI 应用。
 
-为此, 您可以使用 `WSGIMiddleware` 来包装你的 WSGI 应用，如：Flask，Django，等等。
+为此，用 `WSGIMiddleware` 包一层你的 WSGI 应用，比如 Flask、Django 等。
 
 ## 使用 `WSGIMiddleware` { #using-wsgimiddleware }
 
-/// info | 信息
+/// note | 注意
 
-需要安装 `a2wsgi`，例如使用 `pip install a2wsgi`。
+需要先安装 `a2wsgi`，比如运行 `pip install a2wsgi`。
 
 ///
 
-您需要从 `a2wsgi` 导入 `WSGIMiddleware`。
+从 `a2wsgi` 导入 `WSGIMiddleware`。
 
-然后使用该中间件包装 WSGI 应用（例如 Flask）。
+然后用这个中间件包住 WSGI 应用（比如 Flask）。
 
-之后将其挂载到某一个路径下。
+再把它挂载到某个路径下。
 
 {* ../../docs_src/wsgi/tutorial001_py310.py hl[1,3,23] *}
 
 /// note | 注意
 
-之前推荐使用 `fastapi.middleware.wsgi` 中的 `WSGIMiddleware`，但它现在已被弃用。
+以前推荐用 `fastapi.middleware.wsgi` 里的 `WSGIMiddleware`，现在已弃用。
 
-建议改用 `a2wsgi` 包，使用方式保持不变。
+建议改用 `a2wsgi` 包。用法不变。
 
-只要确保已安装 `a2wsgi` 包，并且从 `a2wsgi` 正确导入 `WSGIMiddleware` 即可。
+只要确保安装了 `a2wsgi`，并从 `a2wsgi` 正确导入 `WSGIMiddleware`。
 
 ///
 
-## 检查 { #check-it }
+## 试一下 { #check-it }
 
-现在，所有定义在 `/v1/` 路径下的请求将会被 Flask 应用处理。
+现在，路径 `/v1/` 下的请求都会由 Flask 应用处理。
 
-其余的请求则会被 **FastAPI** 处理。
+其他路径走 **FastAPI**。
 
-如果你运行它并访问 [http://localhost:8000/v1/](http://localhost:8000/v1/)，你将会看到由 Flask 返回的响应：
+运行后，打开 [http://localhost:8000/v1/](http://localhost:8000/v1/)，能看到来自 Flask 的响应：
 
 ```txt
 Hello, World from Flask!
 ```
 
-如果你访问 [http://localhost:8000/v2](http://localhost:8000/v2)，你将会看到由 FastAPI 返回的响应：
+打开 [http://localhost:8000/v2](http://localhost:8000/v2)，能看到来自 FastAPI 的响应：
 
 ```JSON
 {

diff --git a/docs/zh/docs/index.md b/docs/zh/docs/index.md
diff --git a/docs/zh/docs/tutorial/background-tasks.md b/docs/zh/docs/tutorial/background-tasks.md
@@ -1,84 +1,84 @@
 # 后台任务 { #background-tasks }
 
-你可以定义在返回响应后运行的后台任务。
+你可以定义后台任务。它会在返回响应之后运行。
 
-这对需要在请求之后执行的操作很有用，但客户端不必在接收响应之前等待操作完成。
+这适合那些请求后需要做，但没必要让客户端等着的操作。
 
-包括这些例子：
+比如：
 
-* 执行操作后发送的电子邮件通知：
-    * 由于连接到电子邮件服务器并发送电子邮件往往很“慢”（几秒钟），您可以立即返回响应并在后台发送电子邮件通知。
+* 动作完成后发邮件通知：
+    * 连接邮件服务器并发送邮件比较慢（要几秒）。可以先返回响应，把发邮件放到后台跑。
 * 处理数据：
-    * 例如，假设您收到的文件必须经过一个缓慢的过程，您可以返回一个"Accepted"(HTTP 202)响应并在后台处理它。
+    * 比如你收到一个需要慢处理的文件。可以先返回 "Accepted"（HTTP 202），把文件在后台处理。
 
 ## 使用 `BackgroundTasks` { #using-backgroundtasks }
 
-首先导入 `BackgroundTasks` 并在 *路径操作函数* 中使用类型声明 `BackgroundTasks` 定义一个参数：
+先导入 `BackgroundTasks`。在你的*路径操作函数*里声明一个类型为 `BackgroundTasks` 的参数：
 
 {* ../../docs_src/background_tasks/tutorial001_py310.py hl[1,13] *}
 
-**FastAPI** 会创建一个 `BackgroundTasks` 类型的对象并作为该参数传入。
+**FastAPI** 会帮你创建 `BackgroundTasks` 实例，并注入到这个参数里。
 
-## 创建一个任务函数 { #create-a-task-function }
+## 写任务函数 { #create-a-task-function }
 
-创建要作为后台任务运行的函数。
+写一个要在后台跑的函数。
 
-它只是一个可以接收参数的标准函数。
+就是普通函数。可以接收参数。
 
-它可以是 `async def` 或普通的 `def` 函数，**FastAPI** 知道如何正确处理。
+可以是 `async def`，也可以是普通 `def`。**FastAPI** 都能正确处理。
 
-在这种情况下，任务函数将写入一个文件（模拟发送电子邮件）。
+这个例子里，任务函数会写文件（模拟发邮件）。
 
-由于写操作不使用 `async` 和 `await`，我们用普通的 `def` 定义函数：
+写文件不需要 `async/await`，所以用普通 `def`：
 
 {* ../../docs_src/background_tasks/tutorial001_py310.py hl[6:9] *}
 
 ## 添加后台任务 { #add-the-background-task }
 
-在你的 *路径操作函数* 里，用 `.add_task()` 方法将任务函数传到 *后台任务* 对象中：
+在你的*路径操作函数*里，用 `.add_task()` 把任务函数加到 `BackgroundTasks` 对象里：
 
 {* ../../docs_src/background_tasks/tutorial001_py310.py hl[14] *}
 
-`.add_task()` 接收以下参数：
+`.add_task()` 的参数：
 
-* 在后台运行的任务函数(`write_notification`)。
-* 应按顺序传递给任务函数的任意参数序列(`email`)。
-* 应传递给任务函数的任意关键字参数(`message="some notification"`)。
+* 要在后台运行的任务函数（`write_notification`）。
+* 按位置传给任务函数的参数序列（`email`）。
+* 传给任务函数的关键字参数（`message="some notification"`）。
 
 ## 依赖注入 { #dependency-injection }
 
-使用 `BackgroundTasks` 也适用于依赖注入系统，你可以在多个级别声明 `BackgroundTasks` 类型的参数：在 *路径操作函数* 里，在依赖中(可依赖)，在子依赖中，等等。
+配合依赖注入也能用。你可以在多层级声明 `BackgroundTasks` 参数：在*路径操作函数*、依赖、子依赖等。
 
-**FastAPI** 知道在每种情况下该做什么以及如何复用同一对象，因此所有后台任务被合并在一起并且随后在后台运行：
+**FastAPI** 会复用同一个对象。把各处添加的后台任务合并。等响应发出后再统一执行：
 
 {* ../../docs_src/background_tasks/tutorial002_an_py310.py hl[13,15,22,25] *}
 
-该示例中，信息会在响应发出 *之后* 被写到 `log.txt` 文件。
+这个示例里，响应发出后才把消息写进 `log.txt`。
 
-如果请求中有查询，它将在后台任务中写入日志。
+如果请求里有 query，会由后台任务写入日志。
 
-然后另一个在 *路径操作函数* 生成的后台任务会使用路径参数 `email` 写入一条信息。
+然后路径操作函数里再加一个后台任务。它会用 `email` 路径参数写一条消息。
 
 ## 技术细节 { #technical-details }
 
-`BackgroundTasks` 类直接来自 [`starlette.background`](https://www.starlette.dev/background/)。
+`BackgroundTasks` 类来自 [`starlette.background`](https://www.starlette.dev/background/)。
 
-它被直接导入/包含到FastAPI以便你可以从 `fastapi` 导入，并避免意外从 `starlette.background` 导入备用的 `BackgroundTask` (后面没有 `s`)。
+它在 FastAPI 里被直接导出。这样你可以从 `fastapi` 导入，避免不小心从 `starlette.background` 导入另一个 `BackgroundTask`（没有结尾的 s）。
 
-通过仅使用 `BackgroundTasks` (而不是 `BackgroundTask`)，使得能将它作为 *路径操作函数* 的参数 ，并让**FastAPI**为您处理其余部分, 就像直接使用 `Request` 对象。
+只用 `BackgroundTasks`（不是 `BackgroundTask`）时，就能把它当作*路径操作函数*的参数。剩下的交给 **FastAPI**，跟直接用 `Request` 类似。
 
-在FastAPI中仍然可以单独使用 `BackgroundTask`，但您必须在代码中创建对象，并返回包含它的Starlette `Response`。
+当然也能在 FastAPI 里单独用 `BackgroundTask`。但你要自己创建对象，并返回包含它的 Starlette `Response`。
 
-更多细节查看 [Starlette 后台任务的官方文档](https://www.starlette.dev/background/)。
+更多细节看 [Starlette 的 Background Tasks 文档](https://www.starlette.dev/background/)。
 
-## 告诫 { #caveat }
+## 注意事项 { #caveat }
 
-如果您需要执行繁重的后台计算，并且不一定需要由同一进程运行（例如，您不需要共享内存、变量等），那么使用其他更大的工具（如 [Celery](https://docs.celeryq.dev)）可能更好。
+如果后台计算很重，而且不需要在同一进程里跑（不需要共享内存、变量等），用更大的工具会更好，比如 [Celery](https://docs.celeryq.dev)。
 
-它们往往需要更复杂的配置，即消息/作业队列管理器，如RabbitMQ或Redis，但它们允许您在多个进程中运行后台任务，甚至是在多个服务器中。
+它们配置更复杂。需要消息/任务队列管理器，比如 RabbitMQ 或 Redis。好处是能在多个进程，尤其是多台服务器上跑后台任务。
 
-但是，如果您需要从同一个**FastAPI**应用程序访问变量和对象，或者您需要执行小型后台任务（如发送电子邮件通知），您只需使用 `BackgroundTasks` 即可。
+但如果你要访问同一个 **FastAPI** 应用里的变量和对象。或者任务很轻（比如发邮件通知）。用 `BackgroundTasks` 就够了。
 
 ## 回顾 { #recap }
 
-导入并使用 `BackgroundTasks` 通过 *路径操作函数* 中的参数和依赖项来添加后台任务。
+在*路径操作函数*和依赖里导入并使用 `BackgroundTasks` 参数，给应用添加后台任务。
diff --git a/docs/zh/docs/tutorial/body-multiple-params.md b/docs/zh/docs/tutorial/body-multiple-params.md
@@ -1,24 +1,24 @@
-# 请求体 - 多个参数 { #body-multiple-parameters }
+# Body - 多个参数 { #body-multiple-parameters }
 
-既然我们已经知道了如何使用 `Path` 和 `Query`，下面让我们来了解一下请求体声明的更高级用法。
+前面看了 `Path` 和 `Query`。现在来看更高级的请求体声明用法。
 
-## 混合使用 `Path`、`Query` 和请求体参数 { #mix-path-query-and-body-parameters }
+## 混用 `Path`、`Query` 和请求体参数 { #mix-path-query-and-body-parameters }
 
-首先，毫无疑问地，你可以随意地混合使用 `Path`、`Query` 和请求体参数声明，**FastAPI** 会知道该如何处理。
+先说结论。`Path`、`Query` 和请求体参数可以随意混用。**FastAPI** 会自己分辨。
 
-你还可以通过将默认值设置为 `None` 来将请求体参数声明为可选参数：
+Body 参数也能是可选的。把默认值设为 `None` 就行：
 
 {* ../../docs_src/body_multiple_params/tutorial001_an_py310.py hl[18:20] *}
 
 /// note | 注意
 
-请注意，在这种情况下，将从请求体获取的 `item` 是可选的。因为它的默认值为 `None`。
+注意，这里从请求体取出的 `item` 是可选的。因为它的默认值是 `None`。
 
 ///
 
 ## 多个请求体参数 { #multiple-body-parameters }
 
-在上面的示例中，*路径操作*将期望一个具有 `Item` 的属性的 JSON 请求体，就像：
+上个例子里，*路径操作* 期望收到一个包含 `Item` 属性的 JSON：
 
 ```JSON
 {
@@ -29,13 +29,13 @@
 }
 ```
 
-但是你也可以声明多个请求体参数，例如 `item` 和 `user`：
+也可以声明多个请求体参数，比如 `item` 和 `user`：
 
 {* ../../docs_src/body_multiple_params/tutorial002_py310.py hl[20] *}
 
-在这种情况下，**FastAPI** 将注意到该函数中有多个请求体参数（两个 Pydantic 模型参数）。
+这时函数里有不止一个请求体参数（两个都是 Pydantic 模型）。**FastAPI** 会识别出来。
 
-因此，它将使用参数名称作为请求体中的键（字段名称），并期望一个类似于以下内容的请求体：
+它会用参数名作为请求体里的键（字段名）。期望的请求体长这样：
 
 ```JSON
 {
@@ -54,27 +54,27 @@
 
 /// note | 注意
 
-请注意，即使 `item` 的声明方式与之前相同，但现在它被期望通过 `item` 键内嵌在请求体中。
+注意，`item` 的声明和之前一样。现在它需要包在请求体的 `item` 键里。
 
 ///
 
-**FastAPI** 将自动对请求中的数据进行转换，因此 `item` 参数将接收指定的内容，`user` 参数也是如此。
+**FastAPI** 会把请求自动转换。`item` 和 `user` 各拿到各自的内容。
 
-它将执行对复合数据的校验，并且像现在这样为 OpenAPI 模式和自动化文档对其进行记录。
+它会校验组合数据。还会按这个结构生成 OpenAPI 模式和自动文档。
 
-## 请求体中的单一值 { #singular-values-in-body }
+## 请求体里的单个值 { #singular-values-in-body }
 
-与使用 `Query` 和 `Path` 为查询参数和路径参数定义额外数据的方式相同，**FastAPI** 提供了一个同等的 `Body`。
+就像有 `Query`、`Path` 用来给查询参数和路径参数加额外信息。**FastAPI** 也提供了等价的 `Body`。
 
-例如，为了扩展先前的模型，你可能决定除了 `item` 和 `user` 之外，还想在同一请求体中具有另一个键 `importance`。
+比如，在上面的模型上再加一个同级的键 `importance`，和 `item`、`user` 并列。
 
-如果你就按原样声明它，因为它是一个单一值，**FastAPI** 将假定它是一个查询参数。
+如果直接这么声明。因为它是单个值，**FastAPI** 会把它当成查询参数。
 
-但是你可以使用 `Body` 指示 **FastAPI** 将其作为请求体的另一个键进行处理。
+但你可以用 `Body` 告诉 **FastAPI** 把它当成请求体里的另一个键：
 
 {* ../../docs_src/body_multiple_params/tutorial003_an_py310.py hl[23] *}
 
-在这种情况下，**FastAPI** 将期望像这样的请求体：
+这时，**FastAPI** 期望的请求体是：
 
 ```JSON
 {
@@ -92,45 +92,45 @@
 }
 ```
 
-同样的，它将转换数据类型，校验，生成文档等。
+同样会做类型转换、校验和文档生成。
 
-## 多个请求体参数和查询参数 { #multiple-body-params-and-query }
+## 多个请求体参数配合查询参数 { #multiple-body-params-and-query }
 
-当然，除了请求体参数外，你还可以在任何需要的时候声明额外的查询参数。
+当然，也可以在有请求体参数时再加查询参数。
 
-由于默认情况下单一值会被解释为查询参数，因此你不必显式地添加 `Query`，你可以这样写：
+默认单个值会被当成查询参数。你不必显式用 `Query`，直接写：
 
 ```Python
 q: str | None = None
 ```
 
-比如：
+例如：
 
 {* ../../docs_src/body_multiple_params/tutorial004_an_py310.py hl[28] *}
 
-/// info | 信息
+/// note | 注意
 
-`Body` 同样具有与 `Query`、`Path` 以及其他后面将看到的类完全相同的额外校验和元数据参数。
+`Body` 也支持和 `Query`、`Path` 一样的额外校验和元数据参数。后面会用到。
 
 ///
 
-## 嵌入单个请求体参数 { #embed-a-single-body-parameter }
+## 嵌套单个请求体参数 { #embed-a-single-body-parameter }
 
-假设你只有一个来自 Pydantic 模型 `Item` 的请求体参数 `item`。
+假设你只有一个 Pydantic 模型 `Item` 的 `item` 请求体参数。
 
-默认情况下，**FastAPI** 将直接期望这样的请求体。
+默认会直接期望模型本身作为请求体。
 
-但是，如果你希望它期望一个拥有 `item` 键并在值中包含模型内容的 JSON，就像在声明额外的请求体参数时所做的那样，则可以使用一个特殊的 `Body` 参数 `embed`：
+但如果你想让它期望一个带 `item` 键的 JSON。模型内容放在这个键里。就像有额外请求体参数时那样。可以用 `Body` 的特殊参数 `embed`：
 
 ```Python
-item: Item = Body(embed=True)
+item: Annotated[Item, Body(embed=True)]
 ```
 
-比如：
+例如：
 
 {* ../../docs_src/body_multiple_params/tutorial005_an_py310.py hl[17] *}
 
-在这种情况下，**FastAPI** 将期望像这样的请求体：
+这时 **FastAPI** 期望的请求体是：
 
 ```JSON hl_lines="2"
 {
@@ -154,12 +154,12 @@ item: Item = Body(embed=True)
 }
 ```
 
-## 总结 { #recap }
+## 小结 { #recap }
 
-你可以添加多个请求体参数到*路径操作函数*中，即使一个请求只能有一个请求体。
+即使一个请求只有一个请求体。你也能在路径操作函数里声明多个请求体参数。
 
-但是 **FastAPI** 会处理它，在函数中为你提供正确的数据，并在*路径操作*中校验并记录正确的模式。
+**FastAPI** 会处理好这些映射。把正确的数据传给函数。并校验并在路径操作里生成正确的模式文档。
 
-你还可以声明将作为请求体的一部分所接收的单一值。
+你也能把单个值声明为请求体的一部分。
 
-你还可以指示 **FastAPI** 在仅声明了一个请求体参数的情况下，将原本的请求体嵌入到一个键中。
+只有一个参数时。也可以让 **FastAPI** 把它嵌在某个键里。