FastAPI 類別

以下是 FastAPI 類別的參考資訊，包含所有參數、屬性和方法。

您可以直接從 fastapi 導入 FastAPI 類別

from fastapi import FastAPI

fastapi.FastAPI

FastAPI(
    *,
    debug=False,
    routes=None,
    title="FastAPI",
    summary=None,
    description="",
    version="0.1.0",
    openapi_url="/openapi.json",
    openapi_tags=None,
    servers=None,
    dependencies=None,
    default_response_class=Default(JSONResponse),
    redirect_slashes=True,
    docs_url="/docs",
    redoc_url="/redoc",
    swagger_ui_oauth2_redirect_url="/docs/oauth2-redirect",
    swagger_ui_init_oauth=None,
    middleware=None,
    exception_handlers=None,
    on_startup=None,
    on_shutdown=None,
    lifespan=None,
    terms_of_service=None,
    contact=None,
    license_info=None,
    openapi_prefix="",
    root_path="",
    root_path_in_servers=True,
    responses=None,
    callbacks=None,
    webhooks=None,
    deprecated=None,
    include_in_schema=True,
    swagger_ui_parameters=None,
    generate_unique_id_function=Default(generate_unique_id),
    separate_input_output_schemas=True,
    **extra
)

基底類別： Starlette

FastAPI 應用程式類別，使用 FastAPI 的主要入口點。

在 FastAPI 文件的「第一步」中閱讀更多資訊。

範例

from fastapi import FastAPI

app = FastAPI()

參數	說明
debug	布林值，指示是否應在伺服器錯誤時返回除錯追蹤。 在 Starlette 應用程式文件中閱讀更多資訊。 類型： bool 預設值： False
routes	您通常不會在 FastAPI 中使用此參數，它是從 Starlette 繼承而來並支援相容性。 在 FastAPI 中，您通常會使用*路徑操作方法*，例如 app.get()、app.post() 等等。**注意：**您可能不應該使用此參數，它是從 Starlette 繼承而來並支援相容性。 用於服務傳入 HTTP 和 WebSocket 請求的路由列表。 類型： Optional[List[BaseRoute]] 預設值： None
title	API 的標題。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在 FastAPI 文件的「中繼資料和文件 URL」中閱讀更多資訊。 範例 from fastapi import FastAPI app = FastAPI(title="ChimichangApp") 類型： str 預設值： 'FastAPI'
summary	API 的簡短摘要。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在 FastAPI 文件的「中繼資料和文件 URL」中閱讀更多資訊。 範例 from fastapi import FastAPI app = FastAPI(summary="Deadpond's favorite app. Nuff said.") 類型： Optional[str] 預設值： None
description	API 的描述。支援 Markdown（使用 CommonMark 語法）。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在 FastAPI 文件的「中繼資料和文件 URL」中閱讀更多資訊。 範例 from fastapi import FastAPI app = FastAPI( description=""" ChimichangApp API helps you do awesome stuff. 🚀 ## Items You can **read items**. ## Users You will be able to: * **Create users** (_not implemented_). * **Read users** (_not implemented_). """ ) 類型： str 預設值： ''
version	API 的版本。 **注意** 這是您的應用程式的版本，而不是 OpenAPI 規範的版本或所使用的 FastAPI 的版本。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在 FastAPI 文件的「中繼資料和文件 URL」中閱讀更多資訊。 範例 from fastapi import FastAPI app = FastAPI(version="0.0.1") 類型： str 預設值： '0.1.0'
openapi_url	OpenAPI 綱要將從中提供的 URL。 如果您將其設置為 None，則不會公開提供 OpenAPI 模式，並且預設的自動端點 /docs 和 /redoc 也將被禁用。 在FastAPI 元數據和 Docs URLs 文件中了解更多資訊。 範例 from fastapi import FastAPI app = FastAPI(openapi_url="/api/v1/openapi.json") 類型： Optional[str] 預設值： '/openapi.json'
openapi_tags	OpenAPI 使用的標籤列表，這些標籤與您可以在*路徑操作*中設置的 tags 相同，例如 @app.get("/users/", tags=["users"]) @app.get("/items/", tags=["items"]) 標籤的順序可以用於指定在 Swagger UI 等工具中顯示的順序，用於自動路徑 /docs。 不需要指定所有使用的標籤。 未聲明的標籤可能會被隨機組織或基於工具的邏輯。列表中的每個標籤名稱都必須是唯一的。 每個項目的值是一個包含以下內容的 dict： name：標籤的名稱。 description：標籤的簡短描述。可以使用 CommonMark 語法 進行富文本表示。 externalDocs：此標籤的額外外部文件。如果提供，它將包含一個帶有以下內容的 dict： description：目標文件的簡短描述。可以使用 CommonMark 語法 進行富文本表示。 url：目標文件的 URL。值必須是 URL 格式。 在FastAPI 元數據和 Docs URLs 文件中了解更多資訊。 範例 from fastapi import FastAPI tags_metadata = [ { "name": "users", "description": "Operations with users. The **login** logic is also here.", }, { "name": "items", "description": "Manage items. So _fancy_ they have their own docs.", "externalDocs": { "description": "Items external docs", "url": "https://fastapi.dev.org.tw/", }, }, ] app = FastAPI(openapi_tags=tags_metadata) 類型： Optional[List[Dict[str, Any]]] 預設值： None
servers	一個包含與目標伺服器連線資訊的 dict 列表。 例如，如果您的應用程式從不同的網域提供服務，並且您想要在瀏覽器中使用相同的 Swagger UI 與每個網域互動（而不是打開多個瀏覽器分頁），則可以使用它。或者，如果您想要固定可能的 URL。 如果未提供 servers list 或是一個空 list，則預設值將是一個 url 值為 / 的 dict。 列表中的每個項目都是一個包含以下內容的 dict： url：目標主機的 URL。此 URL 支援伺服器變數，並且可以是相對的，以指示主機位置相對於提供 OpenAPI 文件的位置。當變數在 {括號} 中命名時，將進行變數替換。 description：描述 URL 指定主機的選用字串。可以使用 CommonMark 語法 進行富文本表示。 variables：變數名稱及其值之間的 dict。該值用於在伺服器的 URL 範本中進行替換。 在FastAPI 代理後端文件中了解更多資訊。 範例 from fastapi import FastAPI app = FastAPI( servers=[ {"url": "https://stag.example.com", "description": "Staging environment"}, {"url": "https://prod.example.com", "description": "Production environment"}, ] ) 類型： Optional[List[Dict[str, Union[str, Any]]]] 預設值： None
dependencies	全域 dependencies 列表，它們將應用於每個*路徑操作*，包括子路由器中的操作。 在FastAPI 全域 Dependencies 文件中了解更多資訊。 範例 from fastapi import Depends, FastAPI from .dependencies import func_dep_1, func_dep_2 app = FastAPI(dependencies=[Depends(func_dep_1), Depends(func_dep_2)]) 類型： Optional[Sequence[Depends]] 預設值： None
default_response_class	預設使用的回應類別。 在FastAPI 自訂回應 - HTML、串流、檔案等的文檔中了解更多。 範例 from fastapi import FastAPI from fastapi.responses import ORJSONResponse app = FastAPI(default_response_class=ORJSONResponse) 類型： Type[Response] 預設值： Default(JSONResponse)
redirect_slashes	當客戶端使用的格式不同時，是否偵測並重導 URL 中的斜線。 範例 from fastapi import FastAPI app = FastAPI(redirect_slashes=True) # the default @app.get("/items/") async def read_items(): return [{"item_id": "Foo"}] 使用此應用程式，如果客戶端訪問 /items（沒有尾端斜線），他們將會被 HTTP 狀態碼 307 自動重導至 /items/。 類型： bool 預設值： True
docs_url	自動互動式 API 文件的路徑。它在瀏覽器中由 Swagger UI 處理。 預設 URL 為 /docs。您可以將其設定為 None 來停用它。 如果 openapi_url 設定為 None，則會自動停用此功能。 在FastAPI 中繼資料和 Docs URLs 的文檔中了解更多。 範例 from fastapi import FastAPI app = FastAPI(docs_url="/documentation", redoc_url=None) 類型： Optional[str] 預設值： '/docs'
redoc_url	由 ReDoc 提供的替代自動互動式 API 文件的路徑。 預設 URL 為 /redoc。您可以將其設定為 None 來停用它。 如果 openapi_url 設定為 None，則會自動停用此功能。 在FastAPI 中繼資料和 Docs URLs 的文檔中了解更多。 範例 from fastapi import FastAPI app = FastAPI(docs_url="/documentation", redoc_url="redocumentation") 類型： Optional[str] 預設值： '/redoc'
swagger_ui_oauth2_redirect_url	Swagger UI 的 OAuth2 重導端點。 預設為 /docs/oauth2-redirect。 這僅在您將 OAuth2（使用「授權」按鈕）與 Swagger UI 一起使用時才會用到。 類型： Optional[str] 預設值： '/docs/oauth2-redirect'
swagger_ui_init_oauth	Swagger UI 的 OAuth2 設定，預設顯示在 /docs。 在Swagger UI 文件中閱讀更多關於可用設定選項的資訊。 類型： Optional[Dict[str, Any]] 預設值： None
middleware	建立應用程式時要新增的中介軟體清單。 在 FastAPI 中，您通常會使用 app.add_middleware() 來執行此操作。 在FastAPI 中介軟體的文檔中了解更多。 類型： Optional[Sequence[Middleware]] 預設值： None
exception_handlers	包含例外處理程式的字典。 在 FastAPI 中，您通常會使用裝飾器 @app.exception_handler()。 在FastAPI 錯誤處理的文檔中了解更多。 類型： Optional[Dict[Union[int, Type[Exception]], Callable[[Request, Any], Coroutine[Any, Any, Response]]]] 預設值： None
on_startup	啟動事件處理函數的清單。 您應該改用 lifespan 處理程式。 更多資訊請參閱FastAPI lifespan 文件。 類型： Optional[Sequence[Callable[[], Any]]] 預設值： None
on_shutdown	關閉事件處理函式的清單。 您應該改用 lifespan 處理程式。 更多資訊請參閱FastAPI lifespan 文件。 類型： Optional[Sequence[Callable[[], Any]]] 預設值： None
lifespan	一個 Lifespan 上下文管理器處理程式。它以單個上下文管理器取代了 startup 和 shutdown 函式。 更多資訊請參閱FastAPI lifespan 文件。 類型： Optional[Lifespan[AppType]] 預設值： None
terms_of_service	API 服務條款的網址。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 更多資訊請參閱FastAPI 中繼資料和文件網址文件。 範例 app = FastAPI(terms_of_service="http://example.com/terms/") 類型： Optional[str] 預設值： None
contact	包含公開 API 聯絡資訊的字典。 它可以包含多個欄位。 name：（str）聯絡人／組織的名稱。 url：（str）指向聯絡資訊的網址。必須是網址格式。 email：（str）聯絡人／組織的電子郵件地址。必須是電子郵件地址格式。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 更多資訊請參閱FastAPI 中繼資料和文件網址文件。 範例 app = FastAPI( contact={ "name": "Deadpoolio the Amazing", "url": "http://x-force.example.com/contact/", "email": "dp@x-force.example.com", } ) 類型： Optional[Dict[str, Union[str, Any]]] 預設值： None
license_info	包含公開 API 授權資訊的字典。 它可以包含多個欄位。 name：（str）必填（如果設定了 license_info）。API 使用的授權名稱。 identifier：（str）API 的 SPDX 授權表達式。identifier 欄位與 url 欄位互斥。從 OpenAPI 3.1.0、FastAPI 0.99.0 開始提供。 url：（str）API 使用的授權網址。必須是網址格式。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 更多資訊請參閱FastAPI 中繼資料和文件網址文件。 範例 app = FastAPI( license_info={ "name": "Apache 2.0", "url": "https://www.apache.org/licenses/LICENSE-2.0.html", } ) 類型： Optional[Dict[str, Union[str, Any]]] 預設值： None
openapi_prefix	「openapi_prefix」已被棄用，改用「root_path」，它更符合 ASGI 標準，更簡單，也更自動化。OpenAPI 網址的網址前綴。 類型： str 預設值： ''
root_path	由代理伺服器處理的路徑前綴，應用程式看不到，但外部用戶端可以看到，這會影響 Swagger UI 等內容。 更多資訊請參閱FastAPI 代理伺服器後端文件。 範例 from fastapi import FastAPI app = FastAPI(root_path="/api/v1") 類型： str 預設值： ''
root_path_in_servers	停用在自動產生的 OpenAPI 中的 servers 欄位中使用 root_path 自動產生網址。 更多資訊請參閱FastAPI 代理伺服器後端文件。 範例 from fastapi import FastAPI app = FastAPI(root_path_in_servers=False) 類型： bool 預設值： True
responses	在 OpenAPI 中顯示的額外回應。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 更多資訊請參閱FastAPI OpenAPI 中的額外回應文件。 以及FastAPI 大型應用程式文件。 類型： Optional[Dict[Union[int, str], Dict[str, Any]]] 預設值： None
callbacks	應該套用於所有*路徑操作*的 OpenAPI 回呼。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 更多資訊請參閱FastAPI OpenAPI 回呼文件。 類型： Optional[List[BaseRoute]] 預設值： None
webhooks	新增 OpenAPI Webhook。這類似於 callbacks，但它不依賴於特定的*路徑操作*。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 注意：此功能從 OpenAPI 3.1.0、FastAPI 0.99.0 開始提供。 更多資訊請參閱FastAPI OpenAPI Webhook 文件。 類型： Optional[APIRouter] 預設值： None
已棄用	將所有*路徑操作*標記為已棄用。您可能不需要它，但它仍然可用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 路徑操作設定文件中了解更多資訊。 類型： Optional[bool] 預設值： None
include_in_schema	是否在產生的 OpenAPI 中包含（或不包含）所有*路徑操作*。您可能不需要它，但它仍然可用。 這會影響產生的 OpenAPI（例如在 /docs 中可見）。 在FastAPI 查詢參數和字串驗證文件中了解更多資訊。 類型： bool 預設值： True
swagger_ui_parameters	用於設定 Swagger UI 的參數，Swagger UI 是自動產生的互動式 API 文件（預設位於 /docs）。 在FastAPI 如何設定 Swagger UI 的文件中了解更多資訊。 類型： Optional[Dict[str, Any]] 預設值： None
generate_unique_id_function	自訂用於產生 OpenAPI 中顯示的*路徑操作*之唯一 ID 的函式。 這在自動為您的 API 產生客戶端或 SDK 時特別有用。 在FastAPI 如何產生客戶端的文件中了解更多資訊。 類型： Callable[[APIRoute], str] 預設值： Default(generate_unique_id)
separate_input_output_schemas	是否在結果更精確時為請求主體和回應主體產生單獨的 OpenAPI 結構描述。 這在自動產生客戶端時特別有用。 例如，如果您有一個像這樣的模型： from pydantic import BaseModel class Item(BaseModel): name: str tags: list[str] = [] 當 Item 用於輸入（請求主體）時，tags 不是必需的，客戶端不必提供它。 但是當 Item 用於輸出（回應主體）時，tags 始終可用，因為它具有預設值，即使它只是一個空列表。因此，客戶端應該能夠始終預期它。 在這種情況下，會有兩個不同的結構描述，一個用於輸入，另一個用於輸出。 類型： bool 預設值： True
**extra	要儲存在應用程式中的額外關鍵字參數，FastAPI 任何地方都不會使用。 類型： Any 預設值： {}

原始程式碼位於 fastapi/applications.py

def __init__(
    self: AppType,
    *,
    debug: Annotated[
        bool,
        Doc(
            """
            Boolean indicating if debug tracebacks should be returned on server
            errors.

            Read more in the
            [Starlette docs for Applications](https://www.starlette.io/applications/#instantiating-the-application).
            """
        ),
    ] = False,
    routes: Annotated[
        Optional[List[BaseRoute]],
        Doc(
            """
            **Note**: you probably shouldn't use this parameter, it is inherited
            from Starlette and supported for compatibility.

            ---

            A list of routes to serve incoming HTTP and WebSocket requests.
            """
        ),
        deprecated(
            """
            You normally wouldn't use this parameter with FastAPI, it is inherited
            from Starlette and supported for compatibility.

            In FastAPI, you normally would use the *path operation methods*,
            like `app.get()`, `app.post()`, etc.
            """
        ),
    ] = None,
    title: Annotated[
        str,
        Doc(
            """
            The title of the API.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more in the
            [FastAPI docs for Metadata and Docs URLs](https://fastapi.dev.org.tw/tutorial/metadata/#metadata-for-api).

            **Example**

            ```python
            from fastapi import FastAPI

            app = FastAPI(title="ChimichangApp")
            ```
            """
        ),
    ] = "FastAPI",
    summary: Annotated[
        Optional[str],
        Doc(
            """
            A short summary of the API.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more in the
            [FastAPI docs for Metadata and Docs URLs](https://fastapi.dev.org.tw/tutorial/metadata/#metadata-for-api).

            **Example**

            ```python
            from fastapi import FastAPI

            app = FastAPI(summary="Deadpond's favorite app. Nuff said.")
            ```
            """
        ),
    ] = None,
    description: Annotated[
        str,
        Doc(
            '''
            A description of the API. Supports Markdown (using
            [CommonMark syntax](https://commonmark.org/)).

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more in the
            [FastAPI docs for Metadata and Docs URLs](https://fastapi.dev.org.tw/tutorial/metadata/#metadata-for-api).

            **Example**

            ```python
            from fastapi import FastAPI

            app = FastAPI(
                description="""
                            ChimichangApp API helps you do awesome stuff. 🚀

                            ## Items

                            You can **read items**.

                            ## Users

                            You will be able to:

                            * **Create users** (_not implemented_).
                            * **Read users** (_not implemented_).

                            """
            )
            ```
            '''
        ),
    ] = "",
    version: Annotated[
        str,
        Doc(
            """
            The version of the API.

            **Note** This is the version of your application, not the version of
            the OpenAPI specification nor the version of FastAPI being used.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more in the
            [FastAPI docs for Metadata and Docs URLs](https://fastapi.dev.org.tw/tutorial/metadata/#metadata-for-api).

            **Example**

            ```python
            from fastapi import FastAPI

            app = FastAPI(version="0.0.1")
            ```
            """
        ),
    ] = "0.1.0",
    openapi_url: Annotated[
        Optional[str],
        Doc(
            """
            The URL where the OpenAPI schema will be served from.

            If you set it to `None`, no OpenAPI schema will be served publicly, and
            the default automatic endpoints `/docs` and `/redoc` will also be
            disabled.

            Read more in the
            [FastAPI docs for Metadata and Docs URLs](https://fastapi.dev.org.tw/tutorial/metadata/#openapi-url).

            **Example**

            ```python
            from fastapi import FastAPI

            app = FastAPI(openapi_url="/api/v1/openapi.json")
            ```
            """
        ),
    ] = "/openapi.json",
    openapi_tags: Annotated[
        Optional[List[Dict[str, Any]]],
        Doc(
            """
            A list of tags used by OpenAPI, these are the same `tags` you can set
            in the *path operations*, like:

            * `@app.get("/users/", tags=["users"])`
            * `@app.get("/items/", tags=["items"])`

            The order of the tags can be used to specify the order shown in
            tools like Swagger UI, used in the automatic path `/docs`.

            It's not required to specify all the tags used.

            The tags that are not declared MAY be organized randomly or based
            on the tools' logic. Each tag name in the list MUST be unique.

            The value of each item is a `dict` containing:

            * `name`: The name of the tag.
            * `description`: A short description of the tag.
                [CommonMark syntax](https://commonmark.org/) MAY be used for rich
                text representation.
            * `externalDocs`: Additional external documentation for this tag. If
                provided, it would contain a `dict` with:
                * `description`: A short description of the target documentation.
                    [CommonMark syntax](https://commonmark.org/) MAY be used for
                    rich text representation.
                * `url`: The URL for the target documentation. Value MUST be in
                    the form of a URL.

            Read more in the
            [FastAPI docs for Metadata and Docs URLs](https://fastapi.dev.org.tw/tutorial/metadata/#metadata-for-tags).

            **Example**

            ```python
            from fastapi import FastAPI

            tags_metadata = [
                {
                    "name": "users",
                    "description": "Operations with users. The **login** logic is also here.",
                },
                {
                    "name": "items",
                    "description": "Manage items. So _fancy_ they have their own docs.",
                    "externalDocs": {
                        "description": "Items external docs",
                        "url": "https://fastapi.dev.org.tw/",
                    },
                },
            ]

            app = FastAPI(openapi_tags=tags_metadata)
            ```
            """
        ),
    ] = None,
    servers: Annotated[
        Optional[List[Dict[str, Union[str, Any]]]],
        Doc(
            """
            A `list` of `dict`s with connectivity information to a target server.

            You would use it, for example, if your application is served from
            different domains and you want to use the same Swagger UI in the
            browser to interact with each of them (instead of having multiple
            browser tabs open). Or if you want to leave fixed the possible URLs.

            If the servers `list` is not provided, or is an empty `list`, the
            default value would be a `dict` with a `url` value of `/`.

            Each item in the `list` is a `dict` containing:

            * `url`: A URL to the target host. This URL supports Server Variables
            and MAY be relative, to indicate that the host location is relative
            to the location where the OpenAPI document is being served. Variable
            substitutions will be made when a variable is named in `{`brackets`}`.
            * `description`: An optional string describing the host designated by
            the URL. [CommonMark syntax](https://commonmark.org/) MAY be used for
            rich text representation.
            * `variables`: A `dict` between a variable name and its value. The value
                is used for substitution in the server's URL template.

            Read more in the
            [FastAPI docs for Behind a Proxy](https://fastapi.dev.org.tw/advanced/behind-a-proxy/#additional-servers).

            **Example**

            ```python
            from fastapi import FastAPI

            app = FastAPI(
                servers=[
                    {"url": "https://stag.example.com", "description": "Staging environment"},
                    {"url": "https://prod.example.com", "description": "Production environment"},
                ]
            )
            ```
            """
        ),
    ] = None,
    dependencies: Annotated[
        Optional[Sequence[Depends]],
        Doc(
            """
            A list of global dependencies, they will be applied to each
            *path operation*, including in sub-routers.

            Read more about it in the
            [FastAPI docs for Global Dependencies](https://fastapi.dev.org.tw/tutorial/dependencies/global-dependencies/).

            **Example**

            ```python
            from fastapi import Depends, FastAPI

            from .dependencies import func_dep_1, func_dep_2

            app = FastAPI(dependencies=[Depends(func_dep_1), Depends(func_dep_2)])
            ```
            """
        ),
    ] = None,
    default_response_class: Annotated[
        Type[Response],
        Doc(
            """
            The default response class to be used.

            Read more in the
            [FastAPI docs for Custom Response - HTML, Stream, File, others](https://fastapi.dev.org.tw/advanced/custom-response/#default-response-class).

            **Example**

            ```python
            from fastapi import FastAPI
            from fastapi.responses import ORJSONResponse

            app = FastAPI(default_response_class=ORJSONResponse)
            ```
            """
        ),
    ] = Default(JSONResponse),
    redirect_slashes: Annotated[
        bool,
        Doc(
            """
            Whether to detect and redirect slashes in URLs when the client doesn't
            use the same format.

            **Example**

            ```python
            from fastapi import FastAPI

            app = FastAPI(redirect_slashes=True)  # the default

            @app.get("/items/")
            async def read_items():
                return [{"item_id": "Foo"}]
            ```

            With this app, if a client goes to `/items` (without a trailing slash),
            they will be automatically redirected with an HTTP status code of 307
            to `/items/`.
            """
        ),
    ] = True,
    docs_url: Annotated[
        Optional[str],
        Doc(
            """
            The path to the automatic interactive API documentation.
            It is handled in the browser by Swagger UI.

            The default URL is `/docs`. You can disable it by setting it to `None`.

            If `openapi_url` is set to `None`, this will be automatically disabled.

            Read more in the
            [FastAPI docs for Metadata and Docs URLs](https://fastapi.dev.org.tw/tutorial/metadata/#docs-urls).

            **Example**

            ```python
            from fastapi import FastAPI

            app = FastAPI(docs_url="/documentation", redoc_url=None)
            ```
            """
        ),
    ] = "/docs",
    redoc_url: Annotated[
        Optional[str],
        Doc(
            """
            The path to the alternative automatic interactive API documentation
            provided by ReDoc.

            The default URL is `/redoc`. You can disable it by setting it to `None`.

            If `openapi_url` is set to `None`, this will be automatically disabled.

            Read more in the
            [FastAPI docs for Metadata and Docs URLs](https://fastapi.dev.org.tw/tutorial/metadata/#docs-urls).

            **Example**

            ```python
            from fastapi import FastAPI

            app = FastAPI(docs_url="/documentation", redoc_url="redocumentation")
            ```
            """
        ),
    ] = "/redoc",
    swagger_ui_oauth2_redirect_url: Annotated[
        Optional[str],
        Doc(
            """
            The OAuth2 redirect endpoint for the Swagger UI.

            By default it is `/docs/oauth2-redirect`.

            This is only used if you use OAuth2 (with the "Authorize" button)
            with Swagger UI.
            """
        ),
    ] = "/docs/oauth2-redirect",
    swagger_ui_init_oauth: Annotated[
        Optional[Dict[str, Any]],
        Doc(
            """
            OAuth2 configuration for the Swagger UI, by default shown at `/docs`.

            Read more about the available configuration options in the
            [Swagger UI docs](https://swagger.dev.org.tw/docs/open-source-tools/swagger-ui/usage/oauth2/).
            """
        ),
    ] = None,
    middleware: Annotated[
        Optional[Sequence[Middleware]],
        Doc(
            """
            List of middleware to be added when creating the application.

            In FastAPI you would normally do this with `app.add_middleware()`
            instead.

            Read more in the
            [FastAPI docs for Middleware](https://fastapi.dev.org.tw/tutorial/middleware/).
            """
        ),
    ] = None,
    exception_handlers: Annotated[
        Optional[
            Dict[
                Union[int, Type[Exception]],
                Callable[[Request, Any], Coroutine[Any, Any, Response]],
            ]
        ],
        Doc(
            """
            A dictionary with handlers for exceptions.

            In FastAPI, you would normally use the decorator
            `@app.exception_handler()`.

            Read more in the
            [FastAPI docs for Handling Errors](https://fastapi.dev.org.tw/tutorial/handling-errors/).
            """
        ),
    ] = None,
    on_startup: Annotated[
        Optional[Sequence[Callable[[], Any]]],
        Doc(
            """
            A list of startup event handler functions.

            You should instead use the `lifespan` handlers.

            Read more in the [FastAPI docs for `lifespan`](https://fastapi.dev.org.tw/advanced/events/).
            """
        ),
    ] = None,
    on_shutdown: Annotated[
        Optional[Sequence[Callable[[], Any]]],
        Doc(
            """
            A list of shutdown event handler functions.

            You should instead use the `lifespan` handlers.

            Read more in the
            [FastAPI docs for `lifespan`](https://fastapi.dev.org.tw/advanced/events/).
            """
        ),
    ] = None,
    lifespan: Annotated[
        Optional[Lifespan[AppType]],
        Doc(
            """
            A `Lifespan` context manager handler. This replaces `startup` and
            `shutdown` functions with a single context manager.

            Read more in the
            [FastAPI docs for `lifespan`](https://fastapi.dev.org.tw/advanced/events/).
            """
        ),
    ] = None,
    terms_of_service: Annotated[
        Optional[str],
        Doc(
            """
            A URL to the Terms of Service for your API.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more at the
            [FastAPI docs for Metadata and Docs URLs](https://fastapi.dev.org.tw/tutorial/metadata/#metadata-for-api).

            **Example**

            ```python
            app = FastAPI(terms_of_service="http://example.com/terms/")
            ```
            """
        ),
    ] = None,
    contact: Annotated[
        Optional[Dict[str, Union[str, Any]]],
        Doc(
            """
            A dictionary with the contact information for the exposed API.

            It can contain several fields.

            * `name`: (`str`) The name of the contact person/organization.
            * `url`: (`str`) A URL pointing to the contact information. MUST be in
                the format of a URL.
            * `email`: (`str`) The email address of the contact person/organization.
                MUST be in the format of an email address.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more at the
            [FastAPI docs for Metadata and Docs URLs](https://fastapi.dev.org.tw/tutorial/metadata/#metadata-for-api).

            **Example**

            ```python
            app = FastAPI(
                contact={
                    "name": "Deadpoolio the Amazing",
                    "url": "http://x-force.example.com/contact/",
                    "email": "dp@x-force.example.com",
                }
            )
            ```
            """
        ),
    ] = None,
    license_info: Annotated[
        Optional[Dict[str, Union[str, Any]]],
        Doc(
            """
            A dictionary with the license information for the exposed API.

            It can contain several fields.

            * `name`: (`str`) **REQUIRED** (if a `license_info` is set). The
                license name used for the API.
            * `identifier`: (`str`) An [SPDX](https://spdx.dev/) license expression
                for the API. The `identifier` field is mutually exclusive of the `url`
                field. Available since OpenAPI 3.1.0, FastAPI 0.99.0.
            * `url`: (`str`) A URL to the license used for the API. This MUST be
                the format of a URL.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more at the
            [FastAPI docs for Metadata and Docs URLs](https://fastapi.dev.org.tw/tutorial/metadata/#metadata-for-api).

            **Example**

            ```python
            app = FastAPI(
                license_info={
                    "name": "Apache 2.0",
                    "url": "https://www.apache.org/licenses/LICENSE-2.0.html",
                }
            )
            ```
            """
        ),
    ] = None,
    openapi_prefix: Annotated[
        str,
        Doc(
            """
            A URL prefix for the OpenAPI URL.
            """
        ),
        deprecated(
            """
            "openapi_prefix" has been deprecated in favor of "root_path", which
            follows more closely the ASGI standard, is simpler, and more
            automatic.
            """
        ),
    ] = "",
    root_path: Annotated[
        str,
        Doc(
            """
            A path prefix handled by a proxy that is not seen by the application
            but is seen by external clients, which affects things like Swagger UI.

            Read more about it at the
            [FastAPI docs for Behind a Proxy](https://fastapi.dev.org.tw/advanced/behind-a-proxy/).

            **Example**

            ```python
            from fastapi import FastAPI

            app = FastAPI(root_path="/api/v1")
            ```
            """
        ),
    ] = "",
    root_path_in_servers: Annotated[
        bool,
        Doc(
            """
            To disable automatically generating the URLs in the `servers` field
            in the autogenerated OpenAPI using the `root_path`.

            Read more about it in the
            [FastAPI docs for Behind a Proxy](https://fastapi.dev.org.tw/advanced/behind-a-proxy/#disable-automatic-server-from-root_path).

            **Example**

            ```python
            from fastapi import FastAPI

            app = FastAPI(root_path_in_servers=False)
            ```
            """
        ),
    ] = True,
    responses: Annotated[
        Optional[Dict[Union[int, str], Dict[str, Any]]],
        Doc(
            """
            Additional responses to be shown in OpenAPI.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Additional Responses in OpenAPI](https://fastapi.dev.org.tw/advanced/additional-responses/).

            And in the
            [FastAPI docs for Bigger Applications](https://fastapi.dev.org.tw/tutorial/bigger-applications/#include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies).
            """
        ),
    ] = None,
    callbacks: Annotated[
        Optional[List[BaseRoute]],
        Doc(
            """
            OpenAPI callbacks that should apply to all *path operations*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for OpenAPI Callbacks](https://fastapi.dev.org.tw/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    webhooks: Annotated[
        Optional[routing.APIRouter],
        Doc(
            """
            Add OpenAPI webhooks. This is similar to `callbacks` but it doesn't
            depend on specific *path operations*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            **Note**: This is available since OpenAPI 3.1.0, FastAPI 0.99.0.

            Read more about it in the
            [FastAPI docs for OpenAPI Webhooks](https://fastapi.dev.org.tw/advanced/openapi-webhooks/).
            """
        ),
    ] = None,
    deprecated: Annotated[
        Optional[bool],
        Doc(
            """
            Mark all *path operations* as deprecated. You probably don't need it,
            but it's available.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    include_in_schema: Annotated[
        bool,
        Doc(
            """
            To include (or not) all the *path operations* in the generated OpenAPI.
            You probably don't need it, but it's available.

            This affects the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Query Parameters and String Validations](https://fastapi.dev.org.tw/tutorial/query-params-str-validations/#exclude-from-openapi).
            """
        ),
    ] = True,
    swagger_ui_parameters: Annotated[
        Optional[Dict[str, Any]],
        Doc(
            """
            Parameters to configure Swagger UI, the autogenerated interactive API
            documentation (by default at `/docs`).

            Read more about it in the
            [FastAPI docs about how to Configure Swagger UI](https://fastapi.dev.org.tw/how-to/configure-swagger-ui/).
            """
        ),
    ] = None,
    generate_unique_id_function: Annotated[
        Callable[[routing.APIRoute], str],
        Doc(
            """
            Customize the function used to generate unique IDs for the *path
            operations* shown in the generated OpenAPI.

            This is particularly useful when automatically generating clients or
            SDKs for your API.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.dev.org.tw/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = Default(generate_unique_id),
    separate_input_output_schemas: Annotated[
        bool,
        Doc(
            """
            Whether to generate separate OpenAPI schemas for request body and
            response body when the results would be more precise.

            This is particularly useful when automatically generating clients.

            For example, if you have a model like:

            ```python
            from pydantic import BaseModel

            class Item(BaseModel):
                name: str
                tags: list[str] = []
            ```

            When `Item` is used for input, a request body, `tags` is not required,
            the client doesn't have to provide it.

            But when using `Item` for output, for a response body, `tags` is always
            available because it has a default value, even if it's just an empty
            list. So, the client should be able to always expect it.

            In this case, there would be two different schemas, one for input and
            another one for output.
            """
        ),
    ] = True,
    **extra: Annotated[
        Any,
        Doc(
            """
            Extra keyword arguments to be stored in the app, not used by FastAPI
            anywhere.
            """
        ),
    ],
) -> None:
    self.debug = debug
    self.title = title
    self.summary = summary
    self.description = description
    self.version = version
    self.terms_of_service = terms_of_service
    self.contact = contact
    self.license_info = license_info
    self.openapi_url = openapi_url
    self.openapi_tags = openapi_tags
    self.root_path_in_servers = root_path_in_servers
    self.docs_url = docs_url
    self.redoc_url = redoc_url
    self.swagger_ui_oauth2_redirect_url = swagger_ui_oauth2_redirect_url
    self.swagger_ui_init_oauth = swagger_ui_init_oauth
    self.swagger_ui_parameters = swagger_ui_parameters
    self.servers = servers or []
    self.separate_input_output_schemas = separate_input_output_schemas
    self.extra = extra
    self.openapi_version: Annotated[
        str,
        Doc(
            """
            The version string of OpenAPI.

            FastAPI will generate OpenAPI version 3.1.0, and will output that as
            the OpenAPI version. But some tools, even though they might be
            compatible with OpenAPI 3.1.0, might not recognize it as a valid.

            So you could override this value to trick those tools into using
            the generated OpenAPI. Have in mind that this is a hack. But if you
            avoid using features added in OpenAPI 3.1.0, it might work for your
            use case.

            This is not passed as a parameter to the `FastAPI` class to avoid
            giving the false idea that FastAPI would generate a different OpenAPI
            schema. It is only available as an attribute.

            **Example**

            ```python
            from fastapi import FastAPI

            app = FastAPI()

            app.openapi_version = "3.0.2"
            ```
            """
        ),
    ] = "3.1.0"
    self.openapi_schema: Optional[Dict[str, Any]] = None
    if self.openapi_url:
        assert self.title, "A title must be provided for OpenAPI, e.g.: 'My API'"
        assert self.version, "A version must be provided for OpenAPI, e.g.: '2.1.0'"
    # TODO: remove when discarding the openapi_prefix parameter
    if openapi_prefix:
        logger.warning(
            '"openapi_prefix" has been deprecated in favor of "root_path", which '
            "follows more closely the ASGI standard, is simpler, and more "
            "automatic. Check the docs at "
            "https://fastapi.dev.org.tw/advanced/sub-applications/"
        )
    self.webhooks: Annotated[
        routing.APIRouter,
        Doc(
            """
            The `app.webhooks` attribute is an `APIRouter` with the *path
            operations* that will be used just for documentation of webhooks.

            Read more about it in the
            [FastAPI docs for OpenAPI Webhooks](https://fastapi.dev.org.tw/advanced/openapi-webhooks/).
            """
        ),
    ] = webhooks or routing.APIRouter()
    self.root_path = root_path or openapi_prefix
    self.state: Annotated[
        State,
        Doc(
            """
            A state object for the application. This is the same object for the
            entire application, it doesn't change from request to request.

            You normally wouldn't use this in FastAPI, for most of the cases you
            would instead use FastAPI dependencies.

            This is simply inherited from Starlette.

            Read more about it in the
            [Starlette docs for Applications](https://www.starlette.io/applications/#storing-state-on-the-app-instance).
            """
        ),
    ] = State()
    self.dependency_overrides: Annotated[
        Dict[Callable[..., Any], Callable[..., Any]],
        Doc(
            """
            A dictionary with overrides for the dependencies.

            Each key is the original dependency callable, and the value is the
            actual dependency that should be called.

            This is for testing, to replace expensive dependencies with testing
            versions.

            Read more about it in the
            [FastAPI docs for Testing Dependencies with Overrides](https://fastapi.dev.org.tw/advanced/testing-dependencies/).
            """
        ),
    ] = {}
    self.router: routing.APIRouter = routing.APIRouter(
        routes=routes,
        redirect_slashes=redirect_slashes,
        dependency_overrides_provider=self,
        on_startup=on_startup,
        on_shutdown=on_shutdown,
        lifespan=lifespan,
        default_response_class=default_response_class,
        dependencies=dependencies,
        callbacks=callbacks,
        deprecated=deprecated,
        include_in_schema=include_in_schema,
        responses=responses,
        generate_unique_id_function=generate_unique_id_function,
    )
    self.exception_handlers: Dict[
        Any, Callable[[Request, Any], Union[Response, Awaitable[Response]]]
    ] = {} if exception_handlers is None else dict(exception_handlers)
    self.exception_handlers.setdefault(HTTPException, http_exception_handler)
    self.exception_handlers.setdefault(
        RequestValidationError, request_validation_exception_handler
    )
    self.exception_handlers.setdefault(
        WebSocketRequestValidationError,
        # Starlette still has incorrect type specification for the handlers
        websocket_request_validation_exception_handler,  # type: ignore
    )

    self.user_middleware: List[Middleware] = (
        [] if middleware is None else list(middleware)
    )
    self.middleware_stack: Union[ASGIApp, None] = None
    self.setup()

openapi_version 實例屬性

openapi_version = '3.1.0'

OpenAPI 的版本字串。

FastAPI 將產生 OpenAPI 版本 3.1.0，並將其輸出為 OpenAPI 版本。但有些工具，即使它們可能與 OpenAPI 3.1.0 相容，也可能無法將其識別為有效版本。

因此，您可以覆寫此值來欺騙這些工具使用產生的 OpenAPI。請記住，這是一個權宜之計。但如果您避免使用 OpenAPI 3.1.0 中新增的功能，它可能適用於您的用例。

這不會作為參數傳遞給 FastAPI 類別，以避免產生 FastAPI 會產生不同 OpenAPI 結構描述的錯誤印象。它僅作為屬性提供。

範例

from fastapi import FastAPI

app = FastAPI()

app.openapi_version = "3.0.2"

webhooks 實例屬性

webhooks = webhooks or APIRouter()

app.webhooks 屬性是一個 APIRouter，其中的*路徑操作*將僅用於 Webhook 的文件記錄。

更多資訊請參閱FastAPI OpenAPI Webhook 文件。

state 實例屬性

state = State()

應用程式的狀態物件。這是整個應用程式的同一個物件，它不會因請求而異。

您通常不會在 FastAPI 中使用這個，在大多數情況下，您應該使用 FastAPI 依賴項。

這只是從 Starlette 繼承而來的。

在 Starlette 應用程式文件 中了解更多相關資訊。

dependency_overrides 實例屬性

dependency_overrides = {}

一個包含依賴項覆蓋的字典。

每個鍵都是原始的依賴項可呼叫物件，而值是應該被呼叫的實際依賴項。

這是用於測試的，用於將昂貴的依賴項替換為測試版本。

在 FastAPI 測試依賴項覆蓋文件 中了解更多相關資訊。

openapi

openapi()

產生應用程式的 OpenAPI 結構描述。這是由 FastAPI 內部呼叫的。

第一次呼叫它時，它會將結果儲存在屬性 app.openapi_schema 中，而下次呼叫它時，它只會返回相同的結果。以避免每次都產生結構描述的成本。

如果您需要修改產生的 OpenAPI 結構描述，您可以修改它。

在 FastAPI OpenAPI 文件 中了解更多資訊。

原始程式碼位於 fastapi/applications.py

def openapi(self) -> Dict[str, Any]:
    """
    Generate the OpenAPI schema of the application. This is called by FastAPI
    internally.

    The first time it is called it stores the result in the attribute
    `app.openapi_schema`, and next times it is called, it just returns that same
    result. To avoid the cost of generating the schema every time.

    If you need to modify the generated OpenAPI schema, you could modify it.

    Read more in the
    [FastAPI docs for OpenAPI](https://fastapi.dev.org.tw/how-to/extending-openapi/).
    """
    if not self.openapi_schema:
        self.openapi_schema = get_openapi(
            title=self.title,
            version=self.version,
            openapi_version=self.openapi_version,
            summary=self.summary,
            description=self.description,
            terms_of_service=self.terms_of_service,
            contact=self.contact,
            license_info=self.license_info,
            routes=self.routes,
            webhooks=self.webhooks.routes,
            tags=self.openapi_tags,
            servers=self.servers,
            separate_input_output_schemas=self.separate_input_output_schemas,
        )
    return self.openapi_schema

websocket

websocket(path, name=None, *, dependencies=None)

裝飾一個 WebSocket 函式。

在 FastAPI WebSockets 文件 中了解更多相關資訊。

範例

from fastapi import FastAPI, WebSocket

app = FastAPI()

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()
    while True:
        data = await websocket.receive_text()
        await websocket.send_text(f"Message text was: {data}")

參數	說明
路徑	WebSocket 路徑。 類型： str
名稱	WebSocket 的名稱。僅供內部使用。 類型： Optional[str] 預設值： None
dependencies	此 WebSocket 要使用的依賴項清單（使用 Depends()）。 在 FastAPI WebSockets 文件 中了解更多相關資訊。 類型： Optional[Sequence[Depends]] 預設值： None

原始程式碼位於 fastapi/applications.py

def websocket(
    self,
    path: Annotated[
        str,
        Doc(
            """
            WebSocket path.
            """
        ),
    ],
    name: Annotated[
        Optional[str],
        Doc(
            """
            A name for the WebSocket. Only used internally.
            """
        ),
    ] = None,
    *,
    dependencies: Annotated[
        Optional[Sequence[Depends]],
        Doc(
            """
            A list of dependencies (using `Depends()`) to be used for this
            WebSocket.

            Read more about it in the
            [FastAPI docs for WebSockets](https://fastapi.dev.org.tw/advanced/websockets/).
            """
        ),
    ] = None,
) -> Callable[[DecoratedCallable], DecoratedCallable]:
    """
    Decorate a WebSocket function.

    Read more about it in the
    [FastAPI docs for WebSockets](https://fastapi.dev.org.tw/advanced/websockets/).

    **Example**

    ```python
    from fastapi import FastAPI, WebSocket

    app = FastAPI()

    @app.websocket("/ws")
    async def websocket_endpoint(websocket: WebSocket):
        await websocket.accept()
        while True:
            data = await websocket.receive_text()
            await websocket.send_text(f"Message text was: {data}")
    ```
    """

    def decorator(func: DecoratedCallable) -> DecoratedCallable:
        self.add_api_websocket_route(
            path,
            func,
            name=name,
            dependencies=dependencies,
        )
        return func

    return decorator

include_router

include_router(
    router,
    *,
    prefix="",
    tags=None,
    dependencies=None,
    responses=None,
    deprecated=None,
    include_in_schema=True,
    default_response_class=Default(JSONResponse),
    callbacks=None,
    generate_unique_id_function=Default(generate_unique_id)
)

在同一個應用程式中包含一個 APIRouter。

在 FastAPI 大型應用程式文件 中了解更多相關資訊。

範例

from fastapi import FastAPI

from .users import users_router

app = FastAPI()

app.include_router(users_router)

參數	說明
路由器	要包含的 APIRouter。 類型： APIRouter
前綴	路由器的選用路徑前綴。 類型： str 預設值： ''
標籤	要套用至此路由器中所有*路徑操作*的標籤清單。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 路徑操作設定文件中了解更多資訊。 類型： Optional[List[Union[str, Enum]]] 預設值： None
dependencies	要套用至此路由器中所有*路徑操作*的依賴項清單（使用 Depends()）。 在 FastAPI 大型應用程式 - 多個檔案文件 中了解更多相關資訊。 範例 from fastapi import Depends, FastAPI from .dependencies import get_token_header from .internal import admin app = FastAPI() app.include_router( admin.router, dependencies=[Depends(get_token_header)], ) 類型： Optional[Sequence[Depends]] 預設值： None
responses	在 OpenAPI 中顯示的額外回應。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 更多資訊請參閱FastAPI OpenAPI 中的額外回應文件。 以及FastAPI 大型應用程式文件。 類型： Optional[Dict[Union[int, str], Dict[str, Any]]] 預設值： None
已棄用	將此路由器中的所有*路徑操作*標記為已棄用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 範例 from fastapi import FastAPI from .internal import old_api app = FastAPI() app.include_router( old_api.router, deprecated=True, ) 類型： Optional[bool] 預設值： None
include_in_schema	在產生的 OpenAPI 模式中包含（或不包含）此路由器中的所有*路徑操作*。 這會影響產生的 OpenAPI（例如在 /docs 中可見）。 範例 from fastapi import FastAPI from .internal import old_api app = FastAPI() app.include_router( old_api.router, include_in_schema=False, ) 類型： bool 預設值： True
default_response_class	此路由器中*路徑操作*的預設回應類別。 在FastAPI 自訂回應 - HTML、串流、檔案等的文檔中了解更多。 範例 from fastapi import FastAPI from fastapi.responses import ORJSONResponse from .internal import old_api app = FastAPI() app.include_router( old_api.router, default_response_class=ORJSONResponse, ) 類型： Type[Response] 預設值： Default(JSONResponse)
callbacks	將用作 OpenAPI 回呼的*路徑操作*清單。 這僅適用於 OpenAPI 文件，回呼不會直接使用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 更多資訊請參閱FastAPI OpenAPI 回呼文件。 類型： Optional[List[BaseRoute]] 預設值： None
generate_unique_id_function	自訂用於產生 OpenAPI 中顯示的*路徑操作*之唯一 ID 的函式。 這在自動為您的 API 產生客戶端或 SDK 時特別有用。 在FastAPI 如何產生客戶端的文件中了解更多資訊。 類型： Callable[[APIRoute], str] 預設值： Default(generate_unique_id)

原始程式碼位於 fastapi/applications.py

def include_router(
    self,
    router: Annotated[routing.APIRouter, Doc("The `APIRouter` to include.")],
    *,
    prefix: Annotated[str, Doc("An optional path prefix for the router.")] = "",
    tags: Annotated[
        Optional[List[Union[str, Enum]]],
        Doc(
            """
            A list of tags to be applied to all the *path operations* in this
            router.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Optional[Sequence[Depends]],
        Doc(
            """
            A list of dependencies (using `Depends()`) to be applied to all the
            *path operations* in this router.

            Read more about it in the
            [FastAPI docs for Bigger Applications - Multiple Files](https://fastapi.dev.org.tw/tutorial/bigger-applications/#include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies).

            **Example**

            ```python
            from fastapi import Depends, FastAPI

            from .dependencies import get_token_header
            from .internal import admin

            app = FastAPI()

            app.include_router(
                admin.router,
                dependencies=[Depends(get_token_header)],
            )
            ```
            """
        ),
    ] = None,
    responses: Annotated[
        Optional[Dict[Union[int, str], Dict[str, Any]]],
        Doc(
            """
            Additional responses to be shown in OpenAPI.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Additional Responses in OpenAPI](https://fastapi.dev.org.tw/advanced/additional-responses/).

            And in the
            [FastAPI docs for Bigger Applications](https://fastapi.dev.org.tw/tutorial/bigger-applications/#include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies).
            """
        ),
    ] = None,
    deprecated: Annotated[
        Optional[bool],
        Doc(
            """
            Mark all the *path operations* in this router as deprecated.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            **Example**

            ```python
            from fastapi import FastAPI

            from .internal import old_api

            app = FastAPI()

            app.include_router(
                old_api.router,
                deprecated=True,
            )
            ```
            """
        ),
    ] = None,
    include_in_schema: Annotated[
        bool,
        Doc(
            """
            Include (or not) all the *path operations* in this router in the
            generated OpenAPI schema.

            This affects the generated OpenAPI (e.g. visible at `/docs`).

            **Example**

            ```python
            from fastapi import FastAPI

            from .internal import old_api

            app = FastAPI()

            app.include_router(
                old_api.router,
                include_in_schema=False,
            )
            ```
            """
        ),
    ] = True,
    default_response_class: Annotated[
        Type[Response],
        Doc(
            """
            Default response class to be used for the *path operations* in this
            router.

            Read more in the
            [FastAPI docs for Custom Response - HTML, Stream, File, others](https://fastapi.dev.org.tw/advanced/custom-response/#default-response-class).

            **Example**

            ```python
            from fastapi import FastAPI
            from fastapi.responses import ORJSONResponse

            from .internal import old_api

            app = FastAPI()

            app.include_router(
                old_api.router,
                default_response_class=ORJSONResponse,
            )
            ```
            """
        ),
    ] = Default(JSONResponse),
    callbacks: Annotated[
        Optional[List[BaseRoute]],
        Doc(
            """
            List of *path operations* that will be used as OpenAPI callbacks.

            This is only for OpenAPI documentation, the callbacks won't be used
            directly.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for OpenAPI Callbacks](https://fastapi.dev.org.tw/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    generate_unique_id_function: Annotated[
        Callable[[routing.APIRoute], str],
        Doc(
            """
            Customize the function used to generate unique IDs for the *path
            operations* shown in the generated OpenAPI.

            This is particularly useful when automatically generating clients or
            SDKs for your API.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.dev.org.tw/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = Default(generate_unique_id),
) -> None:
    """
    Include an `APIRouter` in the same app.

    Read more about it in the
    [FastAPI docs for Bigger Applications](https://fastapi.dev.org.tw/tutorial/bigger-applications/).

    ## Example

    ```python
    from fastapi import FastAPI

    from .users import users_router

    app = FastAPI()

    app.include_router(users_router)
    ```
    """
    self.router.include_router(
        router,
        prefix=prefix,
        tags=tags,
        dependencies=dependencies,
        responses=responses,
        deprecated=deprecated,
        include_in_schema=include_in_schema,
        default_response_class=default_response_class,
        callbacks=callbacks,
        generate_unique_id_function=generate_unique_id_function,
    )

get

get(
    path,
    *,
    response_model=Default(None),
    status_code=None,
    tags=None,
    dependencies=None,
    summary=None,
    description=None,
    response_description="Successful Response",
    responses=None,
    deprecated=None,
    operation_id=None,
    response_model_include=None,
    response_model_exclude=None,
    response_model_by_alias=True,
    response_model_exclude_unset=False,
    response_model_exclude_defaults=False,
    response_model_exclude_none=False,
    include_in_schema=True,
    response_class=Default(JSONResponse),
    name=None,
    callbacks=None,
    openapi_extra=None,
    generate_unique_id_function=Default(generate_unique_id)
)

使用 HTTP GET 操作新增*路徑操作*。

範例

from fastapi import FastAPI

app = FastAPI()

@app.get("/items/")
def read_items():
    return [{"name": "Empanada"}, {"name": "Arepa"}]

參數	說明
路徑	此*路徑操作*要使用的 URL 路徑。 例如，在 http://example.com/items 中，路徑是 /items。 類型： str
response_model（回應模型）	用於回應的類型。 它可以是任何有效的 Pydantic *欄位*類型。因此，它不必是 Pydantic 模型，它可以是其他類型，例如 list、dict 等。 它將用於 文件：產生的 OpenAPI（以及 /docs 的使用者介面）將其顯示為回應（JSON Schema）。 序列化：您可以返回任意物件，`response_model` 將用於將該物件序列化為相應的 JSON。 過濾：傳送到用戶端的 JSON 將僅包含 `response_model` 中定義的資料（欄位）。如果您返回的物件包含屬性 `password`，但 `response_model` 不包含該欄位，則傳送到用戶端的 JSON 將不包含 `password`。 驗證：您返回的任何內容都將使用 `response_model` 進行序列化，並根據需要轉換任何資料以產生相應的 JSON。但是，如果返回的物件中的資料無效，則表示違反了與用戶端的合約，因此這是 API 開發人員的錯誤。因此，FastAPI 將引發錯誤並返回 500 錯誤碼（內部伺服器錯誤）。 在FastAPI 的回應模型文件中了解更多資訊。 類型： Any 預設值： Default(None)
status_code（狀態碼）	用於回應的預設狀態碼。 您可以透過直接返回回應來覆寫狀態碼。 在FastAPI 的回應狀態碼文件中了解更多資訊。 類型： Optional[int] 預設值： None
標籤	要套用至*路徑操作*的標籤清單。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 的路徑操作設定文件中了解更多資訊。 類型： Optional[List[Union[str, Enum]]] 預設值： None
dependencies	要套用至*路徑操作*的依存關係清單（使用 Depends()）。 在FastAPI 的路徑操作裝飾器中的依存關係文件中了解更多資訊。 類型： Optional[Sequence[Depends]] 預設值： None
summary	*路徑操作*的摘要。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 路徑操作設定文件中了解更多資訊。 類型： Optional[str] 預設值： None
description	*路徑操作*的描述。 如果未提供，將會從*路徑操作函式*的文件字串中自動擷取。 它可以包含 Markdown。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 路徑操作設定文件中了解更多資訊。 類型： Optional[str] 預設值： None
response_description（回應描述）	預設回應的描述。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： str 預設值： '成功回應'
responses	此*路徑操作*可以返回的其他回應。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： Optional[Dict[Union[int, str], Dict[str, Any]]] 預設值： None
已棄用	將此*路徑操作*標記為已棄用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： Optional[bool] 預設值： None
operation_id（操作 ID）	此 *路徑操作* 要使用的自訂操作 ID。 預設情況下，它會自動生成。 如果您提供自訂操作 ID，則需要確保它在整個 API 中是唯一的。 您可以使用 FastAPI 類別中的 generate_unique_id_function 參數來自訂操作 ID 的生成方式。 在FastAPI 如何產生客戶端的文件中了解更多資訊。 類型： Optional[str] 預設值： None
response_model_include	傳遞給 Pydantic 的設定，用於僅包含回應數據中的特定欄位。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： Optional[IncEx] 預設值： None
response_model_exclude	傳遞給 Pydantic 的設定，用於排除回應數據中的特定欄位。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： Optional[IncEx] 預設值： None
response_model_by_alias	傳遞給 Pydantic 的設定，用於定義當使用別名時，回應模型是否應透過別名進行序列化。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： True
response_model_exclude_unset	傳遞給 Pydantic 的設定，用於定義回應數據是否應包含所有欄位，包括那些未設定且具有預設值的欄位。這與 response_model_exclude_defaults 不同，如果設定了欄位，即使值與預設值相同，它們也會包含在回應中。 當設為 True 時，預設值會從回應中省略。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
response_model_exclude_defaults	傳遞給 Pydantic 的設定，用於定義回應數據是否應包含所有欄位，包括那些與預設值相同的欄位。這與 response_model_exclude_unset 不同，如果設定了欄位但包含相同的預設值，它們將從回應中排除。 當設為 True 時，預設值會從回應中省略。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
response_model_exclude_none	傳遞給 Pydantic 的設定，用於定義回應數據是否應排除設為 None 的欄位。 這比 response_model_exclude_unset 和 response_model_exclude_defaults 簡單得多（不那麼聰明）。您可能想要使用這兩個其中之一而不是這個，因為它們允許在合理的情況下返回 None 值。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
include_in_schema	將此 *路徑操作* 包含在生成的 OpenAPI 模式中。 這會影響產生的 OpenAPI（例如在 /docs 中可見）。 在FastAPI 查詢參數和字串驗證文件中了解更多資訊。 類型： bool 預設值： True
response_class	此 *路徑操作* 要使用的回應類別。 如果您直接返回回應，則不會使用此選項。 在 FastAPI 自訂回應 - HTML、串流、檔案等文件 中了解更多資訊。 類型： Type[Response] 預設值： Default(JSONResponse)
名稱	此 *路徑操作* 的名稱。僅供內部使用。 類型： Optional[str] 預設值： None
callbacks	將用作 OpenAPI 回呼的*路徑操作*清單。 這僅適用於 OpenAPI 文件，回呼不會直接使用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 更多資訊請參閱FastAPI OpenAPI 回呼文件。 類型： Optional[List[BaseRoute]] 預設值： None
openapi_extra	要包含在此 *路徑操作* 的 OpenAPI 模式中的額外中繼資料。 在 FastAPI 路徑操作進階設定文件 中了解更多資訊。 類型： Optional[Dict[str, Any]] 預設值： None
generate_unique_id_function	自訂用於產生 OpenAPI 中顯示的*路徑操作*之唯一 ID 的函式。 這在自動為您的 API 產生客戶端或 SDK 時特別有用。 在FastAPI 如何產生客戶端的文件中了解更多資訊。 類型： Callable[[APIRoute], str] 預設值： Default(generate_unique_id)

原始程式碼位於 fastapi/applications.py

def get(
    self,
    path: Annotated[
        str,
        Doc(
            """
            The URL path to be used for this *path operation*.

            For example, in `http://example.com/items`, the path is `/items`.
            """
        ),
    ],
    *,
    response_model: Annotated[
        Any,
        Doc(
            """
            The type to use for the response.

            It could be any valid Pydantic *field* type. So, it doesn't have to
            be a Pydantic model, it could be other things, like a `list`, `dict`,
            etc.

            It will be used for:

            * Documentation: the generated OpenAPI (and the UI at `/docs`) will
                show it as the response (JSON Schema).
            * Serialization: you could return an arbitrary object and the
                `response_model` would be used to serialize that object into the
                corresponding JSON.
            * Filtering: the JSON sent to the client will only contain the data
                (fields) defined in the `response_model`. If you returned an object
                that contains an attribute `password` but the `response_model` does
                not include that field, the JSON sent to the client would not have
                that `password`.
            * Validation: whatever you return will be serialized with the
                `response_model`, converting any data as necessary to generate the
                corresponding JSON. But if the data in the object returned is not
                valid, that would mean a violation of the contract with the client,
                so it's an error from the API developer. So, FastAPI will raise an
                error and return a 500 error code (Internal Server Error).

            Read more about it in the
            [FastAPI docs for Response Model](https://fastapi.dev.org.tw/tutorial/response-model/).
            """
        ),
    ] = Default(None),
    status_code: Annotated[
        Optional[int],
        Doc(
            """
            The default status code to be used for the response.

            You could override the status code by returning a response directly.

            Read more about it in the
            [FastAPI docs for Response Status Code](https://fastapi.dev.org.tw/tutorial/response-status-code/).
            """
        ),
    ] = None,
    tags: Annotated[
        Optional[List[Union[str, Enum]]],
        Doc(
            """
            A list of tags to be applied to the *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/#tags).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Optional[Sequence[Depends]],
        Doc(
            """
            A list of dependencies (using `Depends()`) to be applied to the
            *path operation*.

            Read more about it in the
            [FastAPI docs for Dependencies in path operation decorators](https://fastapi.dev.org.tw/tutorial/dependencies/dependencies-in-path-operation-decorators/).
            """
        ),
    ] = None,
    summary: Annotated[
        Optional[str],
        Doc(
            """
            A summary for the *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    description: Annotated[
        Optional[str],
        Doc(
            """
            A description for the *path operation*.

            If not provided, it will be extracted automatically from the docstring
            of the *path operation function*.

            It can contain Markdown.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    response_description: Annotated[
        str,
        Doc(
            """
            The description for the default response.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = "Successful Response",
    responses: Annotated[
        Optional[Dict[Union[int, str], Dict[str, Any]]],
        Doc(
            """
            Additional responses that could be returned by this *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    deprecated: Annotated[
        Optional[bool],
        Doc(
            """
            Mark this *path operation* as deprecated.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    operation_id: Annotated[
        Optional[str],
        Doc(
            """
            Custom operation ID to be used by this *path operation*.

            By default, it is generated automatically.

            If you provide a custom operation ID, you need to make sure it is
            unique for the whole API.

            You can customize the
            operation ID generation with the parameter
            `generate_unique_id_function` in the `FastAPI` class.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.dev.org.tw/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = None,
    response_model_include: Annotated[
        Optional[IncEx],
        Doc(
            """
            Configuration passed to Pydantic to include only certain fields in the
            response data.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_exclude: Annotated[
        Optional[IncEx],
        Doc(
            """
            Configuration passed to Pydantic to exclude certain fields in the
            response data.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_by_alias: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response model
            should be serialized by alias when an alias is used.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = True,
    response_model_exclude_unset: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data
            should have all the fields, including the ones that were not set and
            have their default values. This is different from
            `response_model_exclude_defaults` in that if the fields are set,
            they will be included in the response, even if the value is the same
            as the default.

            When `True`, default values are omitted from the response.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#use-the-response_model_exclude_unset-parameter).
            """
        ),
    ] = False,
    response_model_exclude_defaults: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data
            should have all the fields, including the ones that have the same value
            as the default. This is different from `response_model_exclude_unset`
            in that if the fields are set but contain the same default values,
            they will be excluded from the response.

            When `True`, default values are omitted from the response.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#use-the-response_model_exclude_unset-parameter).
            """
        ),
    ] = False,
    response_model_exclude_none: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data should
            exclude fields set to `None`.

            This is much simpler (less smart) than `response_model_exclude_unset`
            and `response_model_exclude_defaults`. You probably want to use one of
            those two instead of this one, as those allow returning `None` values
            when it makes sense.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_exclude_none).
            """
        ),
    ] = False,
    include_in_schema: Annotated[
        bool,
        Doc(
            """
            Include this *path operation* in the generated OpenAPI schema.

            This affects the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Query Parameters and String Validations](https://fastapi.dev.org.tw/tutorial/query-params-str-validations/#exclude-from-openapi).
            """
        ),
    ] = True,
    response_class: Annotated[
        Type[Response],
        Doc(
            """
            Response class to be used for this *path operation*.

            This will not be used if you return a response directly.

            Read more about it in the
            [FastAPI docs for Custom Response - HTML, Stream, File, others](https://fastapi.dev.org.tw/advanced/custom-response/#redirectresponse).
            """
        ),
    ] = Default(JSONResponse),
    name: Annotated[
        Optional[str],
        Doc(
            """
            Name for this *path operation*. Only used internally.
            """
        ),
    ] = None,
    callbacks: Annotated[
        Optional[List[BaseRoute]],
        Doc(
            """
            List of *path operations* that will be used as OpenAPI callbacks.

            This is only for OpenAPI documentation, the callbacks won't be used
            directly.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for OpenAPI Callbacks](https://fastapi.dev.org.tw/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    openapi_extra: Annotated[
        Optional[Dict[str, Any]],
        Doc(
            """
            Extra metadata to be included in the OpenAPI schema for this *path
            operation*.

            Read more about it in the
            [FastAPI docs for Path Operation Advanced Configuration](https://fastapi.dev.org.tw/advanced/path-operation-advanced-configuration/#custom-openapi-path-operation-schema).
            """
        ),
    ] = None,
    generate_unique_id_function: Annotated[
        Callable[[routing.APIRoute], str],
        Doc(
            """
            Customize the function used to generate unique IDs for the *path
            operations* shown in the generated OpenAPI.

            This is particularly useful when automatically generating clients or
            SDKs for your API.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.dev.org.tw/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = Default(generate_unique_id),
) -> Callable[[DecoratedCallable], DecoratedCallable]:
    """
    Add a *path operation* using an HTTP GET operation.

    ## Example

    ```python
    from fastapi import FastAPI

    app = FastAPI()

    @app.get("/items/")
    def read_items():
        return [{"name": "Empanada"}, {"name": "Arepa"}]
    ```
    """
    return self.router.get(
        path,
        response_model=response_model,
        status_code=status_code,
        tags=tags,
        dependencies=dependencies,
        summary=summary,
        description=description,
        response_description=response_description,
        responses=responses,
        deprecated=deprecated,
        operation_id=operation_id,
        response_model_include=response_model_include,
        response_model_exclude=response_model_exclude,
        response_model_by_alias=response_model_by_alias,
        response_model_exclude_unset=response_model_exclude_unset,
        response_model_exclude_defaults=response_model_exclude_defaults,
        response_model_exclude_none=response_model_exclude_none,
        include_in_schema=include_in_schema,
        response_class=response_class,
        name=name,
        callbacks=callbacks,
        openapi_extra=openapi_extra,
        generate_unique_id_function=generate_unique_id_function,
    )

put

put(
    path,
    *,
    response_model=Default(None),
    status_code=None,
    tags=None,
    dependencies=None,
    summary=None,
    description=None,
    response_description="Successful Response",
    responses=None,
    deprecated=None,
    operation_id=None,
    response_model_include=None,
    response_model_exclude=None,
    response_model_by_alias=True,
    response_model_exclude_unset=False,
    response_model_exclude_defaults=False,
    response_model_exclude_none=False,
    include_in_schema=True,
    response_class=Default(JSONResponse),
    name=None,
    callbacks=None,
    openapi_extra=None,
    generate_unique_id_function=Default(generate_unique_id)
)

使用 HTTP PUT 操作新增 *路徑操作*。

範例

from fastapi import FastAPI
from pydantic import BaseModel

class Item(BaseModel):
    name: str
    description: str | None = None

app = FastAPI()

@app.put("/items/{item_id}")
def replace_item(item_id: str, item: Item):
    return {"message": "Item replaced", "id": item_id}

參數	說明
路徑	此*路徑操作*要使用的 URL 路徑。 例如，在 http://example.com/items 中，路徑是 /items。 類型： str
response_model（回應模型）	用於回應的類型。 它可以是任何有效的 Pydantic *欄位*類型。因此，它不必是 Pydantic 模型，它可以是其他類型，例如 list、dict 等。 它將用於 文件：產生的 OpenAPI（以及 /docs 的使用者介面）將其顯示為回應（JSON Schema）。 序列化：您可以返回任意物件，`response_model` 將用於將該物件序列化為相應的 JSON。 過濾：傳送到用戶端的 JSON 將僅包含 `response_model` 中定義的資料（欄位）。如果您返回的物件包含屬性 `password`，但 `response_model` 不包含該欄位，則傳送到用戶端的 JSON 將不包含 `password`。 驗證：您返回的任何內容都將使用 `response_model` 進行序列化，並根據需要轉換任何資料以產生相應的 JSON。但是，如果返回的物件中的資料無效，則表示違反了與用戶端的合約，因此這是 API 開發人員的錯誤。因此，FastAPI 將引發錯誤並返回 500 錯誤碼（內部伺服器錯誤）。 在FastAPI 的回應模型文件中了解更多資訊。 類型： Any 預設值： Default(None)
status_code（狀態碼）	用於回應的預設狀態碼。 您可以透過直接返回回應來覆寫狀態碼。 在FastAPI 的回應狀態碼文件中了解更多資訊。 類型： Optional[int] 預設值： None
標籤	要套用至*路徑操作*的標籤清單。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 的路徑操作設定文件中了解更多資訊。 類型： Optional[List[Union[str, Enum]]] 預設值： None
dependencies	要套用至*路徑操作*的依存關係清單（使用 Depends()）。 在FastAPI 的路徑操作裝飾器中的依存關係文件中了解更多資訊。 類型： Optional[Sequence[Depends]] 預設值： None
summary	*路徑操作*的摘要。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 路徑操作設定文件中了解更多資訊。 類型： Optional[str] 預設值： None
description	*路徑操作*的描述。 如果未提供，將會從*路徑操作函式*的文件字串中自動擷取。 它可以包含 Markdown。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 路徑操作設定文件中了解更多資訊。 類型： Optional[str] 預設值： None
response_description（回應描述）	預設回應的描述。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： str 預設值： '成功回應'
responses	此*路徑操作*可以返回的其他回應。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： Optional[Dict[Union[int, str], Dict[str, Any]]] 預設值： None
已棄用	將此*路徑操作*標記為已棄用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： Optional[bool] 預設值： None
operation_id（操作 ID）	此 *路徑操作* 要使用的自訂操作 ID。 預設情況下，它會自動生成。 如果您提供自訂操作 ID，則需要確保它在整個 API 中是唯一的。 您可以使用 FastAPI 類別中的 generate_unique_id_function 參數來自訂操作 ID 的生成方式。 在FastAPI 如何產生客戶端的文件中了解更多資訊。 類型： Optional[str] 預設值： None
response_model_include	傳遞給 Pydantic 的設定，用於僅包含回應數據中的特定欄位。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： Optional[IncEx] 預設值： None
response_model_exclude	傳遞給 Pydantic 的設定，用於排除回應數據中的特定欄位。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： Optional[IncEx] 預設值： None
response_model_by_alias	傳遞給 Pydantic 的設定，用於定義當使用別名時，回應模型是否應透過別名進行序列化。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： True
response_model_exclude_unset	傳遞給 Pydantic 的設定，用於定義回應數據是否應包含所有欄位，包括那些未設定且具有預設值的欄位。這與 response_model_exclude_defaults 不同，如果設定了欄位，即使值與預設值相同，它們也會包含在回應中。 當設為 True 時，預設值會從回應中省略。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
response_model_exclude_defaults	傳遞給 Pydantic 的設定，用於定義回應數據是否應包含所有欄位，包括那些與預設值相同的欄位。這與 response_model_exclude_unset 不同，如果設定了欄位但包含相同的預設值，它們將從回應中排除。 當設為 True 時，預設值會從回應中省略。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
response_model_exclude_none	傳遞給 Pydantic 的設定，用於定義回應數據是否應排除設為 None 的欄位。 這比 response_model_exclude_unset 和 response_model_exclude_defaults 簡單得多（不那麼聰明）。您可能想要使用這兩個其中之一而不是這個，因為它們允許在合理的情況下返回 None 值。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
include_in_schema	將此 *路徑操作* 包含在生成的 OpenAPI 模式中。 這會影響產生的 OpenAPI（例如在 /docs 中可見）。 在FastAPI 查詢參數和字串驗證文件中了解更多資訊。 類型： bool 預設值： True
response_class	此 *路徑操作* 要使用的回應類別。 如果您直接返回回應，則不會使用此選項。 在 FastAPI 自訂回應 - HTML、串流、檔案等文件 中了解更多資訊。 類型： Type[Response] 預設值： Default(JSONResponse)
名稱	此 *路徑操作* 的名稱。僅供內部使用。 類型： Optional[str] 預設值： None
callbacks	將用作 OpenAPI 回呼的*路徑操作*清單。 這僅適用於 OpenAPI 文件，回呼不會直接使用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 更多資訊請參閱FastAPI OpenAPI 回呼文件。 類型： Optional[List[BaseRoute]] 預設值： None
openapi_extra	要包含在此 *路徑操作* 的 OpenAPI 模式中的額外中繼資料。 在 FastAPI 路徑操作進階設定文件 中了解更多資訊。 類型： Optional[Dict[str, Any]] 預設值： None
generate_unique_id_function	自訂用於產生 OpenAPI 中顯示的*路徑操作*之唯一 ID 的函式。 這在自動為您的 API 產生客戶端或 SDK 時特別有用。 在FastAPI 如何產生客戶端的文件中了解更多資訊。 類型： Callable[[APIRoute], str] 預設值： Default(generate_unique_id)

原始程式碼位於 fastapi/applications.py

def put(
    self,
    path: Annotated[
        str,
        Doc(
            """
            The URL path to be used for this *path operation*.

            For example, in `http://example.com/items`, the path is `/items`.
            """
        ),
    ],
    *,
    response_model: Annotated[
        Any,
        Doc(
            """
            The type to use for the response.

            It could be any valid Pydantic *field* type. So, it doesn't have to
            be a Pydantic model, it could be other things, like a `list`, `dict`,
            etc.

            It will be used for:

            * Documentation: the generated OpenAPI (and the UI at `/docs`) will
                show it as the response (JSON Schema).
            * Serialization: you could return an arbitrary object and the
                `response_model` would be used to serialize that object into the
                corresponding JSON.
            * Filtering: the JSON sent to the client will only contain the data
                (fields) defined in the `response_model`. If you returned an object
                that contains an attribute `password` but the `response_model` does
                not include that field, the JSON sent to the client would not have
                that `password`.
            * Validation: whatever you return will be serialized with the
                `response_model`, converting any data as necessary to generate the
                corresponding JSON. But if the data in the object returned is not
                valid, that would mean a violation of the contract with the client,
                so it's an error from the API developer. So, FastAPI will raise an
                error and return a 500 error code (Internal Server Error).

            Read more about it in the
            [FastAPI docs for Response Model](https://fastapi.dev.org.tw/tutorial/response-model/).
            """
        ),
    ] = Default(None),
    status_code: Annotated[
        Optional[int],
        Doc(
            """
            The default status code to be used for the response.

            You could override the status code by returning a response directly.

            Read more about it in the
            [FastAPI docs for Response Status Code](https://fastapi.dev.org.tw/tutorial/response-status-code/).
            """
        ),
    ] = None,
    tags: Annotated[
        Optional[List[Union[str, Enum]]],
        Doc(
            """
            A list of tags to be applied to the *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/#tags).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Optional[Sequence[Depends]],
        Doc(
            """
            A list of dependencies (using `Depends()`) to be applied to the
            *path operation*.

            Read more about it in the
            [FastAPI docs for Dependencies in path operation decorators](https://fastapi.dev.org.tw/tutorial/dependencies/dependencies-in-path-operation-decorators/).
            """
        ),
    ] = None,
    summary: Annotated[
        Optional[str],
        Doc(
            """
            A summary for the *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    description: Annotated[
        Optional[str],
        Doc(
            """
            A description for the *path operation*.

            If not provided, it will be extracted automatically from the docstring
            of the *path operation function*.

            It can contain Markdown.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    response_description: Annotated[
        str,
        Doc(
            """
            The description for the default response.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = "Successful Response",
    responses: Annotated[
        Optional[Dict[Union[int, str], Dict[str, Any]]],
        Doc(
            """
            Additional responses that could be returned by this *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    deprecated: Annotated[
        Optional[bool],
        Doc(
            """
            Mark this *path operation* as deprecated.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    operation_id: Annotated[
        Optional[str],
        Doc(
            """
            Custom operation ID to be used by this *path operation*.

            By default, it is generated automatically.

            If you provide a custom operation ID, you need to make sure it is
            unique for the whole API.

            You can customize the
            operation ID generation with the parameter
            `generate_unique_id_function` in the `FastAPI` class.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.dev.org.tw/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = None,
    response_model_include: Annotated[
        Optional[IncEx],
        Doc(
            """
            Configuration passed to Pydantic to include only certain fields in the
            response data.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_exclude: Annotated[
        Optional[IncEx],
        Doc(
            """
            Configuration passed to Pydantic to exclude certain fields in the
            response data.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_by_alias: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response model
            should be serialized by alias when an alias is used.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = True,
    response_model_exclude_unset: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data
            should have all the fields, including the ones that were not set and
            have their default values. This is different from
            `response_model_exclude_defaults` in that if the fields are set,
            they will be included in the response, even if the value is the same
            as the default.

            When `True`, default values are omitted from the response.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#use-the-response_model_exclude_unset-parameter).
            """
        ),
    ] = False,
    response_model_exclude_defaults: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data
            should have all the fields, including the ones that have the same value
            as the default. This is different from `response_model_exclude_unset`
            in that if the fields are set but contain the same default values,
            they will be excluded from the response.

            When `True`, default values are omitted from the response.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#use-the-response_model_exclude_unset-parameter).
            """
        ),
    ] = False,
    response_model_exclude_none: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data should
            exclude fields set to `None`.

            This is much simpler (less smart) than `response_model_exclude_unset`
            and `response_model_exclude_defaults`. You probably want to use one of
            those two instead of this one, as those allow returning `None` values
            when it makes sense.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_exclude_none).
            """
        ),
    ] = False,
    include_in_schema: Annotated[
        bool,
        Doc(
            """
            Include this *path operation* in the generated OpenAPI schema.

            This affects the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Query Parameters and String Validations](https://fastapi.dev.org.tw/tutorial/query-params-str-validations/#exclude-from-openapi).
            """
        ),
    ] = True,
    response_class: Annotated[
        Type[Response],
        Doc(
            """
            Response class to be used for this *path operation*.

            This will not be used if you return a response directly.

            Read more about it in the
            [FastAPI docs for Custom Response - HTML, Stream, File, others](https://fastapi.dev.org.tw/advanced/custom-response/#redirectresponse).
            """
        ),
    ] = Default(JSONResponse),
    name: Annotated[
        Optional[str],
        Doc(
            """
            Name for this *path operation*. Only used internally.
            """
        ),
    ] = None,
    callbacks: Annotated[
        Optional[List[BaseRoute]],
        Doc(
            """
            List of *path operations* that will be used as OpenAPI callbacks.

            This is only for OpenAPI documentation, the callbacks won't be used
            directly.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for OpenAPI Callbacks](https://fastapi.dev.org.tw/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    openapi_extra: Annotated[
        Optional[Dict[str, Any]],
        Doc(
            """
            Extra metadata to be included in the OpenAPI schema for this *path
            operation*.

            Read more about it in the
            [FastAPI docs for Path Operation Advanced Configuration](https://fastapi.dev.org.tw/advanced/path-operation-advanced-configuration/#custom-openapi-path-operation-schema).
            """
        ),
    ] = None,
    generate_unique_id_function: Annotated[
        Callable[[routing.APIRoute], str],
        Doc(
            """
            Customize the function used to generate unique IDs for the *path
            operations* shown in the generated OpenAPI.

            This is particularly useful when automatically generating clients or
            SDKs for your API.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.dev.org.tw/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = Default(generate_unique_id),
) -> Callable[[DecoratedCallable], DecoratedCallable]:
    """
    Add a *path operation* using an HTTP PUT operation.

    ## Example

    ```python
    from fastapi import FastAPI
    from pydantic import BaseModel

    class Item(BaseModel):
        name: str
        description: str | None = None

    app = FastAPI()

    @app.put("/items/{item_id}")
    def replace_item(item_id: str, item: Item):
        return {"message": "Item replaced", "id": item_id}
    ```
    """
    return self.router.put(
        path,
        response_model=response_model,
        status_code=status_code,
        tags=tags,
        dependencies=dependencies,
        summary=summary,
        description=description,
        response_description=response_description,
        responses=responses,
        deprecated=deprecated,
        operation_id=operation_id,
        response_model_include=response_model_include,
        response_model_exclude=response_model_exclude,
        response_model_by_alias=response_model_by_alias,
        response_model_exclude_unset=response_model_exclude_unset,
        response_model_exclude_defaults=response_model_exclude_defaults,
        response_model_exclude_none=response_model_exclude_none,
        include_in_schema=include_in_schema,
        response_class=response_class,
        name=name,
        callbacks=callbacks,
        openapi_extra=openapi_extra,
        generate_unique_id_function=generate_unique_id_function,
    )

post

post(
    path,
    *,
    response_model=Default(None),
    status_code=None,
    tags=None,
    dependencies=None,
    summary=None,
    description=None,
    response_description="Successful Response",
    responses=None,
    deprecated=None,
    operation_id=None,
    response_model_include=None,
    response_model_exclude=None,
    response_model_by_alias=True,
    response_model_exclude_unset=False,
    response_model_exclude_defaults=False,
    response_model_exclude_none=False,
    include_in_schema=True,
    response_class=Default(JSONResponse),
    name=None,
    callbacks=None,
    openapi_extra=None,
    generate_unique_id_function=Default(generate_unique_id)
)

使用 HTTP POST 操作新增 *路徑操作*。

範例

from fastapi import FastAPI
from pydantic import BaseModel

class Item(BaseModel):
    name: str
    description: str | None = None

app = FastAPI()

@app.post("/items/")
def create_item(item: Item):
    return {"message": "Item created"}

參數	說明
路徑	此*路徑操作*要使用的 URL 路徑。 例如，在 http://example.com/items 中，路徑是 /items。 類型： str
response_model（回應模型）	用於回應的類型。 它可以是任何有效的 Pydantic *欄位*類型。因此，它不必是 Pydantic 模型，它可以是其他類型，例如 list、dict 等。 它將用於 文件：產生的 OpenAPI（以及 /docs 的使用者介面）將其顯示為回應（JSON Schema）。 序列化：您可以返回任意物件，`response_model` 將用於將該物件序列化為相應的 JSON。 過濾：傳送到用戶端的 JSON 將僅包含 `response_model` 中定義的資料（欄位）。如果您返回的物件包含屬性 `password`，但 `response_model` 不包含該欄位，則傳送到用戶端的 JSON 將不包含 `password`。 驗證：您返回的任何內容都將使用 `response_model` 進行序列化，並根據需要轉換任何資料以產生相應的 JSON。但是，如果返回的物件中的資料無效，則表示違反了與用戶端的合約，因此這是 API 開發人員的錯誤。因此，FastAPI 將引發錯誤並返回 500 錯誤碼（內部伺服器錯誤）。 在FastAPI 的回應模型文件中了解更多資訊。 類型： Any 預設值： Default(None)
status_code（狀態碼）	用於回應的預設狀態碼。 您可以透過直接返回回應來覆寫狀態碼。 在FastAPI 的回應狀態碼文件中了解更多資訊。 類型： Optional[int] 預設值： None
標籤	要套用至*路徑操作*的標籤清單。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 的路徑操作設定文件中了解更多資訊。 類型： Optional[List[Union[str, Enum]]] 預設值： None
dependencies	要套用至*路徑操作*的依存關係清單（使用 Depends()）。 在FastAPI 的路徑操作裝飾器中的依存關係文件中了解更多資訊。 類型： Optional[Sequence[Depends]] 預設值： None
summary	*路徑操作*的摘要。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 路徑操作設定文件中了解更多資訊。 類型： Optional[str] 預設值： None
description	*路徑操作*的描述。 如果未提供，將會從*路徑操作函式*的文件字串中自動擷取。 它可以包含 Markdown。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 路徑操作設定文件中了解更多資訊。 類型： Optional[str] 預設值： None
response_description（回應描述）	預設回應的描述。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： str 預設值： '成功回應'
responses	此*路徑操作*可以返回的其他回應。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： Optional[Dict[Union[int, str], Dict[str, Any]]] 預設值： None
已棄用	將此*路徑操作*標記為已棄用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： Optional[bool] 預設值： None
operation_id（操作 ID）	此 *路徑操作* 要使用的自訂操作 ID。 預設情況下，它會自動生成。 如果您提供自訂操作 ID，則需要確保它在整個 API 中是唯一的。 您可以使用 FastAPI 類別中的 generate_unique_id_function 參數來自訂操作 ID 的生成方式。 在FastAPI 如何產生客戶端的文件中了解更多資訊。 類型： Optional[str] 預設值： None
response_model_include	傳遞給 Pydantic 的設定，用於僅包含回應數據中的特定欄位。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： Optional[IncEx] 預設值： None
response_model_exclude	傳遞給 Pydantic 的設定，用於排除回應數據中的特定欄位。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： Optional[IncEx] 預設值： None
response_model_by_alias	傳遞給 Pydantic 的設定，用於定義當使用別名時，回應模型是否應透過別名進行序列化。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： True
response_model_exclude_unset	傳遞給 Pydantic 的設定，用於定義回應數據是否應包含所有欄位，包括那些未設定且具有預設值的欄位。這與 response_model_exclude_defaults 不同，如果設定了欄位，即使值與預設值相同，它們也會包含在回應中。 當設為 True 時，預設值會從回應中省略。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
response_model_exclude_defaults	傳遞給 Pydantic 的設定，用於定義回應數據是否應包含所有欄位，包括那些與預設值相同的欄位。這與 response_model_exclude_unset 不同，如果設定了欄位但包含相同的預設值，它們將從回應中排除。 當設為 True 時，預設值會從回應中省略。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
response_model_exclude_none	傳遞給 Pydantic 的設定，用於定義回應數據是否應排除設為 None 的欄位。 這比 response_model_exclude_unset 和 response_model_exclude_defaults 簡單得多（不那麼聰明）。您可能想要使用這兩個其中之一而不是這個，因為它們允許在合理的情況下返回 None 值。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
include_in_schema	將此 *路徑操作* 包含在生成的 OpenAPI 模式中。 這會影響產生的 OpenAPI（例如在 /docs 中可見）。 在FastAPI 查詢參數和字串驗證文件中了解更多資訊。 類型： bool 預設值： True
response_class	此 *路徑操作* 要使用的回應類別。 如果您直接返回回應，則不會使用此選項。 在 FastAPI 自訂回應 - HTML、串流、檔案等文件 中了解更多資訊。 類型： Type[Response] 預設值： Default(JSONResponse)
名稱	此 *路徑操作* 的名稱。僅供內部使用。 類型： Optional[str] 預設值： None
callbacks	將用作 OpenAPI 回呼的*路徑操作*清單。 這僅適用於 OpenAPI 文件，回呼不會直接使用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 更多資訊請參閱FastAPI OpenAPI 回呼文件。 類型： Optional[List[BaseRoute]] 預設值： None
openapi_extra	要包含在此 *路徑操作* 的 OpenAPI 模式中的額外中繼資料。 在 FastAPI 路徑操作進階設定文件 中了解更多資訊。 類型： Optional[Dict[str, Any]] 預設值： None
generate_unique_id_function	自訂用於產生 OpenAPI 中顯示的*路徑操作*之唯一 ID 的函式。 這在自動為您的 API 產生客戶端或 SDK 時特別有用。 在FastAPI 如何產生客戶端的文件中了解更多資訊。 類型： Callable[[APIRoute], str] 預設值： Default(generate_unique_id)

原始程式碼位於 fastapi/applications.py

def post(
    self,
    path: Annotated[
        str,
        Doc(
            """
            The URL path to be used for this *path operation*.

            For example, in `http://example.com/items`, the path is `/items`.
            """
        ),
    ],
    *,
    response_model: Annotated[
        Any,
        Doc(
            """
            The type to use for the response.

            It could be any valid Pydantic *field* type. So, it doesn't have to
            be a Pydantic model, it could be other things, like a `list`, `dict`,
            etc.

            It will be used for:

            * Documentation: the generated OpenAPI (and the UI at `/docs`) will
                show it as the response (JSON Schema).
            * Serialization: you could return an arbitrary object and the
                `response_model` would be used to serialize that object into the
                corresponding JSON.
            * Filtering: the JSON sent to the client will only contain the data
                (fields) defined in the `response_model`. If you returned an object
                that contains an attribute `password` but the `response_model` does
                not include that field, the JSON sent to the client would not have
                that `password`.
            * Validation: whatever you return will be serialized with the
                `response_model`, converting any data as necessary to generate the
                corresponding JSON. But if the data in the object returned is not
                valid, that would mean a violation of the contract with the client,
                so it's an error from the API developer. So, FastAPI will raise an
                error and return a 500 error code (Internal Server Error).

            Read more about it in the
            [FastAPI docs for Response Model](https://fastapi.dev.org.tw/tutorial/response-model/).
            """
        ),
    ] = Default(None),
    status_code: Annotated[
        Optional[int],
        Doc(
            """
            The default status code to be used for the response.

            You could override the status code by returning a response directly.

            Read more about it in the
            [FastAPI docs for Response Status Code](https://fastapi.dev.org.tw/tutorial/response-status-code/).
            """
        ),
    ] = None,
    tags: Annotated[
        Optional[List[Union[str, Enum]]],
        Doc(
            """
            A list of tags to be applied to the *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/#tags).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Optional[Sequence[Depends]],
        Doc(
            """
            A list of dependencies (using `Depends()`) to be applied to the
            *path operation*.

            Read more about it in the
            [FastAPI docs for Dependencies in path operation decorators](https://fastapi.dev.org.tw/tutorial/dependencies/dependencies-in-path-operation-decorators/).
            """
        ),
    ] = None,
    summary: Annotated[
        Optional[str],
        Doc(
            """
            A summary for the *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    description: Annotated[
        Optional[str],
        Doc(
            """
            A description for the *path operation*.

            If not provided, it will be extracted automatically from the docstring
            of the *path operation function*.

            It can contain Markdown.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    response_description: Annotated[
        str,
        Doc(
            """
            The description for the default response.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = "Successful Response",
    responses: Annotated[
        Optional[Dict[Union[int, str], Dict[str, Any]]],
        Doc(
            """
            Additional responses that could be returned by this *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    deprecated: Annotated[
        Optional[bool],
        Doc(
            """
            Mark this *path operation* as deprecated.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    operation_id: Annotated[
        Optional[str],
        Doc(
            """
            Custom operation ID to be used by this *path operation*.

            By default, it is generated automatically.

            If you provide a custom operation ID, you need to make sure it is
            unique for the whole API.

            You can customize the
            operation ID generation with the parameter
            `generate_unique_id_function` in the `FastAPI` class.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.dev.org.tw/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = None,
    response_model_include: Annotated[
        Optional[IncEx],
        Doc(
            """
            Configuration passed to Pydantic to include only certain fields in the
            response data.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_exclude: Annotated[
        Optional[IncEx],
        Doc(
            """
            Configuration passed to Pydantic to exclude certain fields in the
            response data.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_by_alias: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response model
            should be serialized by alias when an alias is used.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = True,
    response_model_exclude_unset: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data
            should have all the fields, including the ones that were not set and
            have their default values. This is different from
            `response_model_exclude_defaults` in that if the fields are set,
            they will be included in the response, even if the value is the same
            as the default.

            When `True`, default values are omitted from the response.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#use-the-response_model_exclude_unset-parameter).
            """
        ),
    ] = False,
    response_model_exclude_defaults: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data
            should have all the fields, including the ones that have the same value
            as the default. This is different from `response_model_exclude_unset`
            in that if the fields are set but contain the same default values,
            they will be excluded from the response.

            When `True`, default values are omitted from the response.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#use-the-response_model_exclude_unset-parameter).
            """
        ),
    ] = False,
    response_model_exclude_none: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data should
            exclude fields set to `None`.

            This is much simpler (less smart) than `response_model_exclude_unset`
            and `response_model_exclude_defaults`. You probably want to use one of
            those two instead of this one, as those allow returning `None` values
            when it makes sense.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_exclude_none).
            """
        ),
    ] = False,
    include_in_schema: Annotated[
        bool,
        Doc(
            """
            Include this *path operation* in the generated OpenAPI schema.

            This affects the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Query Parameters and String Validations](https://fastapi.dev.org.tw/tutorial/query-params-str-validations/#exclude-from-openapi).
            """
        ),
    ] = True,
    response_class: Annotated[
        Type[Response],
        Doc(
            """
            Response class to be used for this *path operation*.

            This will not be used if you return a response directly.

            Read more about it in the
            [FastAPI docs for Custom Response - HTML, Stream, File, others](https://fastapi.dev.org.tw/advanced/custom-response/#redirectresponse).
            """
        ),
    ] = Default(JSONResponse),
    name: Annotated[
        Optional[str],
        Doc(
            """
            Name for this *path operation*. Only used internally.
            """
        ),
    ] = None,
    callbacks: Annotated[
        Optional[List[BaseRoute]],
        Doc(
            """
            List of *path operations* that will be used as OpenAPI callbacks.

            This is only for OpenAPI documentation, the callbacks won't be used
            directly.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for OpenAPI Callbacks](https://fastapi.dev.org.tw/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    openapi_extra: Annotated[
        Optional[Dict[str, Any]],
        Doc(
            """
            Extra metadata to be included in the OpenAPI schema for this *path
            operation*.

            Read more about it in the
            [FastAPI docs for Path Operation Advanced Configuration](https://fastapi.dev.org.tw/advanced/path-operation-advanced-configuration/#custom-openapi-path-operation-schema).
            """
        ),
    ] = None,
    generate_unique_id_function: Annotated[
        Callable[[routing.APIRoute], str],
        Doc(
            """
            Customize the function used to generate unique IDs for the *path
            operations* shown in the generated OpenAPI.

            This is particularly useful when automatically generating clients or
            SDKs for your API.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.dev.org.tw/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = Default(generate_unique_id),
) -> Callable[[DecoratedCallable], DecoratedCallable]:
    """
    Add a *path operation* using an HTTP POST operation.

    ## Example

    ```python
    from fastapi import FastAPI
    from pydantic import BaseModel

    class Item(BaseModel):
        name: str
        description: str | None = None

    app = FastAPI()

    @app.post("/items/")
    def create_item(item: Item):
        return {"message": "Item created"}
    ```
    """
    return self.router.post(
        path,
        response_model=response_model,
        status_code=status_code,
        tags=tags,
        dependencies=dependencies,
        summary=summary,
        description=description,
        response_description=response_description,
        responses=responses,
        deprecated=deprecated,
        operation_id=operation_id,
        response_model_include=response_model_include,
        response_model_exclude=response_model_exclude,
        response_model_by_alias=response_model_by_alias,
        response_model_exclude_unset=response_model_exclude_unset,
        response_model_exclude_defaults=response_model_exclude_defaults,
        response_model_exclude_none=response_model_exclude_none,
        include_in_schema=include_in_schema,
        response_class=response_class,
        name=name,
        callbacks=callbacks,
        openapi_extra=openapi_extra,
        generate_unique_id_function=generate_unique_id_function,
    )

delete

delete(
    path,
    *,
    response_model=Default(None),
    status_code=None,
    tags=None,
    dependencies=None,
    summary=None,
    description=None,
    response_description="Successful Response",
    responses=None,
    deprecated=None,
    operation_id=None,
    response_model_include=None,
    response_model_exclude=None,
    response_model_by_alias=True,
    response_model_exclude_unset=False,
    response_model_exclude_defaults=False,
    response_model_exclude_none=False,
    include_in_schema=True,
    response_class=Default(JSONResponse),
    name=None,
    callbacks=None,
    openapi_extra=None,
    generate_unique_id_function=Default(generate_unique_id)
)

使用 HTTP DELETE 操作新增一個 *路徑操作*。

範例

from fastapi import FastAPI

app = FastAPI()

@app.delete("/items/{item_id}")
def delete_item(item_id: str):
    return {"message": "Item deleted"}

參數	說明
路徑	此*路徑操作*要使用的 URL 路徑。 例如，在 http://example.com/items 中，路徑是 /items。 類型： str
response_model（回應模型）	用於回應的類型。 它可以是任何有效的 Pydantic *欄位*類型。因此，它不必是 Pydantic 模型，它可以是其他類型，例如 list、dict 等。 它將用於 文件：產生的 OpenAPI（以及 /docs 的使用者介面）將其顯示為回應（JSON Schema）。 序列化：您可以返回任意物件，`response_model` 將用於將該物件序列化為相應的 JSON。 過濾：傳送到用戶端的 JSON 將僅包含 `response_model` 中定義的資料（欄位）。如果您返回的物件包含屬性 `password`，但 `response_model` 不包含該欄位，則傳送到用戶端的 JSON 將不包含 `password`。 驗證：您返回的任何內容都將使用 `response_model` 進行序列化，並根據需要轉換任何資料以產生相應的 JSON。但是，如果返回的物件中的資料無效，則表示違反了與用戶端的合約，因此這是 API 開發人員的錯誤。因此，FastAPI 將引發錯誤並返回 500 錯誤碼（內部伺服器錯誤）。 在FastAPI 的回應模型文件中了解更多資訊。 類型： Any 預設值： Default(None)
status_code（狀態碼）	用於回應的預設狀態碼。 您可以透過直接返回回應來覆寫狀態碼。 在FastAPI 的回應狀態碼文件中了解更多資訊。 類型： Optional[int] 預設值： None
標籤	要套用至*路徑操作*的標籤清單。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 的路徑操作設定文件中了解更多資訊。 類型： Optional[List[Union[str, Enum]]] 預設值： None
dependencies	要套用至*路徑操作*的依存關係清單（使用 Depends()）。 在FastAPI 的路徑操作裝飾器中的依存關係文件中了解更多資訊。 類型： Optional[Sequence[Depends]] 預設值： None
summary	*路徑操作*的摘要。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 路徑操作設定文件中了解更多資訊。 類型： Optional[str] 預設值： None
description	*路徑操作*的描述。 如果未提供，將會從*路徑操作函式*的文件字串中自動擷取。 它可以包含 Markdown。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 路徑操作設定文件中了解更多資訊。 類型： Optional[str] 預設值： None
response_description（回應描述）	預設回應的描述。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： str 預設值： '成功回應'
responses	此*路徑操作*可以返回的其他回應。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： Optional[Dict[Union[int, str], Dict[str, Any]]] 預設值： None
已棄用	將此*路徑操作*標記為已棄用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： Optional[bool] 預設值： None
operation_id（操作 ID）	此 *路徑操作* 要使用的自訂操作 ID。 預設情況下，它會自動生成。 如果您提供自訂操作 ID，則需要確保它在整個 API 中是唯一的。 您可以使用 FastAPI 類別中的 generate_unique_id_function 參數來自訂操作 ID 的生成方式。 在FastAPI 如何產生客戶端的文件中了解更多資訊。 類型： Optional[str] 預設值： None
response_model_include	傳遞給 Pydantic 的設定，用於僅包含回應數據中的特定欄位。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： Optional[IncEx] 預設值： None
response_model_exclude	傳遞給 Pydantic 的設定，用於排除回應數據中的特定欄位。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： Optional[IncEx] 預設值： None
response_model_by_alias	傳遞給 Pydantic 的設定，用於定義當使用別名時，回應模型是否應透過別名進行序列化。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： True
response_model_exclude_unset	傳遞給 Pydantic 的設定，用於定義回應數據是否應包含所有欄位，包括那些未設定且具有預設值的欄位。這與 response_model_exclude_defaults 不同，如果設定了欄位，即使值與預設值相同，它們也會包含在回應中。 當設為 True 時，預設值會從回應中省略。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
response_model_exclude_defaults	傳遞給 Pydantic 的設定，用於定義回應數據是否應包含所有欄位，包括那些與預設值相同的欄位。這與 response_model_exclude_unset 不同，如果設定了欄位但包含相同的預設值，它們將從回應中排除。 當設為 True 時，預設值會從回應中省略。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
response_model_exclude_none	傳遞給 Pydantic 的設定，用於定義回應數據是否應排除設為 None 的欄位。 這比 response_model_exclude_unset 和 response_model_exclude_defaults 簡單得多（不那麼聰明）。您可能想要使用這兩個其中之一而不是這個，因為它們允許在合理的情況下返回 None 值。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
include_in_schema	將此 *路徑操作* 包含在生成的 OpenAPI 模式中。 這會影響產生的 OpenAPI（例如在 /docs 中可見）。 在FastAPI 查詢參數和字串驗證文件中了解更多資訊。 類型： bool 預設值： True
response_class	此 *路徑操作* 要使用的回應類別。 如果您直接返回回應，則不會使用此選項。 在 FastAPI 自訂回應 - HTML、串流、檔案等文件 中了解更多資訊。 類型： Type[Response] 預設值： Default(JSONResponse)
名稱	此 *路徑操作* 的名稱。僅供內部使用。 類型： Optional[str] 預設值： None
callbacks	將用作 OpenAPI 回呼的*路徑操作*清單。 這僅適用於 OpenAPI 文件，回呼不會直接使用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 更多資訊請參閱FastAPI OpenAPI 回呼文件。 類型： Optional[List[BaseRoute]] 預設值： None
openapi_extra	要包含在此 *路徑操作* 的 OpenAPI 模式中的額外中繼資料。 在 FastAPI 路徑操作進階設定文件 中了解更多資訊。 類型： Optional[Dict[str, Any]] 預設值： None
generate_unique_id_function	自訂用於產生 OpenAPI 中顯示的*路徑操作*之唯一 ID 的函式。 這在自動為您的 API 產生客戶端或 SDK 時特別有用。 在FastAPI 如何產生客戶端的文件中了解更多資訊。 類型： Callable[[APIRoute], str] 預設值： Default(generate_unique_id)

原始程式碼位於 fastapi/applications.py

def delete(
    self,
    path: Annotated[
        str,
        Doc(
            """
            The URL path to be used for this *path operation*.

            For example, in `http://example.com/items`, the path is `/items`.
            """
        ),
    ],
    *,
    response_model: Annotated[
        Any,
        Doc(
            """
            The type to use for the response.

            It could be any valid Pydantic *field* type. So, it doesn't have to
            be a Pydantic model, it could be other things, like a `list`, `dict`,
            etc.

            It will be used for:

            * Documentation: the generated OpenAPI (and the UI at `/docs`) will
                show it as the response (JSON Schema).
            * Serialization: you could return an arbitrary object and the
                `response_model` would be used to serialize that object into the
                corresponding JSON.
            * Filtering: the JSON sent to the client will only contain the data
                (fields) defined in the `response_model`. If you returned an object
                that contains an attribute `password` but the `response_model` does
                not include that field, the JSON sent to the client would not have
                that `password`.
            * Validation: whatever you return will be serialized with the
                `response_model`, converting any data as necessary to generate the
                corresponding JSON. But if the data in the object returned is not
                valid, that would mean a violation of the contract with the client,
                so it's an error from the API developer. So, FastAPI will raise an
                error and return a 500 error code (Internal Server Error).

            Read more about it in the
            [FastAPI docs for Response Model](https://fastapi.dev.org.tw/tutorial/response-model/).
            """
        ),
    ] = Default(None),
    status_code: Annotated[
        Optional[int],
        Doc(
            """
            The default status code to be used for the response.

            You could override the status code by returning a response directly.

            Read more about it in the
            [FastAPI docs for Response Status Code](https://fastapi.dev.org.tw/tutorial/response-status-code/).
            """
        ),
    ] = None,
    tags: Annotated[
        Optional[List[Union[str, Enum]]],
        Doc(
            """
            A list of tags to be applied to the *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/#tags).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Optional[Sequence[Depends]],
        Doc(
            """
            A list of dependencies (using `Depends()`) to be applied to the
            *path operation*.

            Read more about it in the
            [FastAPI docs for Dependencies in path operation decorators](https://fastapi.dev.org.tw/tutorial/dependencies/dependencies-in-path-operation-decorators/).
            """
        ),
    ] = None,
    summary: Annotated[
        Optional[str],
        Doc(
            """
            A summary for the *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    description: Annotated[
        Optional[str],
        Doc(
            """
            A description for the *path operation*.

            If not provided, it will be extracted automatically from the docstring
            of the *path operation function*.

            It can contain Markdown.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    response_description: Annotated[
        str,
        Doc(
            """
            The description for the default response.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = "Successful Response",
    responses: Annotated[
        Optional[Dict[Union[int, str], Dict[str, Any]]],
        Doc(
            """
            Additional responses that could be returned by this *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    deprecated: Annotated[
        Optional[bool],
        Doc(
            """
            Mark this *path operation* as deprecated.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    operation_id: Annotated[
        Optional[str],
        Doc(
            """
            Custom operation ID to be used by this *path operation*.

            By default, it is generated automatically.

            If you provide a custom operation ID, you need to make sure it is
            unique for the whole API.

            You can customize the
            operation ID generation with the parameter
            `generate_unique_id_function` in the `FastAPI` class.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.dev.org.tw/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = None,
    response_model_include: Annotated[
        Optional[IncEx],
        Doc(
            """
            Configuration passed to Pydantic to include only certain fields in the
            response data.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_exclude: Annotated[
        Optional[IncEx],
        Doc(
            """
            Configuration passed to Pydantic to exclude certain fields in the
            response data.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_by_alias: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response model
            should be serialized by alias when an alias is used.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = True,
    response_model_exclude_unset: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data
            should have all the fields, including the ones that were not set and
            have their default values. This is different from
            `response_model_exclude_defaults` in that if the fields are set,
            they will be included in the response, even if the value is the same
            as the default.

            When `True`, default values are omitted from the response.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#use-the-response_model_exclude_unset-parameter).
            """
        ),
    ] = False,
    response_model_exclude_defaults: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data
            should have all the fields, including the ones that have the same value
            as the default. This is different from `response_model_exclude_unset`
            in that if the fields are set but contain the same default values,
            they will be excluded from the response.

            When `True`, default values are omitted from the response.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#use-the-response_model_exclude_unset-parameter).
            """
        ),
    ] = False,
    response_model_exclude_none: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data should
            exclude fields set to `None`.

            This is much simpler (less smart) than `response_model_exclude_unset`
            and `response_model_exclude_defaults`. You probably want to use one of
            those two instead of this one, as those allow returning `None` values
            when it makes sense.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_exclude_none).
            """
        ),
    ] = False,
    include_in_schema: Annotated[
        bool,
        Doc(
            """
            Include this *path operation* in the generated OpenAPI schema.

            This affects the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Query Parameters and String Validations](https://fastapi.dev.org.tw/tutorial/query-params-str-validations/#exclude-from-openapi).
            """
        ),
    ] = True,
    response_class: Annotated[
        Type[Response],
        Doc(
            """
            Response class to be used for this *path operation*.

            This will not be used if you return a response directly.

            Read more about it in the
            [FastAPI docs for Custom Response - HTML, Stream, File, others](https://fastapi.dev.org.tw/advanced/custom-response/#redirectresponse).
            """
        ),
    ] = Default(JSONResponse),
    name: Annotated[
        Optional[str],
        Doc(
            """
            Name for this *path operation*. Only used internally.
            """
        ),
    ] = None,
    callbacks: Annotated[
        Optional[List[BaseRoute]],
        Doc(
            """
            List of *path operations* that will be used as OpenAPI callbacks.

            This is only for OpenAPI documentation, the callbacks won't be used
            directly.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for OpenAPI Callbacks](https://fastapi.dev.org.tw/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    openapi_extra: Annotated[
        Optional[Dict[str, Any]],
        Doc(
            """
            Extra metadata to be included in the OpenAPI schema for this *path
            operation*.

            Read more about it in the
            [FastAPI docs for Path Operation Advanced Configuration](https://fastapi.dev.org.tw/advanced/path-operation-advanced-configuration/#custom-openapi-path-operation-schema).
            """
        ),
    ] = None,
    generate_unique_id_function: Annotated[
        Callable[[routing.APIRoute], str],
        Doc(
            """
            Customize the function used to generate unique IDs for the *path
            operations* shown in the generated OpenAPI.

            This is particularly useful when automatically generating clients or
            SDKs for your API.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.dev.org.tw/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = Default(generate_unique_id),
) -> Callable[[DecoratedCallable], DecoratedCallable]:
    """
    Add a *path operation* using an HTTP DELETE operation.

    ## Example

    ```python
    from fastapi import FastAPI

    app = FastAPI()

    @app.delete("/items/{item_id}")
    def delete_item(item_id: str):
        return {"message": "Item deleted"}
    ```
    """
    return self.router.delete(
        path,
        response_model=response_model,
        status_code=status_code,
        tags=tags,
        dependencies=dependencies,
        summary=summary,
        description=description,
        response_description=response_description,
        responses=responses,
        deprecated=deprecated,
        operation_id=operation_id,
        response_model_include=response_model_include,
        response_model_exclude=response_model_exclude,
        response_model_by_alias=response_model_by_alias,
        response_model_exclude_unset=response_model_exclude_unset,
        response_model_exclude_defaults=response_model_exclude_defaults,
        response_model_exclude_none=response_model_exclude_none,
        include_in_schema=include_in_schema,
        response_class=response_class,
        name=name,
        callbacks=callbacks,
        openapi_extra=openapi_extra,
        generate_unique_id_function=generate_unique_id_function,
    )

options

options(
    path,
    *,
    response_model=Default(None),
    status_code=None,
    tags=None,
    dependencies=None,
    summary=None,
    description=None,
    response_description="Successful Response",
    responses=None,
    deprecated=None,
    operation_id=None,
    response_model_include=None,
    response_model_exclude=None,
    response_model_by_alias=True,
    response_model_exclude_unset=False,
    response_model_exclude_defaults=False,
    response_model_exclude_none=False,
    include_in_schema=True,
    response_class=Default(JSONResponse),
    name=None,
    callbacks=None,
    openapi_extra=None,
    generate_unique_id_function=Default(generate_unique_id)
)

使用 HTTP OPTIONS 操作新增一個 *路徑操作*。

範例

from fastapi import FastAPI

app = FastAPI()

@app.options("/items/")
def get_item_options():
    return {"additions": ["Aji", "Guacamole"]}

參數	說明
路徑	此*路徑操作*要使用的 URL 路徑。 例如，在 http://example.com/items 中，路徑是 /items。 類型： str
response_model（回應模型）	用於回應的類型。 它可以是任何有效的 Pydantic *欄位*類型。因此，它不必是 Pydantic 模型，它可以是其他類型，例如 list、dict 等。 它將用於 文件：產生的 OpenAPI（以及 /docs 的使用者介面）將其顯示為回應（JSON Schema）。 序列化：您可以返回任意物件，`response_model` 將用於將該物件序列化為相應的 JSON。 過濾：傳送到用戶端的 JSON 將僅包含 `response_model` 中定義的資料（欄位）。如果您返回的物件包含屬性 `password`，但 `response_model` 不包含該欄位，則傳送到用戶端的 JSON 將不包含 `password`。 驗證：您返回的任何內容都將使用 `response_model` 進行序列化，並根據需要轉換任何資料以產生相應的 JSON。但是，如果返回的物件中的資料無效，則表示違反了與用戶端的合約，因此這是 API 開發人員的錯誤。因此，FastAPI 將引發錯誤並返回 500 錯誤碼（內部伺服器錯誤）。 在FastAPI 的回應模型文件中了解更多資訊。 類型： Any 預設值： Default(None)
status_code（狀態碼）	用於回應的預設狀態碼。 您可以透過直接返回回應來覆寫狀態碼。 在FastAPI 的回應狀態碼文件中了解更多資訊。 類型： Optional[int] 預設值： None
標籤	要套用至*路徑操作*的標籤清單。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 的路徑操作設定文件中了解更多資訊。 類型： Optional[List[Union[str, Enum]]] 預設值： None
dependencies	要套用至*路徑操作*的依存關係清單（使用 Depends()）。 在FastAPI 的路徑操作裝飾器中的依存關係文件中了解更多資訊。 類型： Optional[Sequence[Depends]] 預設值： None
summary	*路徑操作*的摘要。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 路徑操作設定文件中了解更多資訊。 類型： Optional[str] 預設值： None
description	*路徑操作*的描述。 如果未提供，將會從*路徑操作函式*的文件字串中自動擷取。 它可以包含 Markdown。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 路徑操作設定文件中了解更多資訊。 類型： Optional[str] 預設值： None
response_description（回應描述）	預設回應的描述。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： str 預設值： '成功回應'
responses	此*路徑操作*可以返回的其他回應。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： Optional[Dict[Union[int, str], Dict[str, Any]]] 預設值： None
已棄用	將此*路徑操作*標記為已棄用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： Optional[bool] 預設值： None
operation_id（操作 ID）	此 *路徑操作* 要使用的自訂操作 ID。 預設情況下，它會自動生成。 如果您提供自訂操作 ID，則需要確保它在整個 API 中是唯一的。 您可以使用 FastAPI 類別中的 generate_unique_id_function 參數來自訂操作 ID 的生成方式。 在FastAPI 如何產生客戶端的文件中了解更多資訊。 類型： Optional[str] 預設值： None
response_model_include	傳遞給 Pydantic 的設定，用於僅包含回應數據中的特定欄位。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： Optional[IncEx] 預設值： None
response_model_exclude	傳遞給 Pydantic 的設定，用於排除回應數據中的特定欄位。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： Optional[IncEx] 預設值： None
response_model_by_alias	傳遞給 Pydantic 的設定，用於定義當使用別名時，回應模型是否應透過別名進行序列化。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： True
response_model_exclude_unset	傳遞給 Pydantic 的設定，用於定義回應數據是否應包含所有欄位，包括那些未設定且具有預設值的欄位。這與 response_model_exclude_defaults 不同，如果設定了欄位，即使值與預設值相同，它們也會包含在回應中。 當設為 True 時，預設值會從回應中省略。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
response_model_exclude_defaults	傳遞給 Pydantic 的設定，用於定義回應數據是否應包含所有欄位，包括那些與預設值相同的欄位。這與 response_model_exclude_unset 不同，如果設定了欄位但包含相同的預設值，它們將從回應中排除。 當設為 True 時，預設值會從回應中省略。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
response_model_exclude_none	傳遞給 Pydantic 的設定，用於定義回應數據是否應排除設為 None 的欄位。 這比 response_model_exclude_unset 和 response_model_exclude_defaults 簡單得多（不那麼聰明）。您可能想要使用這兩個其中之一而不是這個，因為它們允許在合理的情況下返回 None 值。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
include_in_schema	將此 *路徑操作* 包含在生成的 OpenAPI 模式中。 這會影響產生的 OpenAPI（例如在 /docs 中可見）。 在FastAPI 查詢參數和字串驗證文件中了解更多資訊。 類型： bool 預設值： True
response_class	此 *路徑操作* 要使用的回應類別。 如果您直接返回回應，則不會使用此選項。 在 FastAPI 自訂回應 - HTML、串流、檔案等文件 中了解更多資訊。 類型： Type[Response] 預設值： Default(JSONResponse)
名稱	此 *路徑操作* 的名稱。僅供內部使用。 類型： Optional[str] 預設值： None
callbacks	將用作 OpenAPI 回呼的*路徑操作*清單。 這僅適用於 OpenAPI 文件，回呼不會直接使用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 更多資訊請參閱FastAPI OpenAPI 回呼文件。 類型： Optional[List[BaseRoute]] 預設值： None
openapi_extra	要包含在此 *路徑操作* 的 OpenAPI 模式中的額外中繼資料。 在 FastAPI 路徑操作進階設定文件 中了解更多資訊。 類型： Optional[Dict[str, Any]] 預設值： None
generate_unique_id_function	自訂用於產生 OpenAPI 中顯示的*路徑操作*之唯一 ID 的函式。 這在自動為您的 API 產生客戶端或 SDK 時特別有用。 在FastAPI 如何產生客戶端的文件中了解更多資訊。 類型： Callable[[APIRoute], str] 預設值： Default(generate_unique_id)

原始程式碼位於 fastapi/applications.py

def options(
    self,
    path: Annotated[
        str,
        Doc(
            """
            The URL path to be used for this *path operation*.

            For example, in `http://example.com/items`, the path is `/items`.
            """
        ),
    ],
    *,
    response_model: Annotated[
        Any,
        Doc(
            """
            The type to use for the response.

            It could be any valid Pydantic *field* type. So, it doesn't have to
            be a Pydantic model, it could be other things, like a `list`, `dict`,
            etc.

            It will be used for:

            * Documentation: the generated OpenAPI (and the UI at `/docs`) will
                show it as the response (JSON Schema).
            * Serialization: you could return an arbitrary object and the
                `response_model` would be used to serialize that object into the
                corresponding JSON.
            * Filtering: the JSON sent to the client will only contain the data
                (fields) defined in the `response_model`. If you returned an object
                that contains an attribute `password` but the `response_model` does
                not include that field, the JSON sent to the client would not have
                that `password`.
            * Validation: whatever you return will be serialized with the
                `response_model`, converting any data as necessary to generate the
                corresponding JSON. But if the data in the object returned is not
                valid, that would mean a violation of the contract with the client,
                so it's an error from the API developer. So, FastAPI will raise an
                error and return a 500 error code (Internal Server Error).

            Read more about it in the
            [FastAPI docs for Response Model](https://fastapi.dev.org.tw/tutorial/response-model/).
            """
        ),
    ] = Default(None),
    status_code: Annotated[
        Optional[int],
        Doc(
            """
            The default status code to be used for the response.

            You could override the status code by returning a response directly.

            Read more about it in the
            [FastAPI docs for Response Status Code](https://fastapi.dev.org.tw/tutorial/response-status-code/).
            """
        ),
    ] = None,
    tags: Annotated[
        Optional[List[Union[str, Enum]]],
        Doc(
            """
            A list of tags to be applied to the *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/#tags).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Optional[Sequence[Depends]],
        Doc(
            """
            A list of dependencies (using `Depends()`) to be applied to the
            *path operation*.

            Read more about it in the
            [FastAPI docs for Dependencies in path operation decorators](https://fastapi.dev.org.tw/tutorial/dependencies/dependencies-in-path-operation-decorators/).
            """
        ),
    ] = None,
    summary: Annotated[
        Optional[str],
        Doc(
            """
            A summary for the *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    description: Annotated[
        Optional[str],
        Doc(
            """
            A description for the *path operation*.

            If not provided, it will be extracted automatically from the docstring
            of the *path operation function*.

            It can contain Markdown.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    response_description: Annotated[
        str,
        Doc(
            """
            The description for the default response.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = "Successful Response",
    responses: Annotated[
        Optional[Dict[Union[int, str], Dict[str, Any]]],
        Doc(
            """
            Additional responses that could be returned by this *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    deprecated: Annotated[
        Optional[bool],
        Doc(
            """
            Mark this *path operation* as deprecated.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    operation_id: Annotated[
        Optional[str],
        Doc(
            """
            Custom operation ID to be used by this *path operation*.

            By default, it is generated automatically.

            If you provide a custom operation ID, you need to make sure it is
            unique for the whole API.

            You can customize the
            operation ID generation with the parameter
            `generate_unique_id_function` in the `FastAPI` class.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.dev.org.tw/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = None,
    response_model_include: Annotated[
        Optional[IncEx],
        Doc(
            """
            Configuration passed to Pydantic to include only certain fields in the
            response data.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_exclude: Annotated[
        Optional[IncEx],
        Doc(
            """
            Configuration passed to Pydantic to exclude certain fields in the
            response data.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_by_alias: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response model
            should be serialized by alias when an alias is used.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = True,
    response_model_exclude_unset: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data
            should have all the fields, including the ones that were not set and
            have their default values. This is different from
            `response_model_exclude_defaults` in that if the fields are set,
            they will be included in the response, even if the value is the same
            as the default.

            When `True`, default values are omitted from the response.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#use-the-response_model_exclude_unset-parameter).
            """
        ),
    ] = False,
    response_model_exclude_defaults: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data
            should have all the fields, including the ones that have the same value
            as the default. This is different from `response_model_exclude_unset`
            in that if the fields are set but contain the same default values,
            they will be excluded from the response.

            When `True`, default values are omitted from the response.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#use-the-response_model_exclude_unset-parameter).
            """
        ),
    ] = False,
    response_model_exclude_none: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data should
            exclude fields set to `None`.

            This is much simpler (less smart) than `response_model_exclude_unset`
            and `response_model_exclude_defaults`. You probably want to use one of
            those two instead of this one, as those allow returning `None` values
            when it makes sense.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_exclude_none).
            """
        ),
    ] = False,
    include_in_schema: Annotated[
        bool,
        Doc(
            """
            Include this *path operation* in the generated OpenAPI schema.

            This affects the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Query Parameters and String Validations](https://fastapi.dev.org.tw/tutorial/query-params-str-validations/#exclude-from-openapi).
            """
        ),
    ] = True,
    response_class: Annotated[
        Type[Response],
        Doc(
            """
            Response class to be used for this *path operation*.

            This will not be used if you return a response directly.

            Read more about it in the
            [FastAPI docs for Custom Response - HTML, Stream, File, others](https://fastapi.dev.org.tw/advanced/custom-response/#redirectresponse).
            """
        ),
    ] = Default(JSONResponse),
    name: Annotated[
        Optional[str],
        Doc(
            """
            Name for this *path operation*. Only used internally.
            """
        ),
    ] = None,
    callbacks: Annotated[
        Optional[List[BaseRoute]],
        Doc(
            """
            List of *path operations* that will be used as OpenAPI callbacks.

            This is only for OpenAPI documentation, the callbacks won't be used
            directly.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for OpenAPI Callbacks](https://fastapi.dev.org.tw/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    openapi_extra: Annotated[
        Optional[Dict[str, Any]],
        Doc(
            """
            Extra metadata to be included in the OpenAPI schema for this *path
            operation*.

            Read more about it in the
            [FastAPI docs for Path Operation Advanced Configuration](https://fastapi.dev.org.tw/advanced/path-operation-advanced-configuration/#custom-openapi-path-operation-schema).
            """
        ),
    ] = None,
    generate_unique_id_function: Annotated[
        Callable[[routing.APIRoute], str],
        Doc(
            """
            Customize the function used to generate unique IDs for the *path
            operations* shown in the generated OpenAPI.

            This is particularly useful when automatically generating clients or
            SDKs for your API.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.dev.org.tw/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = Default(generate_unique_id),
) -> Callable[[DecoratedCallable], DecoratedCallable]:
    """
    Add a *path operation* using an HTTP OPTIONS operation.

    ## Example

    ```python
    from fastapi import FastAPI

    app = FastAPI()

    @app.options("/items/")
    def get_item_options():
        return {"additions": ["Aji", "Guacamole"]}
    ```
    """
    return self.router.options(
        path,
        response_model=response_model,
        status_code=status_code,
        tags=tags,
        dependencies=dependencies,
        summary=summary,
        description=description,
        response_description=response_description,
        responses=responses,
        deprecated=deprecated,
        operation_id=operation_id,
        response_model_include=response_model_include,
        response_model_exclude=response_model_exclude,
        response_model_by_alias=response_model_by_alias,
        response_model_exclude_unset=response_model_exclude_unset,
        response_model_exclude_defaults=response_model_exclude_defaults,
        response_model_exclude_none=response_model_exclude_none,
        include_in_schema=include_in_schema,
        response_class=response_class,
        name=name,
        callbacks=callbacks,
        openapi_extra=openapi_extra,
        generate_unique_id_function=generate_unique_id_function,
    )

head

head(
    path,
    *,
    response_model=Default(None),
    status_code=None,
    tags=None,
    dependencies=None,
    summary=None,
    description=None,
    response_description="Successful Response",
    responses=None,
    deprecated=None,
    operation_id=None,
    response_model_include=None,
    response_model_exclude=None,
    response_model_by_alias=True,
    response_model_exclude_unset=False,
    response_model_exclude_defaults=False,
    response_model_exclude_none=False,
    include_in_schema=True,
    response_class=Default(JSONResponse),
    name=None,
    callbacks=None,
    openapi_extra=None,
    generate_unique_id_function=Default(generate_unique_id)
)

使用 HTTP HEAD 操作新增一個 *路徑操作*。

範例

from fastapi import FastAPI, Response

app = FastAPI()

@app.head("/items/", status_code=204)
def get_items_headers(response: Response):
    response.headers["X-Cat-Dog"] = "Alone in the world"

參數	說明
路徑	此*路徑操作*要使用的 URL 路徑。 例如，在 http://example.com/items 中，路徑是 /items。 類型： str
response_model（回應模型）	用於回應的類型。 它可以是任何有效的 Pydantic *欄位*類型。因此，它不必是 Pydantic 模型，它可以是其他類型，例如 list、dict 等。 它將用於 文件：產生的 OpenAPI（以及 /docs 的使用者介面）將其顯示為回應（JSON Schema）。 序列化：您可以返回任意物件，`response_model` 將用於將該物件序列化為相應的 JSON。 過濾：傳送到用戶端的 JSON 將僅包含 `response_model` 中定義的資料（欄位）。如果您返回的物件包含屬性 `password`，但 `response_model` 不包含該欄位，則傳送到用戶端的 JSON 將不包含 `password`。 驗證：您返回的任何內容都將使用 `response_model` 進行序列化，並根據需要轉換任何資料以產生相應的 JSON。但是，如果返回的物件中的資料無效，則表示違反了與用戶端的合約，因此這是 API 開發人員的錯誤。因此，FastAPI 將引發錯誤並返回 500 錯誤碼（內部伺服器錯誤）。 在FastAPI 的回應模型文件中了解更多資訊。 類型： Any 預設值： Default(None)
status_code（狀態碼）	用於回應的預設狀態碼。 您可以透過直接返回回應來覆寫狀態碼。 在FastAPI 的回應狀態碼文件中了解更多資訊。 類型： Optional[int] 預設值： None
標籤	要套用至*路徑操作*的標籤清單。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 的路徑操作設定文件中了解更多資訊。 類型： Optional[List[Union[str, Enum]]] 預設值： None
dependencies	要套用至*路徑操作*的依存關係清單（使用 Depends()）。 在FastAPI 的路徑操作裝飾器中的依存關係文件中了解更多資訊。 類型： Optional[Sequence[Depends]] 預設值： None
summary	*路徑操作*的摘要。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 路徑操作設定文件中了解更多資訊。 類型： Optional[str] 預設值： None
description	*路徑操作*的描述。 如果未提供，將會從*路徑操作函式*的文件字串中自動擷取。 它可以包含 Markdown。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 路徑操作設定文件中了解更多資訊。 類型： Optional[str] 預設值： None
response_description（回應描述）	預設回應的描述。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： str 預設值： '成功回應'
responses	此*路徑操作*可以返回的其他回應。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： Optional[Dict[Union[int, str], Dict[str, Any]]] 預設值： None
已棄用	將此*路徑操作*標記為已棄用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： Optional[bool] 預設值： None
operation_id（操作 ID）	此 *路徑操作* 要使用的自訂操作 ID。 預設情況下，它會自動生成。 如果您提供自訂操作 ID，則需要確保它在整個 API 中是唯一的。 您可以使用 FastAPI 類別中的 generate_unique_id_function 參數來自訂操作 ID 的生成方式。 在FastAPI 如何產生客戶端的文件中了解更多資訊。 類型： Optional[str] 預設值： None
response_model_include	傳遞給 Pydantic 的設定，用於僅包含回應數據中的特定欄位。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： Optional[IncEx] 預設值： None
response_model_exclude	傳遞給 Pydantic 的設定，用於排除回應數據中的特定欄位。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： Optional[IncEx] 預設值： None
response_model_by_alias	傳遞給 Pydantic 的設定，用於定義當使用別名時，回應模型是否應透過別名進行序列化。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： True
response_model_exclude_unset	傳遞給 Pydantic 的設定，用於定義回應數據是否應包含所有欄位，包括那些未設定且具有預設值的欄位。這與 response_model_exclude_defaults 不同，如果設定了欄位，即使值與預設值相同，它們也會包含在回應中。 當設為 True 時，預設值會從回應中省略。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
response_model_exclude_defaults	傳遞給 Pydantic 的設定，用於定義回應數據是否應包含所有欄位，包括那些與預設值相同的欄位。這與 response_model_exclude_unset 不同，如果設定了欄位但包含相同的預設值，它們將從回應中排除。 當設為 True 時，預設值會從回應中省略。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
response_model_exclude_none	傳遞給 Pydantic 的設定，用於定義回應數據是否應排除設為 None 的欄位。 這比 response_model_exclude_unset 和 response_model_exclude_defaults 簡單得多（不那麼聰明）。您可能想要使用這兩個其中之一而不是這個，因為它們允許在合理的情況下返回 None 值。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
include_in_schema	將此 *路徑操作* 包含在生成的 OpenAPI 模式中。 這會影響產生的 OpenAPI（例如在 /docs 中可見）。 在FastAPI 查詢參數和字串驗證文件中了解更多資訊。 類型： bool 預設值： True
response_class	此 *路徑操作* 要使用的回應類別。 如果您直接返回回應，則不會使用此選項。 在 FastAPI 自訂回應 - HTML、串流、檔案等文件 中了解更多資訊。 類型： Type[Response] 預設值： Default(JSONResponse)
名稱	此 *路徑操作* 的名稱。僅供內部使用。 類型： Optional[str] 預設值： None
callbacks	將用作 OpenAPI 回呼的*路徑操作*清單。 這僅適用於 OpenAPI 文件，回呼不會直接使用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 更多資訊請參閱FastAPI OpenAPI 回呼文件。 類型： Optional[List[BaseRoute]] 預設值： None
openapi_extra	要包含在此 *路徑操作* 的 OpenAPI 模式中的額外中繼資料。 在 FastAPI 路徑操作進階設定文件 中了解更多資訊。 類型： Optional[Dict[str, Any]] 預設值： None
generate_unique_id_function	自訂用於產生 OpenAPI 中顯示的*路徑操作*之唯一 ID 的函式。 這在自動為您的 API 產生客戶端或 SDK 時特別有用。 在FastAPI 如何產生客戶端的文件中了解更多資訊。 類型： Callable[[APIRoute], str] 預設值： Default(generate_unique_id)

原始程式碼位於 fastapi/applications.py

def head(
    self,
    path: Annotated[
        str,
        Doc(
            """
            The URL path to be used for this *path operation*.

            For example, in `http://example.com/items`, the path is `/items`.
            """
        ),
    ],
    *,
    response_model: Annotated[
        Any,
        Doc(
            """
            The type to use for the response.

            It could be any valid Pydantic *field* type. So, it doesn't have to
            be a Pydantic model, it could be other things, like a `list`, `dict`,
            etc.

            It will be used for:

            * Documentation: the generated OpenAPI (and the UI at `/docs`) will
                show it as the response (JSON Schema).
            * Serialization: you could return an arbitrary object and the
                `response_model` would be used to serialize that object into the
                corresponding JSON.
            * Filtering: the JSON sent to the client will only contain the data
                (fields) defined in the `response_model`. If you returned an object
                that contains an attribute `password` but the `response_model` does
                not include that field, the JSON sent to the client would not have
                that `password`.
            * Validation: whatever you return will be serialized with the
                `response_model`, converting any data as necessary to generate the
                corresponding JSON. But if the data in the object returned is not
                valid, that would mean a violation of the contract with the client,
                so it's an error from the API developer. So, FastAPI will raise an
                error and return a 500 error code (Internal Server Error).

            Read more about it in the
            [FastAPI docs for Response Model](https://fastapi.dev.org.tw/tutorial/response-model/).
            """
        ),
    ] = Default(None),
    status_code: Annotated[
        Optional[int],
        Doc(
            """
            The default status code to be used for the response.

            You could override the status code by returning a response directly.

            Read more about it in the
            [FastAPI docs for Response Status Code](https://fastapi.dev.org.tw/tutorial/response-status-code/).
            """
        ),
    ] = None,
    tags: Annotated[
        Optional[List[Union[str, Enum]]],
        Doc(
            """
            A list of tags to be applied to the *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/#tags).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Optional[Sequence[Depends]],
        Doc(
            """
            A list of dependencies (using `Depends()`) to be applied to the
            *path operation*.

            Read more about it in the
            [FastAPI docs for Dependencies in path operation decorators](https://fastapi.dev.org.tw/tutorial/dependencies/dependencies-in-path-operation-decorators/).
            """
        ),
    ] = None,
    summary: Annotated[
        Optional[str],
        Doc(
            """
            A summary for the *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    description: Annotated[
        Optional[str],
        Doc(
            """
            A description for the *path operation*.

            If not provided, it will be extracted automatically from the docstring
            of the *path operation function*.

            It can contain Markdown.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    response_description: Annotated[
        str,
        Doc(
            """
            The description for the default response.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = "Successful Response",
    responses: Annotated[
        Optional[Dict[Union[int, str], Dict[str, Any]]],
        Doc(
            """
            Additional responses that could be returned by this *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    deprecated: Annotated[
        Optional[bool],
        Doc(
            """
            Mark this *path operation* as deprecated.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    operation_id: Annotated[
        Optional[str],
        Doc(
            """
            Custom operation ID to be used by this *path operation*.

            By default, it is generated automatically.

            If you provide a custom operation ID, you need to make sure it is
            unique for the whole API.

            You can customize the
            operation ID generation with the parameter
            `generate_unique_id_function` in the `FastAPI` class.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.dev.org.tw/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = None,
    response_model_include: Annotated[
        Optional[IncEx],
        Doc(
            """
            Configuration passed to Pydantic to include only certain fields in the
            response data.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_exclude: Annotated[
        Optional[IncEx],
        Doc(
            """
            Configuration passed to Pydantic to exclude certain fields in the
            response data.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_by_alias: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response model
            should be serialized by alias when an alias is used.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = True,
    response_model_exclude_unset: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data
            should have all the fields, including the ones that were not set and
            have their default values. This is different from
            `response_model_exclude_defaults` in that if the fields are set,
            they will be included in the response, even if the value is the same
            as the default.

            When `True`, default values are omitted from the response.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#use-the-response_model_exclude_unset-parameter).
            """
        ),
    ] = False,
    response_model_exclude_defaults: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data
            should have all the fields, including the ones that have the same value
            as the default. This is different from `response_model_exclude_unset`
            in that if the fields are set but contain the same default values,
            they will be excluded from the response.

            When `True`, default values are omitted from the response.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#use-the-response_model_exclude_unset-parameter).
            """
        ),
    ] = False,
    response_model_exclude_none: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data should
            exclude fields set to `None`.

            This is much simpler (less smart) than `response_model_exclude_unset`
            and `response_model_exclude_defaults`. You probably want to use one of
            those two instead of this one, as those allow returning `None` values
            when it makes sense.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_exclude_none).
            """
        ),
    ] = False,
    include_in_schema: Annotated[
        bool,
        Doc(
            """
            Include this *path operation* in the generated OpenAPI schema.

            This affects the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Query Parameters and String Validations](https://fastapi.dev.org.tw/tutorial/query-params-str-validations/#exclude-from-openapi).
            """
        ),
    ] = True,
    response_class: Annotated[
        Type[Response],
        Doc(
            """
            Response class to be used for this *path operation*.

            This will not be used if you return a response directly.

            Read more about it in the
            [FastAPI docs for Custom Response - HTML, Stream, File, others](https://fastapi.dev.org.tw/advanced/custom-response/#redirectresponse).
            """
        ),
    ] = Default(JSONResponse),
    name: Annotated[
        Optional[str],
        Doc(
            """
            Name for this *path operation*. Only used internally.
            """
        ),
    ] = None,
    callbacks: Annotated[
        Optional[List[BaseRoute]],
        Doc(
            """
            List of *path operations* that will be used as OpenAPI callbacks.

            This is only for OpenAPI documentation, the callbacks won't be used
            directly.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for OpenAPI Callbacks](https://fastapi.dev.org.tw/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    openapi_extra: Annotated[
        Optional[Dict[str, Any]],
        Doc(
            """
            Extra metadata to be included in the OpenAPI schema for this *path
            operation*.

            Read more about it in the
            [FastAPI docs for Path Operation Advanced Configuration](https://fastapi.dev.org.tw/advanced/path-operation-advanced-configuration/#custom-openapi-path-operation-schema).
            """
        ),
    ] = None,
    generate_unique_id_function: Annotated[
        Callable[[routing.APIRoute], str],
        Doc(
            """
            Customize the function used to generate unique IDs for the *path
            operations* shown in the generated OpenAPI.

            This is particularly useful when automatically generating clients or
            SDKs for your API.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.dev.org.tw/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = Default(generate_unique_id),
) -> Callable[[DecoratedCallable], DecoratedCallable]:
    """
    Add a *path operation* using an HTTP HEAD operation.

    ## Example

    ```python
    from fastapi import FastAPI, Response

    app = FastAPI()

    @app.head("/items/", status_code=204)
    def get_items_headers(response: Response):
        response.headers["X-Cat-Dog"] = "Alone in the world"
    ```
    """
    return self.router.head(
        path,
        response_model=response_model,
        status_code=status_code,
        tags=tags,
        dependencies=dependencies,
        summary=summary,
        description=description,
        response_description=response_description,
        responses=responses,
        deprecated=deprecated,
        operation_id=operation_id,
        response_model_include=response_model_include,
        response_model_exclude=response_model_exclude,
        response_model_by_alias=response_model_by_alias,
        response_model_exclude_unset=response_model_exclude_unset,
        response_model_exclude_defaults=response_model_exclude_defaults,
        response_model_exclude_none=response_model_exclude_none,
        include_in_schema=include_in_schema,
        response_class=response_class,
        name=name,
        callbacks=callbacks,
        openapi_extra=openapi_extra,
        generate_unique_id_function=generate_unique_id_function,
    )

patch

patch(
    path,
    *,
    response_model=Default(None),
    status_code=None,
    tags=None,
    dependencies=None,
    summary=None,
    description=None,
    response_description="Successful Response",
    responses=None,
    deprecated=None,
    operation_id=None,
    response_model_include=None,
    response_model_exclude=None,
    response_model_by_alias=True,
    response_model_exclude_unset=False,
    response_model_exclude_defaults=False,
    response_model_exclude_none=False,
    include_in_schema=True,
    response_class=Default(JSONResponse),
    name=None,
    callbacks=None,
    openapi_extra=None,
    generate_unique_id_function=Default(generate_unique_id)
)

使用 HTTP PATCH 操作新增一個 *路徑操作*。

範例

from fastapi import FastAPI
from pydantic import BaseModel

class Item(BaseModel):
    name: str
    description: str | None = None

app = FastAPI()

@app.patch("/items/")
def update_item(item: Item):
    return {"message": "Item updated in place"}

參數	說明
路徑	此*路徑操作*要使用的 URL 路徑。 例如，在 http://example.com/items 中，路徑是 /items。 類型： str
response_model（回應模型）	用於回應的類型。 它可以是任何有效的 Pydantic *欄位*類型。因此，它不必是 Pydantic 模型，它可以是其他類型，例如 list、dict 等。 它將用於 文件：產生的 OpenAPI（以及 /docs 的使用者介面）將其顯示為回應（JSON Schema）。 序列化：您可以返回任意物件，`response_model` 將用於將該物件序列化為相應的 JSON。 過濾：傳送到用戶端的 JSON 將僅包含 `response_model` 中定義的資料（欄位）。如果您返回的物件包含屬性 `password`，但 `response_model` 不包含該欄位，則傳送到用戶端的 JSON 將不包含 `password`。 驗證：您返回的任何內容都將使用 `response_model` 進行序列化，並根據需要轉換任何資料以產生相應的 JSON。但是，如果返回的物件中的資料無效，則表示違反了與用戶端的合約，因此這是 API 開發人員的錯誤。因此，FastAPI 將引發錯誤並返回 500 錯誤碼（內部伺服器錯誤）。 在FastAPI 的回應模型文件中了解更多資訊。 類型： Any 預設值： Default(None)
status_code（狀態碼）	用於回應的預設狀態碼。 您可以透過直接返回回應來覆寫狀態碼。 在FastAPI 的回應狀態碼文件中了解更多資訊。 類型： Optional[int] 預設值： None
標籤	要套用至*路徑操作*的標籤清單。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 的路徑操作設定文件中了解更多資訊。 類型： Optional[List[Union[str, Enum]]] 預設值： None
dependencies	要套用至*路徑操作*的依存關係清單（使用 Depends()）。 在FastAPI 的路徑操作裝飾器中的依存關係文件中了解更多資訊。 類型： Optional[Sequence[Depends]] 預設值： None
summary	*路徑操作*的摘要。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 路徑操作設定文件中了解更多資訊。 類型： Optional[str] 預設值： None
description	*路徑操作*的描述。 如果未提供，將會從*路徑操作函式*的文件字串中自動擷取。 它可以包含 Markdown。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 路徑操作設定文件中了解更多資訊。 類型： Optional[str] 預設值： None
response_description（回應描述）	預設回應的描述。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： str 預設值： '成功回應'
responses	此*路徑操作*可以返回的其他回應。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： Optional[Dict[Union[int, str], Dict[str, Any]]] 預設值： None
已棄用	將此*路徑操作*標記為已棄用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： Optional[bool] 預設值： None
operation_id（操作 ID）	此 *路徑操作* 要使用的自訂操作 ID。 預設情況下，它會自動生成。 如果您提供自訂操作 ID，則需要確保它在整個 API 中是唯一的。 您可以使用 FastAPI 類別中的 generate_unique_id_function 參數來自訂操作 ID 的生成方式。 在FastAPI 如何產生客戶端的文件中了解更多資訊。 類型： Optional[str] 預設值： None
response_model_include	傳遞給 Pydantic 的設定，用於僅包含回應數據中的特定欄位。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： Optional[IncEx] 預設值： None
response_model_exclude	傳遞給 Pydantic 的設定，用於排除回應數據中的特定欄位。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： Optional[IncEx] 預設值： None
response_model_by_alias	傳遞給 Pydantic 的設定，用於定義當使用別名時，回應模型是否應透過別名進行序列化。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： True
response_model_exclude_unset	傳遞給 Pydantic 的設定，用於定義回應數據是否應包含所有欄位，包括那些未設定且具有預設值的欄位。這與 response_model_exclude_defaults 不同，如果設定了欄位，即使值與預設值相同，它們也會包含在回應中。 當設為 True 時，預設值會從回應中省略。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
response_model_exclude_defaults	傳遞給 Pydantic 的設定，用於定義回應數據是否應包含所有欄位，包括那些與預設值相同的欄位。這與 response_model_exclude_unset 不同，如果設定了欄位但包含相同的預設值，它們將從回應中排除。 當設為 True 時，預設值會從回應中省略。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
response_model_exclude_none	傳遞給 Pydantic 的設定，用於定義回應數據是否應排除設為 None 的欄位。 這比 response_model_exclude_unset 和 response_model_exclude_defaults 簡單得多（不那麼聰明）。您可能想要使用這兩個其中之一而不是這個，因為它們允許在合理的情況下返回 None 值。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
include_in_schema	將此 *路徑操作* 包含在生成的 OpenAPI 模式中。 這會影響產生的 OpenAPI（例如在 /docs 中可見）。 在FastAPI 查詢參數和字串驗證文件中了解更多資訊。 類型： bool 預設值： True
response_class	此 *路徑操作* 要使用的回應類別。 如果您直接返回回應，則不會使用此選項。 在 FastAPI 自訂回應 - HTML、串流、檔案等文件 中了解更多資訊。 類型： Type[Response] 預設值： Default(JSONResponse)
名稱	此 *路徑操作* 的名稱。僅供內部使用。 類型： Optional[str] 預設值： None
callbacks	將用作 OpenAPI 回呼的*路徑操作*清單。 這僅適用於 OpenAPI 文件，回呼不會直接使用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 更多資訊請參閱FastAPI OpenAPI 回呼文件。 類型： Optional[List[BaseRoute]] 預設值： None
openapi_extra	要包含在此 *路徑操作* 的 OpenAPI 模式中的額外中繼資料。 在 FastAPI 路徑操作進階設定文件 中了解更多資訊。 類型： Optional[Dict[str, Any]] 預設值： None
generate_unique_id_function	自訂用於產生 OpenAPI 中顯示的*路徑操作*之唯一 ID 的函式。 這在自動為您的 API 產生客戶端或 SDK 時特別有用。 在FastAPI 如何產生客戶端的文件中了解更多資訊。 類型： Callable[[APIRoute], str] 預設值： Default(generate_unique_id)

原始程式碼位於 fastapi/applications.py

def patch(
    self,
    path: Annotated[
        str,
        Doc(
            """
            The URL path to be used for this *path operation*.

            For example, in `http://example.com/items`, the path is `/items`.
            """
        ),
    ],
    *,
    response_model: Annotated[
        Any,
        Doc(
            """
            The type to use for the response.

            It could be any valid Pydantic *field* type. So, it doesn't have to
            be a Pydantic model, it could be other things, like a `list`, `dict`,
            etc.

            It will be used for:

            * Documentation: the generated OpenAPI (and the UI at `/docs`) will
                show it as the response (JSON Schema).
            * Serialization: you could return an arbitrary object and the
                `response_model` would be used to serialize that object into the
                corresponding JSON.
            * Filtering: the JSON sent to the client will only contain the data
                (fields) defined in the `response_model`. If you returned an object
                that contains an attribute `password` but the `response_model` does
                not include that field, the JSON sent to the client would not have
                that `password`.
            * Validation: whatever you return will be serialized with the
                `response_model`, converting any data as necessary to generate the
                corresponding JSON. But if the data in the object returned is not
                valid, that would mean a violation of the contract with the client,
                so it's an error from the API developer. So, FastAPI will raise an
                error and return a 500 error code (Internal Server Error).

            Read more about it in the
            [FastAPI docs for Response Model](https://fastapi.dev.org.tw/tutorial/response-model/).
            """
        ),
    ] = Default(None),
    status_code: Annotated[
        Optional[int],
        Doc(
            """
            The default status code to be used for the response.

            You could override the status code by returning a response directly.

            Read more about it in the
            [FastAPI docs for Response Status Code](https://fastapi.dev.org.tw/tutorial/response-status-code/).
            """
        ),
    ] = None,
    tags: Annotated[
        Optional[List[Union[str, Enum]]],
        Doc(
            """
            A list of tags to be applied to the *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/#tags).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Optional[Sequence[Depends]],
        Doc(
            """
            A list of dependencies (using `Depends()`) to be applied to the
            *path operation*.

            Read more about it in the
            [FastAPI docs for Dependencies in path operation decorators](https://fastapi.dev.org.tw/tutorial/dependencies/dependencies-in-path-operation-decorators/).
            """
        ),
    ] = None,
    summary: Annotated[
        Optional[str],
        Doc(
            """
            A summary for the *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    description: Annotated[
        Optional[str],
        Doc(
            """
            A description for the *path operation*.

            If not provided, it will be extracted automatically from the docstring
            of the *path operation function*.

            It can contain Markdown.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    response_description: Annotated[
        str,
        Doc(
            """
            The description for the default response.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = "Successful Response",
    responses: Annotated[
        Optional[Dict[Union[int, str], Dict[str, Any]]],
        Doc(
            """
            Additional responses that could be returned by this *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    deprecated: Annotated[
        Optional[bool],
        Doc(
            """
            Mark this *path operation* as deprecated.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    operation_id: Annotated[
        Optional[str],
        Doc(
            """
            Custom operation ID to be used by this *path operation*.

            By default, it is generated automatically.

            If you provide a custom operation ID, you need to make sure it is
            unique for the whole API.

            You can customize the
            operation ID generation with the parameter
            `generate_unique_id_function` in the `FastAPI` class.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.dev.org.tw/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = None,
    response_model_include: Annotated[
        Optional[IncEx],
        Doc(
            """
            Configuration passed to Pydantic to include only certain fields in the
            response data.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_exclude: Annotated[
        Optional[IncEx],
        Doc(
            """
            Configuration passed to Pydantic to exclude certain fields in the
            response data.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_by_alias: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response model
            should be serialized by alias when an alias is used.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = True,
    response_model_exclude_unset: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data
            should have all the fields, including the ones that were not set and
            have their default values. This is different from
            `response_model_exclude_defaults` in that if the fields are set,
            they will be included in the response, even if the value is the same
            as the default.

            When `True`, default values are omitted from the response.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#use-the-response_model_exclude_unset-parameter).
            """
        ),
    ] = False,
    response_model_exclude_defaults: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data
            should have all the fields, including the ones that have the same value
            as the default. This is different from `response_model_exclude_unset`
            in that if the fields are set but contain the same default values,
            they will be excluded from the response.

            When `True`, default values are omitted from the response.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#use-the-response_model_exclude_unset-parameter).
            """
        ),
    ] = False,
    response_model_exclude_none: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data should
            exclude fields set to `None`.

            This is much simpler (less smart) than `response_model_exclude_unset`
            and `response_model_exclude_defaults`. You probably want to use one of
            those two instead of this one, as those allow returning `None` values
            when it makes sense.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_exclude_none).
            """
        ),
    ] = False,
    include_in_schema: Annotated[
        bool,
        Doc(
            """
            Include this *path operation* in the generated OpenAPI schema.

            This affects the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Query Parameters and String Validations](https://fastapi.dev.org.tw/tutorial/query-params-str-validations/#exclude-from-openapi).
            """
        ),
    ] = True,
    response_class: Annotated[
        Type[Response],
        Doc(
            """
            Response class to be used for this *path operation*.

            This will not be used if you return a response directly.

            Read more about it in the
            [FastAPI docs for Custom Response - HTML, Stream, File, others](https://fastapi.dev.org.tw/advanced/custom-response/#redirectresponse).
            """
        ),
    ] = Default(JSONResponse),
    name: Annotated[
        Optional[str],
        Doc(
            """
            Name for this *path operation*. Only used internally.
            """
        ),
    ] = None,
    callbacks: Annotated[
        Optional[List[BaseRoute]],
        Doc(
            """
            List of *path operations* that will be used as OpenAPI callbacks.

            This is only for OpenAPI documentation, the callbacks won't be used
            directly.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for OpenAPI Callbacks](https://fastapi.dev.org.tw/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    openapi_extra: Annotated[
        Optional[Dict[str, Any]],
        Doc(
            """
            Extra metadata to be included in the OpenAPI schema for this *path
            operation*.

            Read more about it in the
            [FastAPI docs for Path Operation Advanced Configuration](https://fastapi.dev.org.tw/advanced/path-operation-advanced-configuration/#custom-openapi-path-operation-schema).
            """
        ),
    ] = None,
    generate_unique_id_function: Annotated[
        Callable[[routing.APIRoute], str],
        Doc(
            """
            Customize the function used to generate unique IDs for the *path
            operations* shown in the generated OpenAPI.

            This is particularly useful when automatically generating clients or
            SDKs for your API.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.dev.org.tw/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = Default(generate_unique_id),
) -> Callable[[DecoratedCallable], DecoratedCallable]:
    """
    Add a *path operation* using an HTTP PATCH operation.

    ## Example

    ```python
    from fastapi import FastAPI
    from pydantic import BaseModel

    class Item(BaseModel):
        name: str
        description: str | None = None

    app = FastAPI()

    @app.patch("/items/")
    def update_item(item: Item):
        return {"message": "Item updated in place"}
    ```
    """
    return self.router.patch(
        path,
        response_model=response_model,
        status_code=status_code,
        tags=tags,
        dependencies=dependencies,
        summary=summary,
        description=description,
        response_description=response_description,
        responses=responses,
        deprecated=deprecated,
        operation_id=operation_id,
        response_model_include=response_model_include,
        response_model_exclude=response_model_exclude,
        response_model_by_alias=response_model_by_alias,
        response_model_exclude_unset=response_model_exclude_unset,
        response_model_exclude_defaults=response_model_exclude_defaults,
        response_model_exclude_none=response_model_exclude_none,
        include_in_schema=include_in_schema,
        response_class=response_class,
        name=name,
        callbacks=callbacks,
        openapi_extra=openapi_extra,
        generate_unique_id_function=generate_unique_id_function,
    )

trace

trace(
    path,
    *,
    response_model=Default(None),
    status_code=None,
    tags=None,
    dependencies=None,
    summary=None,
    description=None,
    response_description="Successful Response",
    responses=None,
    deprecated=None,
    operation_id=None,
    response_model_include=None,
    response_model_exclude=None,
    response_model_by_alias=True,
    response_model_exclude_unset=False,
    response_model_exclude_defaults=False,
    response_model_exclude_none=False,
    include_in_schema=True,
    response_class=Default(JSONResponse),
    name=None,
    callbacks=None,
    openapi_extra=None,
    generate_unique_id_function=Default(generate_unique_id)
)

使用 HTTP TRACE 操作新增一個 *路徑操作*。

範例

from fastapi import FastAPI

app = FastAPI()

@app.put("/items/{item_id}")
def trace_item(item_id: str):
    return None

參數	說明
路徑	此*路徑操作*要使用的 URL 路徑。 例如，在 http://example.com/items 中，路徑是 /items。 類型： str
response_model（回應模型）	用於回應的類型。 它可以是任何有效的 Pydantic *欄位*類型。因此，它不必是 Pydantic 模型，它可以是其他類型，例如 list、dict 等。 它將用於 文件：產生的 OpenAPI（以及 /docs 的使用者介面）將其顯示為回應（JSON Schema）。 序列化：您可以返回任意物件，`response_model` 將用於將該物件序列化為相應的 JSON。 過濾：傳送到用戶端的 JSON 將僅包含 `response_model` 中定義的資料（欄位）。如果您返回的物件包含屬性 `password`，但 `response_model` 不包含該欄位，則傳送到用戶端的 JSON 將不包含 `password`。 驗證：您返回的任何內容都將使用 `response_model` 進行序列化，並根據需要轉換任何資料以產生相應的 JSON。但是，如果返回的物件中的資料無效，則表示違反了與用戶端的合約，因此這是 API 開發人員的錯誤。因此，FastAPI 將引發錯誤並返回 500 錯誤碼（內部伺服器錯誤）。 在FastAPI 的回應模型文件中了解更多資訊。 類型： Any 預設值： Default(None)
status_code（狀態碼）	用於回應的預設狀態碼。 您可以透過直接返回回應來覆寫狀態碼。 在FastAPI 的回應狀態碼文件中了解更多資訊。 類型： Optional[int] 預設值： None
標籤	要套用至*路徑操作*的標籤清單。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 的路徑操作設定文件中了解更多資訊。 類型： Optional[List[Union[str, Enum]]] 預設值： None
dependencies	要套用至*路徑操作*的依存關係清單（使用 Depends()）。 在FastAPI 的路徑操作裝飾器中的依存關係文件中了解更多資訊。 類型： Optional[Sequence[Depends]] 預設值： None
summary	*路徑操作*的摘要。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 路徑操作設定文件中了解更多資訊。 類型： Optional[str] 預設值： None
description	*路徑操作*的描述。 如果未提供，將會從*路徑操作函式*的文件字串中自動擷取。 它可以包含 Markdown。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 在FastAPI 路徑操作設定文件中了解更多資訊。 類型： Optional[str] 預設值： None
response_description（回應描述）	預設回應的描述。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： str 預設值： '成功回應'
responses	此*路徑操作*可以返回的其他回應。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： Optional[Dict[Union[int, str], Dict[str, Any]]] 預設值： None
已棄用	將此*路徑操作*標記為已棄用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 類型： Optional[bool] 預設值： None
operation_id（操作 ID）	此 *路徑操作* 要使用的自訂操作 ID。 預設情況下，它會自動生成。 如果您提供自訂操作 ID，則需要確保它在整個 API 中是唯一的。 您可以使用 FastAPI 類別中的 generate_unique_id_function 參數來自訂操作 ID 的生成方式。 在FastAPI 如何產生客戶端的文件中了解更多資訊。 類型： Optional[str] 預設值： None
response_model_include	傳遞給 Pydantic 的設定，用於僅包含回應數據中的特定欄位。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： Optional[IncEx] 預設值： None
response_model_exclude	傳遞給 Pydantic 的設定，用於排除回應數據中的特定欄位。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： Optional[IncEx] 預設值： None
response_model_by_alias	傳遞給 Pydantic 的設定，用於定義當使用別名時，回應模型是否應透過別名進行序列化。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： True
response_model_exclude_unset	傳遞給 Pydantic 的設定，用於定義回應數據是否應包含所有欄位，包括那些未設定且具有預設值的欄位。這與 response_model_exclude_defaults 不同，如果設定了欄位，即使值與預設值相同，它們也會包含在回應中。 當設為 True 時，預設值會從回應中省略。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
response_model_exclude_defaults	傳遞給 Pydantic 的設定，用於定義回應數據是否應包含所有欄位，包括那些與預設值相同的欄位。這與 response_model_exclude_unset 不同，如果設定了欄位但包含相同的預設值，它們將從回應中排除。 當設為 True 時，預設值會從回應中省略。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
response_model_exclude_none	傳遞給 Pydantic 的設定，用於定義回應數據是否應排除設為 None 的欄位。 這比 response_model_exclude_unset 和 response_model_exclude_defaults 簡單得多（不那麼聰明）。您可能想要使用這兩個其中之一而不是這個，因為它們允許在合理的情況下返回 None 值。 在 FastAPI 回應模型 - 返回類型文件 中了解更多資訊。 類型： bool 預設值： False
include_in_schema	將此 *路徑操作* 包含在生成的 OpenAPI 模式中。 這會影響產生的 OpenAPI（例如在 /docs 中可見）。 在FastAPI 查詢參數和字串驗證文件中了解更多資訊。 類型： bool 預設值： True
response_class	此 *路徑操作* 要使用的回應類別。 如果您直接返回回應，則不會使用此選項。 在 FastAPI 自訂回應 - HTML、串流、檔案等文件 中了解更多資訊。 類型： Type[Response] 預設值： Default(JSONResponse)
名稱	此 *路徑操作* 的名稱。僅供內部使用。 類型： Optional[str] 預設值： None
callbacks	將用作 OpenAPI 回呼的*路徑操作*清單。 這僅適用於 OpenAPI 文件，回呼不會直接使用。 它將被添加到生成的 OpenAPI 中（例如，在 /docs 中可見）。 更多資訊請參閱FastAPI OpenAPI 回呼文件。 類型： Optional[List[BaseRoute]] 預設值： None
openapi_extra	要包含在此 *路徑操作* 的 OpenAPI 模式中的額外中繼資料。 在 FastAPI 路徑操作進階設定文件 中了解更多資訊。 類型： Optional[Dict[str, Any]] 預設值： None
generate_unique_id_function	自訂用於產生 OpenAPI 中顯示的*路徑操作*之唯一 ID 的函式。 這在自動為您的 API 產生客戶端或 SDK 時特別有用。 在FastAPI 如何產生客戶端的文件中了解更多資訊。 類型： Callable[[APIRoute], str] 預設值： Default(generate_unique_id)

原始程式碼位於 fastapi/applications.py

def trace(
    self,
    path: Annotated[
        str,
        Doc(
            """
            The URL path to be used for this *path operation*.

            For example, in `http://example.com/items`, the path is `/items`.
            """
        ),
    ],
    *,
    response_model: Annotated[
        Any,
        Doc(
            """
            The type to use for the response.

            It could be any valid Pydantic *field* type. So, it doesn't have to
            be a Pydantic model, it could be other things, like a `list`, `dict`,
            etc.

            It will be used for:

            * Documentation: the generated OpenAPI (and the UI at `/docs`) will
                show it as the response (JSON Schema).
            * Serialization: you could return an arbitrary object and the
                `response_model` would be used to serialize that object into the
                corresponding JSON.
            * Filtering: the JSON sent to the client will only contain the data
                (fields) defined in the `response_model`. If you returned an object
                that contains an attribute `password` but the `response_model` does
                not include that field, the JSON sent to the client would not have
                that `password`.
            * Validation: whatever you return will be serialized with the
                `response_model`, converting any data as necessary to generate the
                corresponding JSON. But if the data in the object returned is not
                valid, that would mean a violation of the contract with the client,
                so it's an error from the API developer. So, FastAPI will raise an
                error and return a 500 error code (Internal Server Error).

            Read more about it in the
            [FastAPI docs for Response Model](https://fastapi.dev.org.tw/tutorial/response-model/).
            """
        ),
    ] = Default(None),
    status_code: Annotated[
        Optional[int],
        Doc(
            """
            The default status code to be used for the response.

            You could override the status code by returning a response directly.

            Read more about it in the
            [FastAPI docs for Response Status Code](https://fastapi.dev.org.tw/tutorial/response-status-code/).
            """
        ),
    ] = None,
    tags: Annotated[
        Optional[List[Union[str, Enum]]],
        Doc(
            """
            A list of tags to be applied to the *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/#tags).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Optional[Sequence[Depends]],
        Doc(
            """
            A list of dependencies (using `Depends()`) to be applied to the
            *path operation*.

            Read more about it in the
            [FastAPI docs for Dependencies in path operation decorators](https://fastapi.dev.org.tw/tutorial/dependencies/dependencies-in-path-operation-decorators/).
            """
        ),
    ] = None,
    summary: Annotated[
        Optional[str],
        Doc(
            """
            A summary for the *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    description: Annotated[
        Optional[str],
        Doc(
            """
            A description for the *path operation*.

            If not provided, it will be extracted automatically from the docstring
            of the *path operation function*.

            It can contain Markdown.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Path Operation Configuration](https://fastapi.dev.org.tw/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    response_description: Annotated[
        str,
        Doc(
            """
            The description for the default response.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = "Successful Response",
    responses: Annotated[
        Optional[Dict[Union[int, str], Dict[str, Any]]],
        Doc(
            """
            Additional responses that could be returned by this *path operation*.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    deprecated: Annotated[
        Optional[bool],
        Doc(
            """
            Mark this *path operation* as deprecated.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    operation_id: Annotated[
        Optional[str],
        Doc(
            """
            Custom operation ID to be used by this *path operation*.

            By default, it is generated automatically.

            If you provide a custom operation ID, you need to make sure it is
            unique for the whole API.

            You can customize the
            operation ID generation with the parameter
            `generate_unique_id_function` in the `FastAPI` class.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.dev.org.tw/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = None,
    response_model_include: Annotated[
        Optional[IncEx],
        Doc(
            """
            Configuration passed to Pydantic to include only certain fields in the
            response data.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_exclude: Annotated[
        Optional[IncEx],
        Doc(
            """
            Configuration passed to Pydantic to exclude certain fields in the
            response data.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_by_alias: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response model
            should be serialized by alias when an alias is used.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = True,
    response_model_exclude_unset: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data
            should have all the fields, including the ones that were not set and
            have their default values. This is different from
            `response_model_exclude_defaults` in that if the fields are set,
            they will be included in the response, even if the value is the same
            as the default.

            When `True`, default values are omitted from the response.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#use-the-response_model_exclude_unset-parameter).
            """
        ),
    ] = False,
    response_model_exclude_defaults: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data
            should have all the fields, including the ones that have the same value
            as the default. This is different from `response_model_exclude_unset`
            in that if the fields are set but contain the same default values,
            they will be excluded from the response.

            When `True`, default values are omitted from the response.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#use-the-response_model_exclude_unset-parameter).
            """
        ),
    ] = False,
    response_model_exclude_none: Annotated[
        bool,
        Doc(
            """
            Configuration passed to Pydantic to define if the response data should
            exclude fields set to `None`.

            This is much simpler (less smart) than `response_model_exclude_unset`
            and `response_model_exclude_defaults`. You probably want to use one of
            those two instead of this one, as those allow returning `None` values
            when it makes sense.

            Read more about it in the
            [FastAPI docs for Response Model - Return Type](https://fastapi.dev.org.tw/tutorial/response-model/#response_model_exclude_none).
            """
        ),
    ] = False,
    include_in_schema: Annotated[
        bool,
        Doc(
            """
            Include this *path operation* in the generated OpenAPI schema.

            This affects the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for Query Parameters and String Validations](https://fastapi.dev.org.tw/tutorial/query-params-str-validations/#exclude-from-openapi).
            """
        ),
    ] = True,
    response_class: Annotated[
        Type[Response],
        Doc(
            """
            Response class to be used for this *path operation*.

            This will not be used if you return a response directly.

            Read more about it in the
            [FastAPI docs for Custom Response - HTML, Stream, File, others](https://fastapi.dev.org.tw/advanced/custom-response/#redirectresponse).
            """
        ),
    ] = Default(JSONResponse),
    name: Annotated[
        Optional[str],
        Doc(
            """
            Name for this *path operation*. Only used internally.
            """
        ),
    ] = None,
    callbacks: Annotated[
        Optional[List[BaseRoute]],
        Doc(
            """
            List of *path operations* that will be used as OpenAPI callbacks.

            This is only for OpenAPI documentation, the callbacks won't be used
            directly.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).

            Read more about it in the
            [FastAPI docs for OpenAPI Callbacks](https://fastapi.dev.org.tw/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    openapi_extra: Annotated[
        Optional[Dict[str, Any]],
        Doc(
            """
            Extra metadata to be included in the OpenAPI schema for this *path
            operation*.

            Read more about it in the
            [FastAPI docs for Path Operation Advanced Configuration](https://fastapi.dev.org.tw/advanced/path-operation-advanced-configuration/#custom-openapi-path-operation-schema).
            """
        ),
    ] = None,
    generate_unique_id_function: Annotated[
        Callable[[routing.APIRoute], str],
        Doc(
            """
            Customize the function used to generate unique IDs for the *path
            operations* shown in the generated OpenAPI.

            This is particularly useful when automatically generating clients or
            SDKs for your API.

            Read more about it in the
            [FastAPI docs about how to Generate Clients](https://fastapi.dev.org.tw/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = Default(generate_unique_id),
) -> Callable[[DecoratedCallable], DecoratedCallable]:
    """
    Add a *path operation* using an HTTP TRACE operation.

    ## Example

    ```python
    from fastapi import FastAPI

    app = FastAPI()

    @app.put("/items/{item_id}")
    def trace_item(item_id: str):
        return None
    ```
    """
    return self.router.trace(
        path,
        response_model=response_model,
        status_code=status_code,
        tags=tags,
        dependencies=dependencies,
        summary=summary,
        description=description,
        response_description=response_description,
        responses=responses,
        deprecated=deprecated,
        operation_id=operation_id,
        response_model_include=response_model_include,
        response_model_exclude=response_model_exclude,
        response_model_by_alias=response_model_by_alias,
        response_model_exclude_unset=response_model_exclude_unset,
        response_model_exclude_defaults=response_model_exclude_defaults,
        response_model_exclude_none=response_model_exclude_none,
        include_in_schema=include_in_schema,
        response_class=response_class,
        name=name,
        callbacks=callbacks,
        openapi_extra=openapi_extra,
        generate_unique_id_function=generate_unique_id_function,
    )

on_event

on_event(event_type)

新增應用程式的事件處理器。

on_event 已被棄用，請改用 lifespan 事件處理器。

請在 FastAPI 生命週期事件文件 中了解更多資訊。

參數	說明
event_type	事件類型。startup 或 shutdown。 類型： str

原始程式碼位於 fastapi/applications.py

@deprecated(
    """
    on_event is deprecated, use lifespan event handlers instead.

    Read more about it in the
    [FastAPI docs for Lifespan Events](https://fastapi.dev.org.tw/advanced/events/).
    """
)
def on_event(
    self,
    event_type: Annotated[
        str,
        Doc(
            """
            The type of event. `startup` or `shutdown`.
            """
        ),
    ],
) -> Callable[[DecoratedCallable], DecoratedCallable]:
    """
    Add an event handler for the application.

    `on_event` is deprecated, use `lifespan` event handlers instead.

    Read more about it in the
    [FastAPI docs for Lifespan Events](https://fastapi.dev.org.tw/advanced/events/#alternative-events-deprecated).
    """
    return self.router.on_event(event_type)

middleware

middleware(middleware_type)

新增中介軟體到應用程式。

請在 FastAPI 中介軟體文件 中了解更多資訊。

範例

import time

from fastapi import FastAPI, Request

app = FastAPI()


@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    start_time = time.time()
    response = await call_next(request)
    process_time = time.time() - start_time
    response.headers["X-Process-Time"] = str(process_time)
    return response

參數	說明
middleware_type	中介軟體類型。目前僅支援 http。 類型： str

原始程式碼位於 fastapi/applications.py

def middleware(
    self,
    middleware_type: Annotated[
        str,
        Doc(
            """
            The type of middleware. Currently only supports `http`.
            """
        ),
    ],
) -> Callable[[DecoratedCallable], DecoratedCallable]:
    """
    Add a middleware to the application.

    Read more about it in the
    [FastAPI docs for Middleware](https://fastapi.dev.org.tw/tutorial/middleware/).

    ## Example

    ```python
    import time

    from fastapi import FastAPI, Request

    app = FastAPI()


    @app.middleware("http")
    async def add_process_time_header(request: Request, call_next):
        start_time = time.time()
        response = await call_next(request)
        process_time = time.time() - start_time
        response.headers["X-Process-Time"] = str(process_time)
        return response
    ```
    """

    def decorator(func: DecoratedCallable) -> DecoratedCallable:
        self.add_middleware(BaseHTTPMiddleware, dispatch=func)
        return func

    return decorator

exception_handler

exception_handler(exc_class_or_status_code)

新增例外處理器到應用程式。

請在 FastAPI 錯誤處理文件 中了解更多資訊。

範例

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse


class UnicornException(Exception):
    def __init__(self, name: str):
        self.name = name


app = FastAPI()


@app.exception_handler(UnicornException)
async def unicorn_exception_handler(request: Request, exc: UnicornException):
    return JSONResponse(
        status_code=418,
        content={"message": f"Oops! {exc.name} did something. There goes a rainbow..."},
    )

參數	說明
exc_class_or_status_code	這個處理器會處理的例外類別，或是一個狀態碼。 類型： Union[int, Type[Exception]]

原始程式碼位於 fastapi/applications.py

def exception_handler(
    self,
    exc_class_or_status_code: Annotated[
        Union[int, Type[Exception]],
        Doc(
            """
            The Exception class this would handle, or a status code.
            """
        ),
    ],
) -> Callable[[DecoratedCallable], DecoratedCallable]:
    """
    Add an exception handler to the app.

    Read more about it in the
    [FastAPI docs for Handling Errors](https://fastapi.dev.org.tw/tutorial/handling-errors/).

    ## Example

    ```python
    from fastapi import FastAPI, Request
    from fastapi.responses import JSONResponse


    class UnicornException(Exception):
        def __init__(self, name: str):
            self.name = name


    app = FastAPI()


    @app.exception_handler(UnicornException)
    async def unicorn_exception_handler(request: Request, exc: UnicornException):
        return JSONResponse(
            status_code=418,
            content={"message": f"Oops! {exc.name} did something. There goes a rainbow..."},
        )
    ```
    """

    def decorator(func: DecoratedCallable) -> DecoratedCallable:
        self.add_exception_handler(exc_class_or_status_code, func)
        return func

    return decorator