diff --git a/docs/zh/docs/index.md b/docs/zh/docs/index.md
index 138d8bd60..897fd45fb 100644
--- a/docs/zh/docs/index.md
+++ b/docs/zh/docs/index.md
@@ -1,7 +1,3 @@
-
-{!../../../docs/missing-translation.md!}
-
-
@@ -25,80 +21,80 @@
---
-**Documentation**: https://fastapi.tiangolo.com
+**文档**： https://fastapi.tiangolo.com
-**Source Code**: https://github.com/tiangolo/fastapi
+**源码**： https://github.com/tiangolo/fastapi
---
-FastAPI is a modern, fast (high-performance), web framework for building APIs with Python 3.6+ based on standard Python type hints.
+FastAPI 是一个用于构建 API 的现代、快速（高性能）的 web 框架，使用基于类型提示的 Python 3.6 及更高版本。
-The key features are:
+关键特性:
-* **Fast**: Very high performance, on par with **NodeJS** and **Go** (thanks to Starlette and Pydantic). [One of the fastest Python frameworks available](#performance).
+* **快速**：可与 **NodeJS** 和 **Go** 比肩的极高性能（归功于 Starlette 和 Pydantic）。[最快的 Python web 框架之一](#_11)。
-* **Fast to code**: Increase the speed to develop features by about 200% to 300% *.
-* **Fewer bugs**: Reduce about 40% of human (developer) induced errors. *
-* **Intuitive**: Great editor support. Completion everywhere. Less time debugging.
-* **Easy**: Designed to be easy to use and learn. Less time reading docs.
-* **Short**: Minimize code duplication. Multiple features from each parameter declaration. Fewer bugs.
-* **Robust**: Get production-ready code. With automatic interactive documentation.
-* **Standards-based**: Based on (and fully compatible with) the open standards for APIs: OpenAPI (previously known as Swagger) and JSON Schema.
+* **高效编码**：提高功能开发速度约 200％ 至 300％。*
+* **更少 bug**：减少约 40％ 的人为（开发者）导致错误。*
+* **智能**：极佳的编辑器支持。处处皆可自动补全，减少调试时间。
+* **简单**：设计的易于使用和学习，减少阅读文档时间。
+* **简短**：减少代码重复。通过不同的参数声明实现丰富功能。bug 更少。
+* **健壮**：生产可用级别的代码。以及自动生成的交互式文档。
+* **标准化**：基于 API 的相关开放标准并完全兼容：OpenAPI (以前被称为 Swagger) 和 JSON Schema。
-* estimation based on tests on an internal development team, building production applications.
+* 根据对某个构建线上应用的内部开发团队所进行的测试估算得出。
-## Opinions
+## 评价
-"*[...] I'm using **FastAPI** a ton these days. [...] I'm actually planning to use it for all of my team's **ML services at Microsoft**. Some of them are getting integrated into the core **Windows** product and some **Office** products.*"
+"*[...] 最近我一直在使用 **FastAPI**。[...] 实际上我正在计划将其用于我所在的微软团队的所有**机器学习服务**。其中一些服务正被集成进 **Windows** 核心产品和一些 **Office** 产品。*"
-Kabir Khan -
Microsoft (ref)Piero Molino, Yaroslav Dudin, and Sai Sumanth Miryala -
Uber (ref)Piero Molino， Yaroslav Dudin 和 Sai Sumanth Miryala -
Uber (ref)
-If you are building a CLI app to be used in the terminal instead of a web API, check out **Typer**.
+如果你正在开发一个在终端中运行的命令行应用而不是 web API，不妨试下 **Typer**。
-**Typer** is FastAPI's little sibling. And it's intended to be the **FastAPI of CLIs**. ⌨️ 🚀
+**Typer** 是 FastAPI 的小伙伴。它打算成为**命令行中的 FastAPI**。 ⌨️ 🚀
-## Requirements
+## 依赖
-Python 3.6+
+Python 3.6 及更高版本
-FastAPI stands on the shoulders of giants:
+FastAPI 站在以下巨人的肩膀之上：
-* Starlette for the web parts.
-* Pydantic for the data parts.
+* Starlette负责 web 部分。
+* Pydantic负责数据部分。
-## Installation
+## 安装
@@ -110,7 +106,7 @@ $ pip install fastapi
-You will also need an ASGI server, for production such as Uvicorn or Hypercorn.
+你还需要一个 ASGI 服务器，生产环境可以使用 Uvicorn 或者 Hypercorn。
@@ -122,11 +118,11 @@ $ pip install uvicorn
-## Example
+## 示例
-### Create it
+### 创建
-* Create a file `main.py` with:
+* 创建一个 `main.py` 文件并写入以下内容:
```Python
from fastapi import FastAPI
@@ -145,9 +141,9 @@ def read_item(item_id: int, q: str = None):
```
-Or use async def...
+或者使用 async def...
-If your code uses `async` / `await`, use `async def`:
+如果你的代码里会出现 `async` / `await`，应使用 `async def`：
```Python hl_lines="7 12"
from fastapi import FastAPI
@@ -167,13 +163,13 @@ async def read_item(item_id: int, q: str = None):
**Note**:
-If you don't know, check the _"In a hurry?"_ section about `async` and `await` in the docs.
+如果你不知道是否会用到，可以查看文档的 _"In a hurry?"_ 章节中 关于 `async` 和 `await` 的部分。
-### Run it
+### 运行
-Run the server with:
+通过以下命令运行服务器：
@@ -190,54 +186,54 @@ $ uvicorn main:app --reload
-About the command uvicorn main:app --reload...
+关于 uvicorn main:app --reload 命令......
-The command `uvicorn main:app` refers to:
+ `uvicorn main:app` 命令含义如下:
-* `main`: the file `main.py` (the Python "module").
-* `app`: the object created inside of `main.py` with the line `app = FastAPI()`.
-* `--reload`: make the server restart after code changes. Only do this for development.
+* `main`：`main.py` 文件（一个 Python "模块"）。
+* `app`：在 `main.py` 文件中通过 `app = FastAPI()` 创建的对象。
+* `--reload`：让服务器在更新代码后重新启动。仅在开发时使用该选项。
-### Check it
+### 检查
-Open your browser at http://127.0.0.1:8000/items/5?q=somequery.
+使用浏览器访问 http://127.0.0.1:8000/items/5?q=somequery。
-You will see the JSON response as:
+你将会看到如下 JSON 响应：
```JSON
{"item_id": 5, "q": "somequery"}
```
-You already created an API that:
+你已经创建了一个具有以下功能的 API：
-* Receives HTTP requests in the _paths_ `/` and `/items/{item_id}`.
-* Both _paths_ take `GET` operations (also known as HTTP _methods_).
-* The _path_ `/items/{item_id}` has a _path parameter_ `item_id` that should be an `int`.
-* The _path_ `/items/{item_id}` has an optional `str` _query parameter_ `q`.
+* 通过 _路径_ `/` 和 `/items/{item_id}` 接受 HTTP 请求。
+* 以上 _路径_ 都接受 `GET` 操作（也被称为 HTTP _方法_）。
+* `/items/{item_id}` _路径_ 有一个 _路径参数_ `item_id` 并且应该为 `int` 类型。
+* `/items/{item_id}` _路径_ 有一个可选的 `str` 类型的 _查询参数_ `q`。
-### Interactive API docs
+### 交互式 API 文档
-Now go to http://127.0.0.1:8000/docs.
+现在访问 http://127.0.0.1:8000/docs。
-You will see the automatic interactive API documentation (provided by Swagger UI):
+你会看到自动生成的交互式 API 文档（由 Swagger UI生成）：
-### Alternative API docs
+### 备选 API 文档
-And now, go to http://127.0.0.1:8000/redoc.
+访问 http://127.0.0.1:8000/redoc。
-You will see the alternative automatic documentation (provided by ReDoc):
+你会看到另一个自动生成的文档（由 ReDoc）生成：
-## Example upgrade
+## 升级示例
-Now modify the file `main.py` to receive a body from a `PUT` request.
+修改 `main.py` 文件来从 `PUT` 请求中接收请求体。
-Declare the body using standard Python types, thanks to Pydantic.
+我们借助 Pydantic 来使用标准的 Python 类型声明请求体。
```Python hl_lines="2 7 8 9 10 23 24 25"
from fastapi import FastAPI
@@ -267,175 +263,176 @@ def update_item(item_id: int, item: Item):
return {"item_name": item.name, "item_id": item_id}
```
-The server should reload automatically (because you added `--reload` to the `uvicorn` command above).
+服务器将会自动重载（因为在上面的步骤中你向 `uvicorn` 命令添加了 `--reload` 选项）。
-### Interactive API docs upgrade
+### 升级交互式 API 文档
-Now go to http://127.0.0.1:8000/docs.
+访问 http://127.0.0.1:8000/docs。
-* The interactive API documentation will be automatically updated, including the new body:
+* 交互式 API 文档将会自动更新，并加入新的请求体：
-* Click on the button "Try it out", it allows you to fill the parameters and directly interact with the API:
+* 点击 "Try it out" 按钮，之后你可以填写参数并直接调用 API：
-* Then click on the "Execute" button, the user interface will communicate with your API, send the parameters, get the results and show them on the screen:
+* 然后点击 "Execute" 按钮，用户界面将会和 API 进行通信，发送参数，获取结果并在屏幕上展示：
-### Alternative API docs upgrade
+### 升级备选文档
-And now, go to http://127.0.0.1:8000/redoc.
+访问 http://127.0.0.1:8000/redoc。
-* The alternative documentation will also reflect the new query parameter and body:
+* 备选文档同样会体现新加入的请求参数和请求体：
-### Recap
+### 回顾
-In summary, you declare **once** the types of parameters, body, etc. as function parameters.
+总的来说，你就像声明函数的参数类型一样只声明了**一次**请求参数、请求体等的类型。
-You do that with standard modern Python types.
+你使用了标准的现代 Python 类型来完成声明。
-You don't have to learn a new syntax, the methods or classes of a specific library, etc.
+你不需要去学习新的语法、了解特定库的方法或类，等等。
-Just standard **Python 3.6+**.
+只需要使用标准的 **Python 3.6 及更高版本**。
-For example, for an `int`:
+举个例子，比如声明 `int` 类型：
```Python
item_id: int
```
-or for a more complex `Item` model:
+或者一个更复杂的 `Item` 模型：
```Python
item: Item
```
-...and with that single declaration you get:
-
-* Editor support, including:
- * Completion.
- * Type checks.
-* Validation of data:
- * Automatic and clear errors when the data is invalid.
- * Validation even for deeply nested JSON objects.
-* Conversion of input data: coming from the network to Python data and types. Reading from:
- * JSON.
- * Path parameters.
- * Query parameters.
- * Cookies.
- * Headers.
- * Forms.
- * Files.
-* Conversion of output data: converting from Python data and types to network data (as JSON):
- * Convert Python types (`str`, `int`, `float`, `bool`, `list`, etc).
- * `datetime` objects.
- * `UUID` objects.
- * Database models.
- * ...and many more.
-* Automatic interactive API documentation, including 2 alternative user interfaces:
- * Swagger UI.
- * ReDoc.
+......在进行一次声明之后，你将获得：
+
+* 编辑器支持，包括：
+ * 自动补全
+ * 类型检查
+* 数据校验：
+ * 在校验失败时自动生成清晰的错误信息
+ * 对多层嵌套的 JSON 对象依然执行校验
+* 转换 来自网络请求的输入数据为 Python 数据类型。包括以下数据：
+ * JSON
+ * 路径参数
+ * 查询参数
+ * Cookies
+ * 请求头
+ * 表单
+ * 文件
+* 转换 输出的数据：转换 Python 数据类型为供网络传输的 JSON 数据：
+ * 转换 Python 基础类型 （`str`、 `int`、 `float`、 `bool`、 `list` 等）
+ * `datetime` 对象
+ * `UUID` 对象
+ * 数据库模型
+ * ......以及更多其他类型
+* 自动生成的交互式 API 文档，包括两种可选的用户界面：
+ * Swagger UI
+ * ReDoc
---
-Coming back to the previous code example, **FastAPI** will:
-
-* Validate that there is an `item_id` in the path for `GET` and `PUT` requests.
-* Validate that the `item_id` is of type `int` for `GET` and `PUT` requests.
- * If it is not, the client will see a useful, clear error.
-* Check if there is an optional query parameter named `q` (as in `http://127.0.0.1:8000/items/foo?q=somequery`) for `GET` requests.
- * As the `q` parameter is declared with `= None`, it is optional.
- * Without the `None` it would be required (as is the body in the case with `PUT`).
-* For `PUT` requests to `/items/{item_id}`, Read the body as JSON:
- * Check that it has a required attribute `name` that should be a `str`.
- * Check that it has a required attribute `price` that has to be a `float`.
- * Check that it has an optional attribute `is_offer`, that should be a `bool`, if present.
- * All this would also work for deeply nested JSON objects.
-* Convert from and to JSON automatically.
-* Document everything with OpenAPI, that can be used by:
- * Interactive documentation systems.
- * Automatic client code generation systems, for many languages.
-* Provide 2 interactive documentation web interfaces directly.
+回到前面的代码示例，**FastAPI** 将会：
+
+* 校验 `GET` 和 `PUT` 请求的路径中是否含有 `item_id`。
+* 校验 `GET` 和 `PUT` 请求中的 `item_id` 是否为 `int` 类型。
+ * 如果不是，客户端将会收到清晰有用的错误信息。
+* 检查 `GET` 请求中是否有命名为 `q` 的可选查询参数（比如 `http://127.0.0.1:8000/items/foo?q=somequery`）。
+ * 因为 `q` 被声明为 `= None`，所以它是可选的。
+ * 如果没有 `None` 它将会是必需的 (如 `PUT` 例子中的请求体)。
+* 对于访问 `/items/{item_id}` 的 `PUT` 请求，将请求体读取为 JSON 并：
+ * 检查是否有必需属性 `name` 并且值为 `str` 类型 。
+ * 检查是否有必需属性 `price` 并且值为 `float` 类型。
+ * 检查是否有可选属性 `is_offer`， 如果有的话值应该为 `bool` 类型。
+ * 以上过程对于多层嵌套的 JSON 对象同样也会执行
+* 自动对 JSON 进行转换或转换成 JSON。
+* 通过 OpenAPI 文档来记录所有内容，可被用于：
+ * 交互式文档系统
+ * 许多编程语言的客户端代码自动生成系统
+* 直接提供 2 种交互式文档 web 界面。
---
-We just scratched the surface, but you already get the idea of how it all works.
+虽然我们才刚刚开始，但其实你已经了解了这一切是如何工作的。
-Try changing the line with:
+尝试更改下面这行代码：
```Python
return {"item_name": item.name, "item_id": item_id}
```
-...from:
+......从：
```Python
... "item_name": item.name ...
```
-...to:
+......改为：
```Python
... "item_price": item.price ...
```
-...and see how your editor will auto-complete the attributes and know their types:
+......注意观察编辑器是如何自动补全属性并且还知道它们的类型：
-For a more complete example including more features, see the Tutorial - User Guide.
+教程 - 用户指南 中有包含更多特性的更完整示例。
-**Spoiler alert**: the tutorial - user guide includes:
+**剧透警告**： 教程 - 用户指南中的内容有：
-* Declaration of **parameters** from other different places as: **headers**, **cookies**, **form fields** and **files**.
-* How to set **validation constraints** as `maximum_length` or `regex`.
-* A very powerful and easy to use **Dependency Injection** system.
-* Security and authentication, including support for **OAuth2** with **JWT tokens** and **HTTP Basic** auth.
-* More advanced (but equally easy) techniques for declaring **deeply nested JSON models** (thanks to Pydantic).
-* Many extra features (thanks to Starlette) as:
+* 对来自不同地方的参数进行声明，如：**请求头**、**cookies**、**form 表单**以及**上传的文件**。
+* 如何设置**校验约束**如 `maximum_length` 或者 `regex`。
+* 一个强大并易于使用的 **依赖注入** 系统。
+* 安全性和身份验证，包括通过 **JWT 令牌**和 **HTTP 基本身份认证**来支持 **OAuth2**。
+* 更进阶（但同样简单）的技巧来声明 **多层嵌套 JSON 模型** （借助 Pydantic）。
+* 许多额外功能（归功于 Starlette）比如：
* **WebSockets**
* **GraphQL**
- * extremely easy tests based on `requests` and `pytest`
+ * 基于 `requests` 和 `pytest` 的极其简单的测试
* **CORS**
* **Cookie Sessions**
- * ...and more.
+ * ......以及更多
+
+## 性能
-## Performance
-Independent TechEmpower benchmarks show **FastAPI** applications running under Uvicorn as one of the fastest Python frameworks available, only below Starlette and Uvicorn themselves (used internally by FastAPI). (*)
+独立机构 TechEmpower 所作的基准测试结果显示，基于 Uvicorn 运行的 **FastAPI** 程序是 最快的 Python web 框架之一，仅次于 Starlette 和 Uvicorn 本身（FastAPI 内部使用了它们）。(*)
-To understand more about it, see the section Benchmarks.
+想了解更多，请查阅 基准测试 章节。
-## Optional Dependencies
+## 可选依赖
-Used by Pydantic:
+用于 Pydantic：
-* ujson - for faster JSON "parsing".
-* email_validator - for email validation.
+* ujson - 更快的 JSON "解析"。
+* email_validator - 用于 email 校验。
-Used by Starlette:
+用于 Starlette：
-* requests - Required if you want to use the `TestClient`.
-* aiofiles - Required if you want to use `FileResponse` or `StaticFiles`.
-* jinja2 - Required if you want to use the default template configuration.
-* python-multipart - Required if you want to support form "parsing", with `request.form()`.
-* itsdangerous - Required for `SessionMiddleware` support.
-* pyyaml - Required for Starlette's `SchemaGenerator` support (you probably don't need it with FastAPI).
-* graphene - Required for `GraphQLApp` support.
-* ujson - Required if you want to use `UJSONResponse`.
+* requests - 使用 `TestClient` 时安装。
+* aiofiles - 使用 `FileResponse` 或 `StaticFiles` 时安装。
+* jinja2 - 使用默认模板配置时安装。
+* python-multipart - 需要通过 `request.form()` 对表单进行"解析"时安装。
+* itsdangerous - 提供 `SessionMiddleware` 支持。
+* pyyaml - 使用 Starlette 提供的 `SchemaGenerator` 时安装（有 FastAPI 你可能并不需要它）。
+* graphene - 需要 `GraphQLApp` 支持时安装。
+* ujson - 使用 `UJSONResponse` 时安装。
-Used by FastAPI / Starlette:
+用于 FastAPI / Starlette：
-* uvicorn - for the server that loads and serves your application.
-* orjson - Required if you want to use `ORJSONResponse`.
+* uvicorn - 用于加载和服务你的应用程序的服务器。
+* orjson - 使用 `ORJSONResponse` 时安装。
-You can install all of these with `pip install fastapi[all]`.
+你可以通过 `pip install fastapi[all]` 命令来安装以上所有依赖。
-## License
+## 许可协议
-This project is licensed under the terms of the MIT license.
+该项目遵循 MIT 许可协议。