Update all

docs/zh-hant/docs/async.md

@@ -1,10 +1,10 @@
-# 並行與 async / await
+# 並行與 async / await { #concurrency-and-async-await }
 
 有關*路徑操作函式*的 `async def` 語法的細節與非同步 (asynchronous) 程式碼、並行 (concurrency) 與平行 (parallelism) 的一些背景知識。
 
-## 趕時間嗎?
+## 趕時間嗎? { #in-a-hurry }
 
-<abbr title="too long; didn't read（文長慎入）"><strong>TL;DR:</strong></abbr>
+<abbr title="too long; didn't read - 太長不看"><strong>TL;DR:</strong></abbr>
 
 如果你正在使用要求你以 `await` 語法呼叫的第三方函式庫，例如：
 
@@ -41,7 +41,7 @@ def results():
 
 ---
 
-如果你的應用程式不需要與外部資源進行任何通訊並等待其回應，請使用 `async def`。
+如果你的應用程式不需要與外部資源進行任何通訊並等待其回應，請使用 `async def`，即使內部不需要使用 `await` 也可以。
 
 ---
 
@@ -55,7 +55,7 @@ def results():
 
 但透過遵循上述步驟，它將能進行一些效能最佳化。
 
-## 技術細節
+## 技術細節 { #technical-details }
 
 現代版本的 Python 支援使用 **「協程」** 的 **`async` 和 `await`** 語法來寫 **「非同步程式碼」**。
 
@@ -65,7 +65,7 @@ def results():
 * **`async` 和 `await`**
 * **協程**
 
-## 非同步程式碼
+## 非同步程式碼 { #asynchronous-code }
 
 非同步程式碼僅意味著程式語言 💬 有辦法告訴電腦/程式 🤖 在程式碼中的某個點，它 🤖 需要等待某些事情完成。讓我們假設這些事情被稱為「慢速檔案」📝。
 
@@ -74,7 +74,7 @@ def results():
 接著程式 🤖 會在有空檔時回來查看是否有等待的工作已經完成，並執行必要的後續操作。
 
 接下來，它 🤖 完成第一個工作（例如我們的「慢速檔案」📝）並繼續執行相關的所有操作。
-這個「等待其他事情」通常指的是一些相對較慢的（與處理器和 RAM 記憶體的速度相比）的 <abbr title="Input and Output">I/O</abbr> 操作，比如說：
+這個「等待其他事情」通常指的是一些相對較慢的（與處理器和 RAM 記憶體的速度相比）的 <abbr title="Input and Output - 輸入與輸出">I/O</abbr> 操作，比如說：
 
 * 透過網路傳送來自用戶端的資料
 * 從網路接收來自用戶端的資料
@@ -85,7 +85,7 @@ def results():
 * 資料庫查詢
 * 等等
 
-由於大部分的執行時間都消耗在等待 <abbr title="輸入與輸出">I/O</abbr> 操作上，因此這些操作被稱為 "I/O 密集型" 操作。
+由於大部分的執行時間都消耗在等待 <abbr title="Input and Output - 輸入與輸出">I/O</abbr> 操作上，因此這些操作被稱為 "I/O 密集型" 操作。
 
 之所以稱為「非同步」，是因為電腦/程式不需要與那些耗時的任務「同步」，等待任務完成的精確時間，然後才能取得結果並繼續工作。
 
@@ -93,7 +93,7 @@ def results():
 
 相對於「非同步」（asynchronous），「同步」（synchronous）也常被稱作「順序性」（sequential），因為電腦/程式會依序執行所有步驟，即便這些步驟涉及等待，才會切換到其他任務。
 
-### 並行與漢堡
+### 並行與漢堡 { #concurrency-and-burgers }
 
 上述非同步程式碼的概念有時也被稱為「並行」，它不同於「平行」。
 
@@ -103,7 +103,7 @@ def results():
 
 為了理解差異，請想像以下有關漢堡的故事：
 
-### 並行漢堡
+### 並行漢堡 { #concurrent-burgers }
 
 你和你的戀人去速食店，排隊等候時，收銀員正在幫排在你前面的人點餐。😍
 
@@ -163,7 +163,7 @@ def results():
 
 然後你走向櫃檯 🔀，回到已經完成的最初任務 ⏯，拿起漢堡，說聲謝謝，並帶回桌上。這就結束了與櫃檯的互動步驟/任務 ⏹，接下來會產生一個新的任務，「吃漢堡」 🔀 ⏯，而先前的「拿漢堡」任務已經完成了 ⏹。
 
-### 平行漢堡
+### 平行漢堡 { #parallel-burgers }
 
 現在，讓我們來想像這裡不是「並行漢堡」，而是「平行漢堡」。
 
@@ -233,7 +233,7 @@ def results():
 
 所以，你不會想帶你的戀人 😍 一起去銀行辦事 🏦。
 
-### 漢堡結論
+### 漢堡結論 { #burger-conclusion }
 
 在「和戀人一起吃速食漢堡」的這個場景中，由於有大量的等待 🕙，使用並行系統 ⏸🔀⏯ 更有意義。
 
@@ -253,7 +253,7 @@ def results():
 
 你可以同時利用並行性和平行性，進一步提升效能，這比大多數已測試的 NodeJS 框架都更快，並且與 Go 語言相當，而 Go 是一種更接近 C 的編譯語言（<a href="https://www.techempower.com/benchmarks/#section=data-r17&hw=ph&test=query&l=zijmkf-1" class="external-link" target="_blank">感謝 Starlette</a>）。
 
-### 並行比平行更好嗎？
+### 並行比平行更好嗎？ { #is-concurrency-better-than-parallelism }
 
 不是的！這不是故事的本意。
 
@@ -277,7 +277,7 @@ def results():
 
 在這個場景中，每個清潔工（包括你）都是一個處理器，完成工作的一部分。
 
-由於大多數的執行時間都花在實際的工作上（而不是等待），而電腦中的工作由 <abbr title="Central Processing Unit">CPU</abbr> 完成，因此這些問題被稱為「CPU 密集型」。
+由於大多數的執行時間都花在實際的工作上（而不是等待），而電腦中的工作由 <abbr title="Central Processing Unit - 中央處理器">CPU</abbr> 完成，因此這些問題被稱為「CPU 密集型」。
 
 ---
 
@@ -290,7 +290,7 @@ def results():
 * **機器學習**: 通常需要大量的「矩陣」和「向量」運算。想像一個包含數字的巨大電子表格，並所有的數字同時相乘;
 * **深度學習**: 這是機器學習的子領域，同樣適用。只不過這不僅僅是一張數字表格，而是大量的數據集合，並且在很多情況下，你會使用特殊的處理器來構建或使用這些模型。
 
-### 並行 + 平行: Web + 機器學習
+### 並行 + 平行: Web + 機器學習 { #concurrency-parallelism-web-machine-learning }
 
 使用 **FastAPI**，你可以利用並行的優勢，這在 Web 開發中非常常見（這也是 NodeJS 的最大吸引力）。
 
@@ -300,9 +300,9 @@ def results():
 
 想了解如何在生產環境中實現這種平行性，請參見 [部屬](deployment/index.md){.internal-link target=_blank}。
 
-## `async` 和 `await`
+## `async` 和 `await` { #async-and-await }
 
-現代 Python 版本提供一種非常直觀的方式定義非同步程式碼。這使得它看起來就像正常的「順序」程式碼，並在適當的時機「等待」。
+現代 Python 版本提供一種非常直觀的方式定義非同步程式碼。這使得它看起來就像正常的「順序」程式碼，並在適當的時機替你「等待」。
 
 當某個操作需要等待才能回傳結果，並且支援這些新的 Python 特性時，你可以像這樣編寫程式碼：
 
@@ -329,7 +329,7 @@ def get_sequential_burgers(number: int):
     return burgers
 ```
 
-使用 `async def`，Python Python 知道在該函式內需要注意 `await`，並且它可以「暫停」 ⏸ 執行該函式，然後執行其他任務 🔀 後回來。
+使用 `async def`，Python 知道在該函式內需要注意 `await`，並且它可以「暫停」 ⏸ 執行該函式，然後執行其他任務 🔀 後回來。
 
 當你想要呼叫 `async def` 函式時，必須使用「await」。因此，這樣寫將無法運行：
 
@@ -349,11 +349,11 @@ async def read_burgers():
     return burgers
 ```
 
-### 更多技術細節
+### 更多技術細節 { #more-technical-details }
 
 你可能已經注意到，`await` 只能在 `async def` 定義的函式內使用。
 
-但同時，使用 `async def` 定義的函式本身也必須被「等待」。所以，帶有 `async def` 函式只能在其他使用 `async def` 定義的函式內呼叫。
+但同時，使用 `async def` 定義的函式本身也必須被「等待」。所以，帶有 `async def` 的函式只能在其他使用 `async def` 定義的函式內呼叫。
 
 那麼，這就像「先有雞還是先有蛋」的問題，要如何呼叫第一個 `async` 函式呢？
 
@@ -361,35 +361,37 @@ async def read_burgers():
 
 但如果你想在沒有 FastAPI 的情況下使用 `async` / `await`，你也可以這樣做。
 
-### 編寫自己的非同步程式碼
+### 編寫自己的非同步程式碼 { #write-your-own-async-code }
 
-Starlette （和 **FastAPI**） 是基於 <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a> 實作的，這使得它們與 Python 標準函式庫相容 <a href="https://docs.python.org/3/library/asyncio-task.html" class="external-link" target="_blank">asyncio</a> 和 <a href="https://trio.readthedocs.io/en/stable/" class="external-link" target="_blank">Trio</a>。
+Starlette（和 **FastAPI**）是基於 <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a> 實作的，這使得它們與 Python 標準函式庫 <a href="https://docs.python.org/3/library/asyncio-task.html" class="external-link" target="_blank">asyncio</a> 和 <a href="https://trio.readthedocs.io/en/stable/" class="external-link" target="_blank">Trio</a> 相容。
 
 特別是，你可以直接使用 <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a> 來處理更複雜的並行使用案例，這些案例需要你在自己的程式碼中使用更高階的模式。
 
-即使你不使用 **FastAPI**，你也可以使用 <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a> 來撰寫自己的非同步應用程式，並獲得高相容性及一些好處（例如結構化並行）。
+即使你不使用 **FastAPI**，你也可以使用 <a href="https://anyio.readthedocs.io/en/stable/" class="external-link" target="_blank">AnyIO</a> 來撰寫自己的非同步應用程式，並獲得高相容性及一些好處（例如「結構化並行」）。
 
-### 其他形式的非同步程式碼
+我另外在 AnyIO 之上做了一個薄封裝的函式庫，稍微改進型別註解以獲得更好的**自動補全**、**即時錯誤**等。同時它也提供友善的介紹與教學，幫助你**理解**並撰寫**自己的非同步程式碼**：<a href="https://asyncer.tiangolo.com/" class="external-link" target="_blank">Asyncer</a>。當你需要**將非同步程式碼與一般**（阻塞/同步）**程式碼整合**時，它特別實用。
+
+### 其他形式的非同步程式碼 { #other-forms-of-asynchronous-code }
 
 使用 `async` 和 `await` 的風格在語言中相對較新。
 
-但它使處理異步程式碼變得更加容易。
+但它使處理非同步程式碼變得更加容易。
 
 相同的語法（或幾乎相同的語法）最近也被包含在現代 JavaScript（無論是瀏覽器還是 NodeJS）中。
 
-但在此之前，處理異步程式碼要更加複雜和困難。
+但在此之前，處理非同步程式碼要更加複雜和困難。
 
 在較舊的 Python 版本中，你可能會使用多執行緒或 <a href="https://www.gevent.org/" class="external-link" target="_blank">Gevent</a>。但這些程式碼要更難以理解、調試和思考。
 
 在較舊的 NodeJS / 瀏覽器 JavaScript 中，你會使用「回呼」，這可能會導致“回呼地獄”。
 
-## 協程
+## 協程 { #coroutines }
 
-**協程** 只是 `async def` 函式所回傳的非常特殊的事物名稱。Python 知道它是一個類似函式的東西，可以啟動它，並且在某個時刻它會結束，但它也可能在內部暫停 ⏸，只要遇到 `await`。
+「協程」只是 `async def` 函式所回傳的非常特殊的事物名稱。Python 知道它是一個類似函式的東西，可以啟動它，並且在某個時刻它會結束，但它也可能在內部暫停 ⏸，只要遇到 `await`。
 
 這種使用 `async` 和 `await` 的非同步程式碼功能通常被概括為「協程」。這與 Go 語言的主要特性「Goroutines」相似。
 
-## 結論
+## 結論 { #conclusion }
 
 讓我們再次回顧之前的句子：
 
@@ -397,9 +399,9 @@ Starlette （和 **FastAPI**） 是基於 <a href="https://anyio.readthedocs.io/
 
 現在應該能明白其含意了。✨
 
-這些就是驅動 FastAPI（通過 Starlette）運作的原理，也讓它擁有如此驚人的效能。
+這些就是驅動 FastAPI（透過 Starlette）運作的原理，也讓它擁有如此驚人的效能。
 
-## 非常技術性的細節
+## 非常技術性的細節 { #very-technical-details }
 
 /// warning
 
@@ -411,23 +413,23 @@ Starlette （和 **FastAPI**） 是基於 <a href="https://anyio.readthedocs.io/
 
 ///
 
-### 路徑操作函数
+### 路徑操作函式 { #path-operation-functions }
 
 當你使用 `def` 而不是 `async def` 宣告*路徑操作函式*時，該函式會在外部的執行緒池（threadpool）中執行，然後等待結果，而不是直接呼叫（因為這樣會阻塞伺服器）。
 
-如果你來自於其他不以這種方式運作的非同步框架，而且你習慣於使用普通的 `def` 定義僅進行簡單計算的*路徑操作函式*，目的是獲得微小的性能增益（大約 100 奈秒），請注意，在 FastAPI 中，效果會完全相反。在這些情況下，最好使用 `async def`除非你的*路徑操作函式*執行阻塞的 <abbr title="輸入/輸出：磁碟讀寫或網路通訊">I/O</abbr> 的程式碼。
+如果你來自於其他不以這種方式運作的非同步框架，而且你習慣於使用普通的 `def` 定義僅進行簡單計算的*路徑操作函式*，目的是獲得微小的性能增益（大約 100 奈秒），請注意，在 FastAPI 中，效果會完全相反。在這些情況下，最好使用 `async def`，除非你的*路徑操作函式*執行阻塞的 <abbr title="Input/Output - 輸入/輸出: 磁碟讀寫或網路通訊。">I/O</abbr> 的程式碼。
 
-不過，在這兩種情況下，**FastAPI** [仍然很快](index.md#_11){.internal-link target=_blank}至少與你之前的框架相當（或者更快）。
+不過，在這兩種情況下，**FastAPI** [仍然很快](index.md#performance){.internal-link target=_blank}，至少與你之前的框架相當（或者更快）。
 
-### 依賴項(Dependencies)
+### 依賴項(Dependencies) { #dependencies }
 
 同樣適用於[依賴項](tutorial/dependencies/index.md){.internal-link target=_blank}。如果依賴項是一個標準的 `def` 函式，而不是 `async def`，那麼它在外部的執行緒池被運行。
 
-### 子依賴項
+### 子依賴項 { #sub-dependencies }
 
-你可以擁有多個相互依賴的依賴項和[子依賴項](tutorial/dependencies/sub-dependencies.md){.internal-link target=_blank} （作為函式定義的參數），其中一些可能是用 `async def` 宣告，也可能是用 `def` 宣告。它們仍然可以正常運作，用 `def` 定義的那些將會在外部的執行緒中呼叫（來自執行緒池），而不是被「等待」。
+你可以擁有多個相互依賴的依賴項和[子依賴項](tutorial/dependencies/sub-dependencies.md){.internal-link target=_blank}（作為函式定義的參數），其中一些可能是用 `async def` 宣告，也可能是用 `def` 宣告。它們仍然可以正常運作，用 `def` 定義的那些將會在外部的執行緒中呼叫（來自執行緒池），而不是被「等待」。
 
-### 其他輔助函式
+### 其他輔助函式 { #other-utility-functions }
 
 你可以直接呼叫任何使用 `def` 或 `async def` 建立的其他輔助函式，FastAPI 不會影響你呼叫它們的方式。
 
@@ -439,4 +441,4 @@ Starlette （和 **FastAPI**） 是基於 <a href="https://anyio.readthedocs.io/
 
 再一次強調，這些都是非常技術性的細節，如果你特地在尋找這些資訊，這些內容可能會對你有幫助。
 
-否則，只需遵循上面提到的指引即可：<a href="#_1">趕時間嗎?</a>.
+否則，只需遵循上面提到的指引即可：<a href="#in-a-hurry">趕時間嗎?</a>。

docs/zh-hant/docs/benchmarks.md

@@ -6,7 +6,7 @@
 
 ## 基準測試和速度 { #benchmarks-and-speed }
 
-當你查看基準測試時，時常會見到幾個不同類型的工具被同時進行測試。
+當你查看基準測試時，常見到不同類型的多個工具被視為等同來比較。
 
 具體來說，是將 Uvicorn、Starlette 和 FastAPI 同時進行比較（以及許多其他工具）。
 
@@ -20,7 +20,7 @@
 
 * **Uvicorn**：
     * 具有最佳效能，因為除了伺服器本身之外，它沒有太多額外的程式碼。
-    * 你不會直接在 Uvicorn 中編寫應用程式。這意味著你的程式碼必須或多或少地包含 Starlette（或 **FastAPI**）提供的所有程式碼。如果你這樣做，你的最終應用程式將具有與使用框架相同的開銷並最大限度地減少應用程式程式碼和錯誤。
+    * 你不會直接在 Uvicorn 中編寫應用程式。這意味著你的程式碼必須或多或少地包含 Starlette（或 **FastAPI**）提供的所有程式碼。如果你這樣做，你的最終應用程式將具有與使用框架相同的開銷，且無法像使用框架那樣減少應用程式程式碼與錯誤。
     * 如果你要比較 Uvicorn，請將其與 Daphne、Hypercorn、uWSGI 等應用程式伺服器進行比較。
 * **Starlette**：
     * 繼 Uvicorn 之後的次佳表現。事實上，Starlette 使用 Uvicorn 來運行。因此它將可能只透過執行更多程式碼而變得比 Uvicorn「慢」。

docs/zh-hant/docs/deployment/index.md

@@ -8,7 +8,7 @@
 
 對於一個 **Web API**，部署通常涉及將其放置在**遠端伺服器**上，並使用性能優良且穩定的**伺服器程式**，確保使用者能夠高效、無中斷地存取應用程式，且不會遇到問題。
 
-這與**開發**階段形成鮮明對比，在**開發**階段，你會不斷更改程式碼、破壞程式碼、修復程式碼，然後停止和重新啟動伺服器等。
+這與**開發**階段形成鮮明對比，在**開發**階段，你會不斷更改程式碼、破壞程式碼、修復程式碼，然後停止和重新啟動開發伺服器等。
 
 ## 部署策略 { #deployment-strategies }
 

docs/zh-hant/docs/fastapi-cli.md

@@ -1,4 +1,4 @@
-# FastAPI CLI
+# FastAPI CLI { #fastapi-cli }
 
 **FastAPI CLI** 是一個命令列程式，能用來運行你的 FastAPI 應用程式、管理你的 FastAPI 專案等。
 
@@ -9,72 +9,64 @@
 <div class="termy">
 
 ```console
-$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:single">main.py</u>
-<font color="#3465A4">INFO    </font> Using path <font color="#3465A4">main.py</font>
-<font color="#3465A4">INFO    </font> Resolved absolute path <font color="#75507B">/home/user/code/awesomeapp/</font><font color="#AD7FA8">main.py</font>
-<font color="#3465A4">INFO    </font> Searching for package file structure from directories with <font color="#3465A4">__init__.py</font> files
-<font color="#3465A4">INFO    </font> Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
-
- ╭─ <font color="#8AE234"><b>Python module file</b></font> ─╮
- │                      │
- │  🐍 main.py          │
- │                      │
- ╰──────────────────────╯
-
-<font color="#3465A4">INFO    </font> Importing module <font color="#4E9A06">main</font>
-<font color="#3465A4">INFO    </font> Found importable FastAPI app
-
- ╭─ <font color="#8AE234"><b>Importable FastAPI app</b></font> ─╮
- │                          │
- │  <span style="background-color:#272822"><font color="#FF4689">from</font></span><span style="background-color:#272822"><font color="#F8F8F2"> main </font></span><span style="background-color:#272822"><font color="#FF4689">import</font></span><span style="background-color:#272822"><font color="#F8F8F2"> app</font></span><span style="background-color:#272822">  </span>  │
- │                          │
- ╰──────────────────────────╯
-
-<font color="#3465A4">INFO    </font> Using import string <font color="#8AE234"><b>main:app</b></font>
-
- <span style="background-color:#C4A000"><font color="#2E3436">╭────────── FastAPI CLI - Development mode ───────────╮</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│  Serving at: http://127.0.0.1:8000                  │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│  API docs: http://127.0.0.1:8000/docs               │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│  Running in development mode, for production use:   │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│  </font></span><span style="background-color:#C4A000"><font color="#555753"><b>fastapi run</b></font></span><span style="background-color:#C4A000"><font color="#2E3436">                                        │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">│                                                     │</font></span>
- <span style="background-color:#C4A000"><font color="#2E3436">╰─────────────────────────────────────────────────────╯</font></span>
-
-<font color="#4E9A06">INFO</font>:     Will watch for changes in these directories: [&apos;/home/user/code/awesomeapp&apos;]
-<font color="#4E9A06">INFO</font>:     Uvicorn running on <b>http://127.0.0.1:8000</b> (Press CTRL+C to quit)
-<font color="#4E9A06">INFO</font>:     Started reloader process [<font color="#34E2E2"><b>2265862</b></font>] using <font color="#34E2E2"><b>WatchFiles</b></font>
-<font color="#4E9A06">INFO</font>:     Started server process [<font color="#06989A">2265873</font>]
-<font color="#4E9A06">INFO</font>:     Waiting for application startup.
-<font color="#4E9A06">INFO</font>:     Application startup complete.
+$ <font color="#4E9A06">fastapi</font> dev <u style="text-decoration-style:solid">main.py</u>
+
+  <span style="background-color:#009485"><font color="#D3D7CF"> FastAPI </font></span>  Starting development server 🚀
+
+             Searching for package file structure from directories with
+             <font color="#3465A4">__init__.py</font> files
+             Importing from <font color="#75507B">/home/user/code/</font><font color="#AD7FA8">awesomeapp</font>
+
+   <span style="background-color:#007166"><font color="#D3D7CF"> module </font></span>  🐍 main.py
+
+     <span style="background-color:#007166"><font color="#D3D7CF"> code </font></span>  Importing the FastAPI app object from the module with the
+             following code:
+
+             <u style="text-decoration-style:solid">from </u><u style="text-decoration-style:solid"><b>main</b></u><u style="text-decoration-style:solid"> import </u><u style="text-decoration-style:solid"><b>app</b></u>
+
+      <span style="background-color:#007166"><font color="#D3D7CF"> app </font></span>  Using import string: <font color="#3465A4">main:app</font>
+
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Server started at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font>
+   <span style="background-color:#007166"><font color="#D3D7CF"> server </font></span>  Documentation at <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000/docs</u></font>
+
+      <span style="background-color:#007166"><font color="#D3D7CF"> tip </font></span>  Running in development mode, for production use:
+             <b>fastapi run</b>
+
+             Logs:
+
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Will watch for changes in these directories:
+             <b>[</b><font color="#4E9A06">&apos;/home/user/code/awesomeapp&apos;</font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Uvicorn running on <font color="#729FCF"><u style="text-decoration-style:solid">http://127.0.0.1:8000</u></font> <b>(</b>Press CTRL+C to
+             quit<b>)</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started reloader process <b>[</b><font color="#34E2E2"><b>383138</b></font><b>]</b> using WatchFiles
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Started server process <b>[</b><font color="#34E2E2"><b>383153</b></font><b>]</b>
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Waiting for application startup.
+     <span style="background-color:#007166"><font color="#D3D7CF"> INFO </font></span>  Application startup complete.
 ```
 
 </div>
 
-`fastapi` 命令列程式就是 **FastAPI CLI**。
+名為 `fastapi` 的命令列程式就是 **FastAPI CLI**。
 
-FastAPI CLI 接收你的 Python 程式路徑（例如 `main.py`），並自動檢測 FastAPI 實例（通常命名為 `app`），確定正確的引入模組流程，然後運行該應用程式。
+FastAPI CLI 接收你的 Python 程式路徑（例如 `main.py`），並自動檢測 `FastAPI` 實例（通常命名為 `app`），確定正確的引入模組流程，然後運行該應用程式。
 
 在生產環境，你應該使用 `fastapi run` 命令。 🚀
 
 **FastAPI CLI** 內部使用了 <a href="https://www.uvicorn.dev" class="external-link" target="_blank">Uvicorn</a>，這是一個高效能、適合生產環境的 ASGI 伺服器。 😎
 
-## `fastapi dev`
+## `fastapi dev` { #fastapi-dev }
 
 執行 `fastapi dev` 會啟動開發模式。
 
 預設情況下，**auto-reload** 功能是啟用的，當你對程式碼進行修改時，伺服器會自動重新載入。這會消耗較多資源，並且可能比禁用時更不穩定。因此，你應該只在開發環境中使用此功能。它也會在 IP 位址 `127.0.0.1` 上監聽，這是用於你的機器與自身通訊的 IP 位址（`localhost`）。
 
-## `fastapi run`
+## `fastapi run` { #fastapi-run }
 
 執行 `fastapi run` 會以生產模式啟動 FastAPI。
 
-預設情況下，**auto-reload** 功能是禁用的。它也會在 IP 位址 `0.0.0.0` 上監聽，表示會監聽所有可用的 IP 地址，這樣任何能與該機器通訊的人都可以公開存取它。這通常是你在生產環境中運行應用程式的方式，例如在容器中運行時。
+預設情況下，**auto-reload** 功能是禁用的。它也會在 IP 位址 `0.0.0.0` 上監聽，表示會監聽所有可用的 IP 位址，這樣任何能與該機器通訊的人都可以公開存取它。這通常是你在生產環境中運行應用程式的方式，例如在容器中運行時。
 
-在大多數情況下，你會（也應該）有一個「終止代理」來處理 HTTPS，這取決於你如何部署你的應用程式，你的服務供應商可能會為你做這件事，或者你需要自己設置它。
+在大多數情況下，你會（也應該）有一個「終止代理」在外層幫你處理 HTTPS；這取決於你如何部署應用程式，你的服務供應商可能會幫你處理，或者你需要自己設置。
 
 /// tip
 

docs/zh-hant/docs/features.md

@@ -1,17 +1,17 @@
-# 特性
+# 特性 { #features }
 
-## FastAPI 特性
+## FastAPI 特性 { #fastapi-features }
 
-**FastAPI** 提供了以下内容：
+**FastAPI** 提供了以下內容：
 
-### 建立在開放標準的基礎上
+### 建立在開放標準的基礎上 { #based-on-open-standards }
 
-* 使用 <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank"><strong>OpenAPI</strong></a> 來建立 API，包含<abbr title="path，也被叫做: endpoints, routes">路徑</abbr><abbr title="也叫做 HTTP 方法，例如 POST, GET, PUT, DELETE">操作</abbr>、參數、請求內文、安全性等聲明。
+* 使用 <a href="https://github.com/OAI/OpenAPI-Specification" class="external-link" target="_blank"><strong>OpenAPI</strong></a> 來建立 API，包含 <dfn title="也稱為：端點、路由">路徑</dfn>、<dfn title="也稱為 HTTP 方法，例如 POST、GET、PUT、DELETE">操作</dfn>、參數、請求內文、安全性等宣告。
 * 使用 <a href="https://json-schema.org/" class="external-link" target="_blank"><strong>JSON Schema</strong></a>（因為 OpenAPI 本身就是基於 JSON Schema）自動生成資料模型文件。
 * 經過縝密的研究後圍繞這些標準進行設計，而不是事後在已有系統上附加的一層功能。
 * 這也讓我們在多種語言中可以使用自動**用戶端程式碼生成**。
 
-### 能夠自動生成文件
+### 能夠自動生成文件 { #automatic-docs }
 
 FastAPI 能生成互動式 API 文件和探索性的 Web 使用者介面。由於該框架基於 OpenAPI，因此有多種選擇，預設提供了兩種。
 
@@ -19,12 +19,11 @@ FastAPI 能生成互動式 API 文件和探索性的 Web 使用者介面。由
 
 ![Swagger UI interaction](https://fastapi.tiangolo.com/img/index/index-03-swagger-02.png)
 
-* <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank"><strong>ReDoc</strong></a> 提供結構性的文件，讓你可以在瀏覽器中查看。
+* 使用 <a href="https://github.com/Rebilly/ReDoc" class="external-link" target="_blank"><strong>ReDoc</strong></a> 的替代 API 文件。
 
 ![ReDoc](https://fastapi.tiangolo.com/img/index/index-06-redoc-02.png)
 
-
-### 現代 Python
+### 現代 Python { #just-modern-python }
 
 這一切都基於標準的 **Python 型別**宣告（感謝 Pydantic）。無需學習新的語法，只需使用標準的現代 Python。
 
@@ -32,7 +31,7 @@ FastAPI 能生成互動式 API 文件和探索性的 Web 使用者介面。由
 
 如果你寫帶有 Python 型別的程式碼：
 
-```python
+```Python
 from datetime import date
 
 from pydantic import BaseModel
@@ -50,10 +49,9 @@ class User(BaseModel):
     joined: date
 ```
 
-
 可以像這樣來使用：
 
-```python
+```Python
 my_user: User = User(id=3, name="John Doe", joined="2018-07-19")
 
 second_user_data = {
@@ -65,7 +63,6 @@ second_user_data = {
 my_second_user: User = User(**second_user_data)
 ```
 
-
 /// info
 
 `**second_user_data` 意思是:
@@ -74,11 +71,11 @@ my_second_user: User = User(**second_user_data)
 
 ///
 
-### 多種編輯器支援
+### 多種編輯器支援 { #editor-support }
 
 整個框架的設計是為了讓使用變得簡單且直觀，在開始開發之前，所有決策都在多個編輯器上進行了測試，以確保提供最佳的開發體驗。
 
-在最近的 Python 開發者調查中，我們能看到<a href="https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features" class="external-link" target="_blank"> 被使用最多的功能是 autocompletion</a>，此功能可以預測將要輸入文字，並自動補齊。
+在最近的 Python 開發者調查中，我們能看到<a href="https://www.jetbrains.com/research/python-developers-survey-2017/#tools-and-features" class="external-link" target="_blank"> 被使用最多的功能是 autocompletion</a>。
 
 整個 **FastAPI** 框架就是基於這一點，任何地方都可以進行自動補齊。
 
@@ -86,11 +83,11 @@ my_second_user: User = User(**second_user_data)
 
 在這裡，你的編輯器可能會這樣幫助你：
 
-* <a href="https://code.visualstudio.com/" class="external-link" target="_blank">Visual Studio Code</a> 中:
+* 在 <a href="https://code.visualstudio.com/" class="external-link" target="_blank">Visual Studio Code</a> 中:
 
 ![editor support](https://fastapi.tiangolo.com/img/vscode-completion.png)
 
-* <a href="https://www.jetbrains.com/pycharm/" class="external-link" target="_blank">PyCharm</a> 中:
+* 在 <a href="https://www.jetbrains.com/pycharm/" class="external-link" target="_blank">PyCharm</a> 中:
 
 ![editor support](https://fastapi.tiangolo.com/img/pycharm-completion.png)
 
@@ -98,17 +95,13 @@ my_second_user: User = User(**second_user_data)
 
 這樣比較不會輸錯鍵名，不用來回翻看文件，也不用來回滾動尋找你最後使用的 `username` 或者 `user_name`。
 
-
-
-### 簡潔
+### 簡潔 { #short }
 
 FastAPI 為你提供了**預設值**，讓你不必在初期進行繁瑣的配置，一切都可以自動運作。如果你有更具體的需求，則可以進行調整和自定義，
 
-但在大多數情況下，你只需要直接使用預設值，就能順利完成 API 開發。
+但預設情況下，一切都「直接可用」。
 
-### 驗證
-
-所有的驗證都由完善且強大的 **Pydantic** 處理。
+### 驗證 { #validation }
 
 * 驗證大部分（甚至所有？）的 Python **資料型別**，包括：
     * JSON 物件 (`dict`)。
@@ -120,9 +113,11 @@ FastAPI 為你提供了**預設值**，讓你不必在初期進行繁瑣的配
     * URL
     * Email
     * UUID
+    * ...等等。
 
+所有的驗證都由完善且強大的 **Pydantic** 處理。
 
-### 安全性及身份驗證
+### 安全性及身份驗證 { #security-and-authentication }
 
 FastAPI 已經整合了安全性和身份驗證的功能，但不會強制與特定的資料庫或資料模型進行綁定。
 
@@ -139,10 +134,9 @@ OpenAPI 中定義的安全模式，包括：
 
 所有的這些都是可重複使用的工具和套件，可以輕鬆與你的系統、資料儲存（Data Stores）、關聯式資料庫（RDBMS）以及非關聯式資料庫（NoSQL）等等整合。
 
+### 依賴注入（Dependency Injection） { #dependency-injection }
 
-### 依賴注入（Dependency Injection）
-
-FastAPI 有一個使用簡單，但是非常強大的<abbr title='也叫做 "components", "resources", "services", "providers"'><strong>依賴注入</strong></abbr>系統。
+FastAPI 有一個使用簡單，但是非常強大的 <dfn title='也稱為「components」、「resources」、「services」、「providers」'><strong>依賴注入</strong></dfn> 系統。
 
 * 依賴項甚至可以有自己的依賴，從而形成一個層級或**依賴圖**的結構。
 * 所有**自動化處理**都由框架完成。
@@ -151,23 +145,21 @@ FastAPI 有一個使用簡單，但是非常強大的<abbr title='也叫做 "com
 * 支持複雜的用戶身份驗證系統、**資料庫連接**等。
 * 不與資料庫、前端等進行強制綁定，但能輕鬆整合它們。
 
-
-### 無限制「擴充功能」
+### 無限制「擴充功能」 { #unlimited-plug-ins }
 
 或者說，無需其他額外配置，直接導入並使用你所需要的程式碼。
 
 任何整合都被設計得非常簡單易用（通過依賴注入），你只需用與*路徑操作*相同的結構和語法，用兩行程式碼就能為你的應用程式建立一個「擴充功能」。
 
+### 測試 { #tested }
 
-### 測試
-
-* 100% 的<abbr title="有自動測試的程式碼">測試覆蓋率</abbr>。
-* 100% 的程式碼有<abbr title="Python 型別註釋，有了這個你的編輯器和外部工具可以給你更好的支援">型別註釋</abbr>。
+* 100% <dfn title="自動化測試所涵蓋的程式碼量">測試覆蓋率</dfn>。
+* 100% <dfn title="Python 型別註解；有了它你的編輯器和外部工具可以提供更好的支援">型別註解</dfn>的程式碼庫。
 * 已能夠在生產環境應用程式中使用。
 
-## Starlette 特性
+## Starlette 特性 { #starlette-features }
 
-**FastAPI** 完全相容且基於 <a href="https://www.starlette.dev/" class="external-link" target="_blank"><strong>Starlette</strong></a>。所以，你有其他的 Starlette 程式碼也能正常運作。FastAPI 繼承了 Starlette 的所有功能，如果你已經知道或者使用過 Starlette，大部分的功能會以相同的方式運作。
+**FastAPI** 完全相容且基於 <a href="https://www.starlette.dev/" class="external-link" target="_blank"><strong>Starlette</strong></a>。所以，你有其他的 Starlette 程式碼也能正常運作。`FastAPI` 實際上是 `Starlette` 的一個子類別。所以，如果你已經知道或者使用過 Starlette，大部分的功能會以相同的方式運作。
 
 通過 **FastAPI** 你可以獲得所有 **Starlette** 的特性（FastAPI 就像加強版的 Starlette）：
 
@@ -181,11 +173,11 @@ FastAPI 有一個使用簡單，但是非常強大的<abbr title='也叫做 "com
 * 100% 測試覆蓋率。
 * 100% 型別註釋的程式碼庫。
 
-## Pydantic 特性
+## Pydantic 特性 { #pydantic-features }
 
 **FastAPI** 完全相容且基於 <a href="https://docs.pydantic.dev/" class="external-link" target="_blank"><strong>Pydantic</strong></a>。所以，你有其他 Pydantic 程式碼也能正常工作。
 
-相容包括基於 Pydantic 的外部函式庫， 例如用於資料庫的 <abbr title="Object-Relational Mapper">ORM</abbr>s, <abbr title="Object-Document Mapper">ODM</abbr>s。
+相容包括基於 Pydantic 的外部函式庫，例如用於資料庫的 <abbr title="Object-Relational Mapper - 物件關聯對映器">ORM</abbr>s、<abbr title="Object-Document Mapper - 物件文件對映器">ODM</abbr>s。
 
 這也意味著在很多情況下，你可以把從請求中獲得的物件**直接傳到資料庫**，因為所有資料都會自動進行驗證。
 
@@ -196,7 +188,7 @@ FastAPI 有一個使用簡單，但是非常強大的<abbr title='也叫做 "com
 * **更簡單**：
     * 不需要學習新的 micro-language 來定義結構。
     * 如果你知道 Python 型別，你就知道如何使用 Pydantic。
-* 和你的 **<abbr title="Integrated Development Environment，和程式碼編輯器類似">IDE</abbr>/<abbr title="一個檢查程式碼錯誤的工具">linter</abbr>/brain** 都能好好配合：
+* 和你的 **<abbr title="Integrated Development Environment - 整合開發環境: 類似於程式碼編輯器">IDE</abbr>/<dfn title="檢查程式碼錯誤的程式">linter</dfn>/brain** 都能好好配合：
     * 因為 Pydantic 的資料結構其實就是你自己定義的類別實例，所以自動補齊、linting、mypy 以及你的直覺都能很好地在經過驗證的資料上發揮作用。
 * 驗證**複雜結構**：
     * 使用 Pydantic 模型時，你可以把資料結構分層設計，並且用 Python 的 `List` 和 `Dict` 等型別來定義。

docs/zh-hant/docs/index.md

@@ -40,7 +40,7 @@ FastAPI 是一個現代、快速（高效能）的 Web 框架，用於以 Python
 * **快速**：非常高的效能，可與 **NodeJS** 和 **Go** 相當（歸功於 Starlette 和 Pydantic）。[最快的 Python 框架之一](#performance)。
 * **極速開發**：開發功能的速度可提升約 200% 至 300%。*
 * **更少的 Bug**：減少約 40% 的人為（開發者）錯誤。*
-* **直覺**：具有出色的編輯器支援，處處都有 <abbr title="也被稱為：自動完成、自動補全、IntelliSense">自動補全</abbr>。更少的偵錯時間。
+* **直覺**：具有出色的編輯器支援，處處都有 <dfn title="也稱為：自動完成、自動補全、IntelliSense">自動補全</dfn>。更少的偵錯時間。
 * **簡單**：設計上易於使用與學習。更少的讀文件時間。
 * **簡潔**：最小化程式碼重複性。每個參數宣告可帶來多個功能。更少的錯誤。
 * **穩健**：立即獲得可投入生產的程式碼，並自動生成互動式文件。
@@ -368,7 +368,7 @@ item: Item
 * 資料驗證：
     * 當資料無效時，自動且清楚的錯誤。
     * 即使是深度巢狀的 JSON 物件也能驗證。
-* 輸入資料的 <abbr title="也被稱為：序列化、解析、封送">轉換</abbr>：從網路讀入到 Python 資料與型別。包含：
+* 輸入資料的 <dfn title="也稱為：序列化、解析、封送">轉換</dfn>：從網路讀入到 Python 資料與型別。包含：
     * JSON。
     * 路徑參數。
     * 查詢參數。
@@ -376,7 +376,7 @@ item: Item
     * 標頭。
     * 表單。
     * 檔案。
-* 輸出資料的 <abbr title="也被稱為：序列化、解析、封送">轉換</abbr>：從 Python 資料與型別轉換為網路資料（JSON）：
+* 輸出資料的 <dfn title="也稱為：序列化、解析、封送">轉換</dfn>：從 Python 資料與型別轉換為網路資料（JSON）：
     * 轉換 Python 型別（`str`、`int`、`float`、`bool`、`list` 等）。
     * `datetime` 物件。
     * `UUID` 物件。
@@ -439,7 +439,7 @@ item: Item
 
 * 來自不同來源的**參數**宣告：例如 **headers**、**cookies**、**form fields** 和 **files**。
 * 如何設定**驗證限制**，如 `maximum_length` 或 `regex`。
-* 一個非常強大且易用的 **<abbr title="也被稱為：components、resources、providers、services、injectables">依賴注入</abbr>** 系統。
+* 一個非常強大且易用的 **<dfn title="也稱為：components、resources、providers、services、injectables">依賴注入</dfn>** 系統。
 * 安全與驗證，包含支援 **OAuth2** 搭配 **JWT tokens** 與 **HTTP Basic** 驗證。
 * 宣告**深度巢狀 JSON 模型**的進階（但同樣簡單）技巧（感謝 Pydantic）。
 * 與 <a href="https://strawberry.rocks" class="external-link" target="_blank">Strawberry</a> 及其他函式庫的 **GraphQL** 整合。
@@ -524,7 +524,7 @@ Starlette 會使用：
 
 * <a href="https://www.python-httpx.org" target="_blank"><code>httpx</code></a> - 若要使用 `TestClient` 必須安裝。
 * <a href="https://jinja.palletsprojects.com" target="_blank"><code>jinja2</code></a> - 若要使用預設的模板設定必須安裝。
-* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a> - 若要支援表單 <abbr title="將來自 HTTP 請求的字串轉換為 Python 資料">"解析"</abbr>，搭配 `request.form()`。
+* <a href="https://github.com/Kludex/python-multipart" target="_blank"><code>python-multipart</code></a> - 若要支援表單 <dfn title="將來自 HTTP 請求的字串轉換為 Python 資料">"解析"</dfn>，搭配 `request.form()`。
 
 FastAPI 會使用：
 

docs/zh-hant/docs/tutorial/first-steps.md

@@ -2,7 +2,7 @@
 
 最簡單的 FastAPI 檔案可能看起來像這樣：
 
-{* ../../docs_src/first_steps/tutorial001_py39.py *}
+{* ../../docs_src/first_steps/tutorial001_py310.py *}
 
 將其複製到一個名為 `main.py` 的文件中。
 
@@ -183,7 +183,7 @@ Deploying to FastAPI Cloud...
 
 ### 第一步：引入 `FastAPI` { #step-1-import-fastapi }
 
-{* ../../docs_src/first_steps/tutorial001_py39.py hl[1] *}
+{* ../../docs_src/first_steps/tutorial001_py310.py hl[1] *}
 
 `FastAPI` 是一個 Python 類別，提供所有 API 的全部功能。
 
@@ -197,7 +197,7 @@ Deploying to FastAPI Cloud...
 
 ### 第二步：建立一個 `FastAPI`「實例」 { #step-2-create-a-fastapi-instance }
 
-{* ../../docs_src/first_steps/tutorial001_py39.py hl[3] *}
+{* ../../docs_src/first_steps/tutorial001_py310.py hl[3] *}
 
 這裡的 `app` 變數將會是 `FastAPI` 類別的「實例」。
 
@@ -266,12 +266,12 @@ https://example.com/items/foo
 
 #### 定義一個「路徑操作裝飾器」 { #define-a-path-operation-decorator }
 
-{* ../../docs_src/first_steps/tutorial001_py39.py hl[6] *}
+{* ../../docs_src/first_steps/tutorial001_py310.py hl[6] *}
 
 `@app.get("/")` 告訴 **FastAPI** 那個函式負責處理請求：
 
 * 路徑 `/`
-* 使用 <abbr title="HTTP GET 方法"><code>get</code>操作</abbr>
+* 使用 <dfn title="HTTP GET 方法"><code>get</code> 操作</dfn>
 
 /// info | `@decorator` 說明
 
@@ -320,7 +320,7 @@ Python 中的 `@something` 語法被稱為「裝飾器」。
 * **operation**：是 `get`。
 * **function**：是裝飾器下面的函式（在 `@app.get("/")` 下面）。
 
-{* ../../docs_src/first_steps/tutorial001_py39.py hl[7] *}
+{* ../../docs_src/first_steps/tutorial001_py310.py hl[7] *}
 
 這就是一個 Python 函式。
 
@@ -332,7 +332,7 @@ Python 中的 `@something` 語法被稱為「裝飾器」。
 
 你也可以將它定義為一般函式，而不是 `async def`：
 
-{* ../../docs_src/first_steps/tutorial003_py39.py hl[7] *}
+{* ../../docs_src/first_steps/tutorial003_py310.py hl[7] *}
 
 /// note
 
@@ -342,7 +342,7 @@ Python 中的 `@something` 語法被稱為「裝飾器」。
 
 ### 第五步：回傳內容 { #step-5-return-the-content }
 
-{* ../../docs_src/first_steps/tutorial001_py39.py hl[8] *}
+{* ../../docs_src/first_steps/tutorial001_py310.py hl[8] *}
 
 你可以返回一個 `dict`、`list`、單個值作為 `str`、`int` 等。
 

docs/zh-hant/docs/virtual-environments.md

@@ -30,7 +30,7 @@
 
 首先，為你的專案建立一個目錄。
 
-我（指原作者 —— 譯者注）通常會在我的主目錄下建立一個名為 `code` 的目錄。
+我通常會在我的主目錄下建立一個名為 `code` 的目錄。
 
 在這個目錄下，我再為每個專案建立一個目錄。
 
@@ -53,7 +53,7 @@ $ cd awesome-project
 
 ## 建立一個虛擬環境 { #create-a-virtual-environment }
 
-在開始一個 Python 專案的**第一時間**，**<abbr title="還有其他做法，此處僅作為一個簡單的指引">在你的專案內部</abbr>**建立一個虛擬環境。
+在開始一個 Python 專案的**第一時間**，**<dfn title="還有其他選項，這是一個簡單的指引">在你的專案內部</dfn>**建立一個虛擬環境。
 
 /// tip
 
@@ -412,7 +412,7 @@ Hello World
 
 ## 設定編輯器 { #configure-your-editor }
 
-你可能會用到編輯器，請確保設定它使用你建立的相同虛擬環境（它可能會自動偵測到），以便你可以獲得自動完成和内嵌錯誤提示。
+你可能會用到編輯器，請確保設定它使用你建立的相同虛擬環境（它可能會自動偵測到），以便你可以獲得自動完成和內嵌錯誤提示。
 
 例如：