`APIRouter` 类¶

这是 APIRouter 类的参考信息，包含其所有的参数、属性和方法。

你可以直接从 fastapi 中导入 APIRouter 类。

from fastapi import APIRouter

fastapi.APIRouter ¶

APIRouter(
    *,
    prefix="",
    tags=None,
    dependencies=None,
    default_response_class=Default(JSONResponse),
    responses=None,
    callbacks=None,
    routes=None,
    redirect_slashes=True,
    default=None,
    dependency_overrides_provider=None,
    route_class=APIRoute,
    on_startup=None,
    on_shutdown=None,
    lifespan=None,
    deprecated=None,
    include_in_schema=True,
    generate_unique_id_function=Default(generate_unique_id),
    strict_content_type=Default(True)
)

基类： Router

APIRouter 类用于对 路径操作 进行分组，例如将应用结构化为多个文件。随后它可以被包含在 FastAPI 应用中，或包含在另一个 APIRouter 中（最终被包含在应用中）。

更多信息请阅读 FastAPI 文档：大型应用 - 多个文件。

示例¶

from fastapi import APIRouter, FastAPI

app = FastAPI()
router = APIRouter()


@router.get("/users/", tags=["users"])
async def read_users():
    return [{"username": "Rick"}, {"username": "Morty"}]


app.include_router(router)

参数	描述
`prefix`	路由器可选的路径前缀。类型: `str` 默认值: `''`
`tags`	应用于此路由器中所有路径操作的标签列表。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型: `list[str \| Enum] \| None` 默认值: `None`
`dependencies`	应用于此路由器中所有路径操作的依赖项列表（使用 `Depends()`）。更多信息请阅读 FastAPI 文档：大型应用 - 多个文件。类型: `Sequence[Depends] \| None` 默认值: `None`
`default_response_class`	使用的默认响应类。更多信息请阅读 FastAPI 文档：自定义响应 - HTML、流、文件等。类型: `type[Response]` 默认值: `Default(JSONResponse)`
`responses`	在 OpenAPI 中显示的附加响应。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：OpenAPI 中的附加响应。以及 FastAPI 文档：大型应用。类型: `dict[int \| str, dict[str, Any]] \| None` 默认值: `None`
`callbacks`	应应用于此路由器中所有路径操作的 OpenAPI 回调。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：OpenAPI 回调。类型: `list[BaseRoute] \| None` 默认值: `None`
`routes`	注意：通常不应使用此参数，它是从 Starlette 继承而来，仅为兼容性提供支持。用于处理传入 HTTP 和 WebSocket 请求的路由列表。类型: `list[BaseRoute] \| None` 默认值: `None`
`redirect_slashes`	当客户端不使用相同格式时，是否检测并重定向 URL 中的斜杠。类型: `bool` 默认值: `True`
`default`	此路由器的默认函数处理器。用于处理 404 未找到错误。类型: `ASGIApp \| None` 默认值: `None`
`dependency_overrides_provider`	仅由 FastAPI 内部用于处理依赖项覆盖。你通常不需要使用它。它通常指向 `FastAPI` 应用对象。类型: `Any \| None` 默认值: `None`
`route_class`	此路由器使用的自定义路由（路径操作）类。更多信息请阅读 FastAPI 文档：自定义请求和 APIRoute 类。类型: `type[APIRoute]` 默认值: `APIRoute`
`on_startup`	启动事件处理器函数列表。建议改用 `lifespan` 处理器。更多信息请阅读 FastAPI 文档：`lifespan`。类型: `Sequence[Callable[[], Any]] \| None` 默认值: `None`
`on_shutdown`	关闭事件处理器函数列表。建议改用 `lifespan` 处理器。更多信息请阅读 FastAPI 文档：`lifespan`。类型: `Sequence[Callable[[], Any]] \| None` 默认值: `None`
`lifespan`	`Lifespan` 上下文管理器处理器。这取代了 `startup` 和 `shutdown` 函数，使用单个上下文管理器。更多信息请阅读 FastAPI 文档：`lifespan`。类型: `Lifespan[Any] \| None` 默认值: `None`
`deprecated`	将此路由器中的所有路径操作标记为已弃用。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型： `bool \| None` 默认值： `None`
`include_in_schema`	决定是否将此路由器中的所有路径操作包含在生成的 OpenAPI 中。这会影响生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：查询参数和字符串校验。类型: `bool` 默认值: `True`
`generate_unique_id_function`	自定义用于为生成的 OpenAPI 中显示的路径操作生成唯一 ID 的函数。这在为 API 自动生成客户端或 SDK 时特别有用。更多信息请阅读 FastAPI 文档：如何生成客户端。类型: `Callable[[APIRoute], str]` 默认值: `Default(generate_unique_id)`
`strict_content_type`	为请求 Content-Type 头启用严格检查。当设置为 `True`（默认值）时，没有 `Content-Type` 头的请求体将不会被解析为 JSON。这可以防止潜在的跨站请求伪造 (CSRF) 攻击，这些攻击利用浏览器在没有 Content-Type 头的情况下发送请求，从而绕过 CORS 预检检查。特别适用于需要本地运行（在 localhost 中）的应用。当设置为 `False` 时，没有 `Content-Type` 头的请求体将被解析为 JSON，这保持了与某些不发送 `Content-Type` 头的客户端的兼容性。更多信息请阅读 FastAPI 文档：严格 Content-Type。类型: `bool` 默认值: `Default(True)`

源代码位于 fastapi/routing.py

def __init__(
    self,
    *,
    prefix: Annotated[str, Doc("An optional path prefix for the router.")] = "",
    tags: Annotated[
        list[str | Enum] | None,
        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.org.cn/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Sequence[params.Depends] | None,
        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.org.cn/tutorial/bigger-applications/#include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies).
            """
        ),
    ] = 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.org.cn/advanced/custom-response/#default-response-class).
            """
        ),
    ] = Default(JSONResponse),
    responses: Annotated[
        dict[int | str, dict[str, Any]] | None,
        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.org.cn/advanced/additional-responses/).

            And in the
            [FastAPI docs for Bigger Applications](https://fastapi.org.cn/tutorial/bigger-applications/#include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies).
            """
        ),
    ] = None,
    callbacks: Annotated[
        list[BaseRoute] | None,
        Doc(
            """
            OpenAPI callbacks that should apply to all *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 OpenAPI Callbacks](https://fastapi.org.cn/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    routes: Annotated[
        list[BaseRoute] | None,
        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 `router.get()`, `router.post()`, etc.
            """
        ),
    ] = None,
    redirect_slashes: Annotated[
        bool,
        Doc(
            """
            Whether to detect and redirect slashes in URLs when the client doesn't
            use the same format.
            """
        ),
    ] = True,
    default: Annotated[
        ASGIApp | None,
        Doc(
            """
            Default function handler for this router. Used to handle
            404 Not Found errors.
            """
        ),
    ] = None,
    dependency_overrides_provider: Annotated[
        Any | None,
        Doc(
            """
            Only used internally by FastAPI to handle dependency overrides.

            You shouldn't need to use it. It normally points to the `FastAPI` app
            object.
            """
        ),
    ] = None,
    route_class: Annotated[
        type[APIRoute],
        Doc(
            """
            Custom route (*path operation*) class to be used by this router.

            Read more about it in the
            [FastAPI docs for Custom Request and APIRoute class](https://fastapi.org.cn/how-to/custom-request-and-route/#custom-apiroute-class-in-a-router).
            """
        ),
    ] = APIRoute,
    on_startup: Annotated[
        Sequence[Callable[[], Any]] | None,
        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.org.cn/advanced/events/).
            """
        ),
    ] = None,
    on_shutdown: Annotated[
        Sequence[Callable[[], Any]] | None,
        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.org.cn/advanced/events/).
            """
        ),
    ] = None,
    # the generic to Lifespan[AppType] is the type of the top level application
    # which the router cannot know statically, so we use typing.Any
    lifespan: Annotated[
        Lifespan[Any] | None,
        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.org.cn/advanced/events/).
            """
        ),
    ] = None,
    deprecated: Annotated[
        bool | None,
        Doc(
            """
            Mark all *path operations* in this router as deprecated.

            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.org.cn/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    include_in_schema: Annotated[
        bool,
        Doc(
            """
            To include (or not) all the *path operations* in this router in the
            generated OpenAPI.

            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.org.cn/tutorial/query-params-str-validations/#exclude-parameters-from-openapi).
            """
        ),
    ] = True,
    generate_unique_id_function: Annotated[
        Callable[[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.org.cn/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = Default(generate_unique_id),
    strict_content_type: Annotated[
        bool,
        Doc(
            """
            Enable strict checking for request Content-Type headers.

            When `True` (the default), requests with a body that do not include
            a `Content-Type` header will **not** be parsed as JSON.

            This prevents potential cross-site request forgery (CSRF) attacks
            that exploit the browser's ability to send requests without a
            Content-Type header, bypassing CORS preflight checks. In particular
            applicable for apps that need to be run locally (in localhost).

            When `False`, requests without a `Content-Type` header will have
            their body parsed as JSON, which maintains compatibility with
            certain clients that don't send `Content-Type` headers.

            Read more about it in the
            [FastAPI docs for Strict Content-Type](https://fastapi.org.cn/advanced/strict-content-type/).
            """
        ),
    ] = Default(True),
) -> None:
    # Determine the lifespan context to use
    if lifespan is None:
        # Use the default lifespan that runs on_startup/on_shutdown handlers
        lifespan_context: Lifespan[Any] = _DefaultLifespan(self)
    elif inspect.isasyncgenfunction(lifespan):
        lifespan_context = asynccontextmanager(lifespan)
    elif inspect.isgeneratorfunction(lifespan):
        lifespan_context = _wrap_gen_lifespan_context(lifespan)
    else:
        lifespan_context = lifespan
    self.lifespan_context = lifespan_context

    super().__init__(
        routes=routes,
        redirect_slashes=redirect_slashes,
        default=default,
        lifespan=lifespan_context,
    )
    if prefix:
        assert prefix.startswith("/"), "A path prefix must start with '/'"
        assert not prefix.endswith("/"), (
            "A path prefix must not end with '/', as the routes will start with '/'"
        )

    # Handle on_startup/on_shutdown locally since Starlette removed support
    # Ref: https://github.com/Kludex/starlette/pull/3117
    # TODO: deprecate this once the lifespan (or alternative) interface is improved
    self.on_startup: list[Callable[[], Any]] = (
        [] if on_startup is None else list(on_startup)
    )
    self.on_shutdown: list[Callable[[], Any]] = (
        [] if on_shutdown is None else list(on_shutdown)
    )

    self.prefix = prefix
    self.tags: list[str | Enum] = tags or []
    self.dependencies = list(dependencies or [])
    self.deprecated = deprecated
    self.include_in_schema = include_in_schema
    self.responses = responses or {}
    self.callbacks = callbacks or []
    self.dependency_overrides_provider = dependency_overrides_provider
    self.route_class = route_class
    self.default_response_class = default_response_class
    self.generate_unique_id_function = generate_unique_id_function
    self.strict_content_type = strict_content_type

websocket ¶

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

装饰一个 WebSocket 函数。

在 FastAPI 文档的“WebSockets”中了解更多。

示例

示例¶

from fastapi import APIRouter, FastAPI, WebSocket

app = FastAPI()
router = APIRouter()

@router.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}")

app.include_router(router)

参数	描述
`path`	WebSocket 路径。类型: `str`
`name`	WebSocket 的名称。仅在内部使用。类型： `str \| None` 默认值： `None`
`dependencies`	用于此 WebSocket 的依赖项列表（使用 `Depends()`）。在 FastAPI 文档的“WebSockets”中了解更多。类型: `Sequence[Depends] \| None` 默认值: `None`

源代码位于 fastapi/routing.py

def websocket(
    self,
    path: Annotated[
        str,
        Doc(
            """
            WebSocket path.
            """
        ),
    ],
    name: Annotated[
        str | None,
        Doc(
            """
            A name for the WebSocket. Only used internally.
            """
        ),
    ] = None,
    *,
    dependencies: Annotated[
        Sequence[params.Depends] | None,
        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.org.cn/advanced/websockets/).
            """
        ),
    ] = None,
) -> Callable[[DecoratedCallable], DecoratedCallable]:
    """
    Decorate a WebSocket function.

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

    **Example**

    ## Example

    ```python
    from fastapi import APIRouter, FastAPI, WebSocket

    app = FastAPI()
    router = APIRouter()

    @router.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}")

    app.include_router(router)
    ```
    """

    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,
    default_response_class=Default(JSONResponse),
    responses=None,
    callbacks=None,
    deprecated=None,
    include_in_schema=True,
    generate_unique_id_function=Default(generate_unique_id)
)

在当前 APIRouter 中包含另一个 APIRouter。

更多信息请阅读 FastAPI 文档：大型应用。

示例¶

from fastapi import APIRouter, FastAPI

app = FastAPI()
internal_router = APIRouter()
users_router = APIRouter()

@users_router.get("/users/")
def read_users():
    return [{"name": "Rick"}, {"name": "Morty"}]

internal_router.include_router(users_router)
app.include_router(internal_router)

参数	描述
`router`	要包含的 `APIRouter`。类型: `APIRouter`
`prefix`	路由器可选的路径前缀。类型: `str` 默认值: `''`
`tags`	应用于此路由器中所有路径操作的标签列表。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型: `list[str \| Enum] \| None` 默认值: `None`
`dependencies`	应用于此路由器中所有路径操作的依赖项列表（使用 `Depends()`）。更多信息请阅读 FastAPI 文档：大型应用 - 多个文件。类型: `Sequence[Depends] \| None` 默认值: `None`
`default_response_class`	使用的默认响应类。更多信息请阅读 FastAPI 文档：自定义响应 - HTML、流、文件等。类型: `type[Response]` 默认值: `Default(JSONResponse)`
`responses`	在 OpenAPI 中显示的附加响应。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：OpenAPI 中的附加响应。以及 FastAPI 文档：大型应用。类型: `dict[int \| str, dict[str, Any]] \| None` 默认值: `None`
`callbacks`	应应用于此路由器中所有路径操作的 OpenAPI 回调。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：OpenAPI 回调。类型: `list[BaseRoute] \| None` 默认值: `None`
`deprecated`	将此路由器中的所有路径操作标记为已弃用。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型： `bool \| None` 默认值： `None`
`include_in_schema`	决定是否将此路由器中的所有路径操作包含在生成的 OpenAPI 模式中。这会影响生成的 OpenAPI (例如在 `/docs` 中可见)。类型: `bool` 默认值: `True`
`generate_unique_id_function`	自定义用于为生成的 OpenAPI 中显示的路径操作生成唯一 ID 的函数。这在为 API 自动生成客户端或 SDK 时特别有用。更多信息请阅读 FastAPI 文档：如何生成客户端。类型: `Callable[[APIRoute], str]` 默认值: `Default(generate_unique_id)`

源代码位于 fastapi/routing.py

def include_router(
    self,
    router: Annotated["APIRouter", Doc("The `APIRouter` to include.")],
    *,
    prefix: Annotated[str, Doc("An optional path prefix for the router.")] = "",
    tags: Annotated[
        list[str | Enum] | None,
        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.org.cn/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Sequence[params.Depends] | None,
        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.org.cn/tutorial/bigger-applications/#include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies).
            """
        ),
    ] = 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.org.cn/advanced/custom-response/#default-response-class).
            """
        ),
    ] = Default(JSONResponse),
    responses: Annotated[
        dict[int | str, dict[str, Any]] | None,
        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.org.cn/advanced/additional-responses/).

            And in the
            [FastAPI docs for Bigger Applications](https://fastapi.org.cn/tutorial/bigger-applications/#include-an-apirouter-with-a-custom-prefix-tags-responses-and-dependencies).
            """
        ),
    ] = None,
    callbacks: Annotated[
        list[BaseRoute] | None,
        Doc(
            """
            OpenAPI callbacks that should apply to all *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 OpenAPI Callbacks](https://fastapi.org.cn/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    deprecated: Annotated[
        bool | None,
        Doc(
            """
            Mark all *path operations* in this router as deprecated.

            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.org.cn/tutorial/path-operation-configuration/).
            """
        ),
    ] = 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`).
            """
        ),
    ] = True,
    generate_unique_id_function: Annotated[
        Callable[[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.org.cn/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = Default(generate_unique_id),
) -> None:
    """
    Include another `APIRouter` in the same current `APIRouter`.

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

    ## Example

    ```python
    from fastapi import APIRouter, FastAPI

    app = FastAPI()
    internal_router = APIRouter()
    users_router = APIRouter()

    @users_router.get("/users/")
    def read_users():
        return [{"name": "Rick"}, {"name": "Morty"}]

    internal_router.include_router(users_router)
    app.include_router(internal_router)
    ```
    """
    assert self is not router, (
        "Cannot include the same APIRouter instance into itself. "
        "Did you mean to include a different router?"
    )
    if prefix:
        assert prefix.startswith("/"), "A path prefix must start with '/'"
        assert not prefix.endswith("/"), (
            "A path prefix must not end with '/', as the routes will start with '/'"
        )
    else:
        for r in router.routes:
            path = getattr(r, "path")  # noqa: B009
            name = getattr(r, "name", "unknown")
            if path is not None and not path:
                raise FastAPIError(
                    f"Prefix and path cannot be both empty (path operation: {name})"
                )
    if responses is None:
        responses = {}
    for route in router.routes:
        if isinstance(route, APIRoute):
            combined_responses = {**responses, **route.responses}
            use_response_class = get_value_or_default(
                route.response_class,
                router.default_response_class,
                default_response_class,
                self.default_response_class,
            )
            current_tags = []
            if tags:
                current_tags.extend(tags)
            if route.tags:
                current_tags.extend(route.tags)
            current_dependencies: list[params.Depends] = []
            if dependencies:
                current_dependencies.extend(dependencies)
            if route.dependencies:
                current_dependencies.extend(route.dependencies)
            current_callbacks = []
            if callbacks:
                current_callbacks.extend(callbacks)
            if route.callbacks:
                current_callbacks.extend(route.callbacks)
            current_generate_unique_id = get_value_or_default(
                route.generate_unique_id_function,
                router.generate_unique_id_function,
                generate_unique_id_function,
                self.generate_unique_id_function,
            )
            self.add_api_route(
                prefix + route.path,
                route.endpoint,
                response_model=route.response_model,
                status_code=route.status_code,
                tags=current_tags,
                dependencies=current_dependencies,
                summary=route.summary,
                description=route.description,
                response_description=route.response_description,
                responses=combined_responses,
                deprecated=route.deprecated or deprecated or self.deprecated,
                methods=route.methods,
                operation_id=route.operation_id,
                response_model_include=route.response_model_include,
                response_model_exclude=route.response_model_exclude,
                response_model_by_alias=route.response_model_by_alias,
                response_model_exclude_unset=route.response_model_exclude_unset,
                response_model_exclude_defaults=route.response_model_exclude_defaults,
                response_model_exclude_none=route.response_model_exclude_none,
                include_in_schema=route.include_in_schema
                and self.include_in_schema
                and include_in_schema,
                response_class=use_response_class,
                name=route.name,
                route_class_override=type(route),
                callbacks=current_callbacks,
                openapi_extra=route.openapi_extra,
                generate_unique_id_function=current_generate_unique_id,
                strict_content_type=get_value_or_default(
                    route.strict_content_type,
                    router.strict_content_type,
                    self.strict_content_type,
                ),
            )
        elif isinstance(route, routing.Route):
            methods = list(route.methods or [])
            self.add_route(
                prefix + route.path,
                route.endpoint,
                methods=methods,
                include_in_schema=route.include_in_schema,
                name=route.name,
            )
        elif isinstance(route, APIWebSocketRoute):
            current_dependencies = []
            if dependencies:
                current_dependencies.extend(dependencies)
            if route.dependencies:
                current_dependencies.extend(route.dependencies)
            self.add_api_websocket_route(
                prefix + route.path,
                route.endpoint,
                dependencies=current_dependencies,
                name=route.name,
            )
        elif isinstance(route, routing.WebSocketRoute):
            self.add_websocket_route(
                prefix + route.path, route.endpoint, name=route.name
            )
    for handler in router.on_startup:
        self.add_event_handler("startup", handler)
    for handler in router.on_shutdown:
        self.add_event_handler("shutdown", handler)
    self.lifespan_context = _merge_lifespan_context(
        self.lifespan_context,
        router.lifespan_context,
    )

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 APIRouter, FastAPI

app = FastAPI()
router = APIRouter()

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

app.include_router(router)

参数	描述
`path`	用于此路径操作的 URL 路径。例如，在 `http://example.com/items` 中，路径是 `/items`。类型: `str`
`response_model`	用于响应的类型。它可以是任何有效的 Pydantic 字段类型。因此，它不一定是 Pydantic 模型，也可以是其他类型，例如 `list`, `dict` 等。它将用于：文档：生成的 OpenAPI（以及 `/docs` 处的 UI）会将其显示为响应（JSON 模式）。序列化：你可以返回一个任意对象，`response_model` 将用于将该对象序列化为对应的 JSON。过滤：发送给客户端的 JSON 只会包含 `response_model` 中定义的字段。如果你返回了一个包含 `password` 属性的对象，但 `response_model` 不包含该字段，那么发送给客户端的 JSON 将不会有 `password`。校验：你返回的任何内容都将使用 `response_model` 进行序列化，根据需要转换任何数据以生成对应的 JSON。但如果对象中的数据无效，则意味着违反了与客户端的契约，这是 API 开发者的错误。因此，FastAPI 将抛出错误并返回 500 错误码（内部服务器错误）。更多信息请阅读 FastAPI 文档：响应模型。类型: `Any` 默认值: `Default(None)`
`status_code`	用于响应的默认状态码。你可以通过直接返回一个响应来覆盖状态码。更多信息请阅读 FastAPI 文档：响应状态码。类型： `int \| None` 默认值： `None`
`tags`	应用于此路径操作的标签列表。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型: `list[str \| Enum] \| None` 默认值: `None`
`dependencies`	应用于此路径操作的依赖项列表（使用 `Depends()`）。更多信息请阅读 FastAPI 文档：路径操作装饰器中的依赖项。类型: `Sequence[Depends] \| None` 默认值: `None`
`summary`	此路径操作的摘要。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型： `str \| None` 默认值： `None`
`description`	此路径操作的描述。如果未提供，它将从路径操作函数的文档字符串中自动提取。它可以包含 Markdown。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型： `str \| None` 默认值： `None`
`response_description`	默认响应的描述。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型: `str` 默认值: `'Successful Response'`
`responses`	此路径操作可能返回的附加响应。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型: `dict[int \| str, dict[str, Any]] \| None` 默认值: `None`
`deprecated`	将此路径操作标记为已弃用。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型： `bool \| None` 默认值： `None`
`operation_id`	此路径操作使用的自定义操作 ID。默认情况下，它是自动生成的。如果你提供了自定义操作 ID，请确保它在整个 API 中是唯一的。你可以使用 `FastAPI` 类中的 `generate_unique_id_function` 参数自定义操作 ID 的生成。更多信息请阅读 FastAPI 文档：如何生成客户端。类型： `str \| None` 默认值： `None`
`response_model_include`	传递给 Pydantic 的配置，仅在响应数据中包含特定字段。更多信息请阅读 FastAPI 文档：响应模型 - 返回类型。类型: `IncEx \| None` 默认值: `None`
`response_model_exclude`	传递给 Pydantic 的配置，在响应数据中排除特定字段。更多信息请阅读 FastAPI 文档：响应模型 - 返回类型。类型: `IncEx \| None` 默认值: `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)`
`name`	此路径操作的名称。仅在内部使用。类型： `str \| None` 默认值： `None`
`callbacks`	将用作 OpenAPI 回调的路径操作列表。这仅用于 OpenAPI 文档，回调不会被直接使用。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：OpenAPI 回调。类型: `list[BaseRoute] \| None` 默认值: `None`
`openapi_extra`	要包含在此路径操作的 OpenAPI 模式中的额外元数据。更多信息请阅读 FastAPI 文档：路径操作高级配置。类型: `dict[str, Any] \| None` 默认值: `None`
`generate_unique_id_function`	自定义用于为生成的 OpenAPI 中显示的路径操作生成唯一 ID 的函数。这在为 API 自动生成客户端或 SDK 时特别有用。更多信息请阅读 FastAPI 文档：如何生成客户端。类型: `Callable[[APIRoute], str]` 默认值: `Default(generate_unique_id)`

源代码位于 fastapi/routing.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.org.cn/tutorial/response-model/).
            """
        ),
    ] = Default(None),
    status_code: Annotated[
        int | None,
        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.org.cn/tutorial/response-status-code/).
            """
        ),
    ] = None,
    tags: Annotated[
        list[str | Enum] | None,
        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.org.cn/tutorial/path-operation-configuration/#tags).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Sequence[params.Depends] | None,
        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.org.cn/tutorial/dependencies/dependencies-in-path-operation-decorators/).
            """
        ),
    ] = None,
    summary: Annotated[
        str | None,
        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.org.cn/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    description: Annotated[
        str | None,
        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.org.cn/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[
        dict[int | str, dict[str, Any]] | None,
        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[
        bool | None,
        Doc(
            """
            Mark this *path operation* as deprecated.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    operation_id: Annotated[
        str | None,
        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.org.cn/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = None,
    response_model_include: Annotated[
        IncEx | None,
        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.org.cn/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_exclude: Annotated[
        IncEx | None,
        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.org.cn/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.org.cn/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.org.cn/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.org.cn/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.org.cn/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.org.cn/tutorial/query-params-str-validations/#exclude-parameters-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.org.cn/advanced/custom-response/#redirectresponse).
            """
        ),
    ] = Default(JSONResponse),
    name: Annotated[
        str | None,
        Doc(
            """
            Name for this *path operation*. Only used internally.
            """
        ),
    ] = None,
    callbacks: Annotated[
        list[BaseRoute] | None,
        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.org.cn/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    openapi_extra: Annotated[
        dict[str, Any] | None,
        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.org.cn/advanced/path-operation-advanced-configuration/#custom-openapi-path-operation-schema).
            """
        ),
    ] = None,
    generate_unique_id_function: Annotated[
        Callable[[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.org.cn/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 APIRouter, FastAPI

    app = FastAPI()
    router = APIRouter()

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

    app.include_router(router)
    ```
    """
    return self.api_route(
        path=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,
        methods=["GET"],
        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 APIRouter, FastAPI
from pydantic import BaseModel

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

app = FastAPI()
router = APIRouter()

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

app.include_router(router)

参数	描述
`path`	用于此路径操作的 URL 路径。例如，在 `http://example.com/items` 中，路径是 `/items`。类型: `str`
`response_model`	用于响应的类型。它可以是任何有效的 Pydantic 字段类型。因此，它不一定是 Pydantic 模型，也可以是其他类型，例如 `list`, `dict` 等。它将用于：文档：生成的 OpenAPI（以及 `/docs` 处的 UI）会将其显示为响应（JSON 模式）。序列化：你可以返回一个任意对象，`response_model` 将用于将该对象序列化为对应的 JSON。过滤：发送给客户端的 JSON 只会包含 `response_model` 中定义的字段。如果你返回了一个包含 `password` 属性的对象，但 `response_model` 不包含该字段，那么发送给客户端的 JSON 将不会有 `password`。校验：你返回的任何内容都将使用 `response_model` 进行序列化，根据需要转换任何数据以生成对应的 JSON。但如果对象中的数据无效，则意味着违反了与客户端的契约，这是 API 开发者的错误。因此，FastAPI 将抛出错误并返回 500 错误码（内部服务器错误）。更多信息请阅读 FastAPI 文档：响应模型。类型: `Any` 默认值: `Default(None)`
`status_code`	用于响应的默认状态码。你可以通过直接返回一个响应来覆盖状态码。更多信息请阅读 FastAPI 文档：响应状态码。类型： `int \| None` 默认值： `None`
`tags`	应用于此路径操作的标签列表。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型: `list[str \| Enum] \| None` 默认值: `None`
`dependencies`	应用于此路径操作的依赖项列表（使用 `Depends()`）。更多信息请阅读 FastAPI 文档：路径操作装饰器中的依赖项。类型: `Sequence[Depends] \| None` 默认值: `None`
`summary`	此路径操作的摘要。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型： `str \| None` 默认值： `None`
`description`	此路径操作的描述。如果未提供，它将从路径操作函数的文档字符串中自动提取。它可以包含 Markdown。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型： `str \| None` 默认值： `None`
`response_description`	默认响应的描述。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型: `str` 默认值: `'Successful Response'`
`responses`	此路径操作可能返回的附加响应。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型: `dict[int \| str, dict[str, Any]] \| None` 默认值: `None`
`deprecated`	将此路径操作标记为已弃用。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型： `bool \| None` 默认值： `None`
`operation_id`	此路径操作使用的自定义操作 ID。默认情况下，它是自动生成的。如果你提供了自定义操作 ID，请确保它在整个 API 中是唯一的。你可以使用 `FastAPI` 类中的 `generate_unique_id_function` 参数自定义操作 ID 的生成。更多信息请阅读 FastAPI 文档：如何生成客户端。类型： `str \| None` 默认值： `None`
`response_model_include`	传递给 Pydantic 的配置，仅在响应数据中包含特定字段。更多信息请阅读 FastAPI 文档：响应模型 - 返回类型。类型: `IncEx \| None` 默认值: `None`
`response_model_exclude`	传递给 Pydantic 的配置，在响应数据中排除特定字段。更多信息请阅读 FastAPI 文档：响应模型 - 返回类型。类型: `IncEx \| None` 默认值: `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)`
`name`	此路径操作的名称。仅在内部使用。类型： `str \| None` 默认值： `None`
`callbacks`	将用作 OpenAPI 回调的路径操作列表。这仅用于 OpenAPI 文档，回调不会被直接使用。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：OpenAPI 回调。类型: `list[BaseRoute] \| None` 默认值: `None`
`openapi_extra`	要包含在此路径操作的 OpenAPI 模式中的额外元数据。更多信息请阅读 FastAPI 文档：路径操作高级配置。类型: `dict[str, Any] \| None` 默认值: `None`
`generate_unique_id_function`	自定义用于为生成的 OpenAPI 中显示的路径操作生成唯一 ID 的函数。这在为 API 自动生成客户端或 SDK 时特别有用。更多信息请阅读 FastAPI 文档：如何生成客户端。类型: `Callable[[APIRoute], str]` 默认值: `Default(generate_unique_id)`

源代码位于 fastapi/routing.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.org.cn/tutorial/response-model/).
            """
        ),
    ] = Default(None),
    status_code: Annotated[
        int | None,
        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.org.cn/tutorial/response-status-code/).
            """
        ),
    ] = None,
    tags: Annotated[
        list[str | Enum] | None,
        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.org.cn/tutorial/path-operation-configuration/#tags).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Sequence[params.Depends] | None,
        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.org.cn/tutorial/dependencies/dependencies-in-path-operation-decorators/).
            """
        ),
    ] = None,
    summary: Annotated[
        str | None,
        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.org.cn/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    description: Annotated[
        str | None,
        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.org.cn/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[
        dict[int | str, dict[str, Any]] | None,
        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[
        bool | None,
        Doc(
            """
            Mark this *path operation* as deprecated.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    operation_id: Annotated[
        str | None,
        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.org.cn/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = None,
    response_model_include: Annotated[
        IncEx | None,
        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.org.cn/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_exclude: Annotated[
        IncEx | None,
        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.org.cn/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.org.cn/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.org.cn/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.org.cn/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.org.cn/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.org.cn/tutorial/query-params-str-validations/#exclude-parameters-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.org.cn/advanced/custom-response/#redirectresponse).
            """
        ),
    ] = Default(JSONResponse),
    name: Annotated[
        str | None,
        Doc(
            """
            Name for this *path operation*. Only used internally.
            """
        ),
    ] = None,
    callbacks: Annotated[
        list[BaseRoute] | None,
        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.org.cn/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    openapi_extra: Annotated[
        dict[str, Any] | None,
        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.org.cn/advanced/path-operation-advanced-configuration/#custom-openapi-path-operation-schema).
            """
        ),
    ] = None,
    generate_unique_id_function: Annotated[
        Callable[[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.org.cn/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 APIRouter, FastAPI
    from pydantic import BaseModel

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

    app = FastAPI()
    router = APIRouter()

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

    app.include_router(router)
    ```
    """
    return self.api_route(
        path=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,
        methods=["PUT"],
        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 APIRouter, FastAPI
from pydantic import BaseModel

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

app = FastAPI()
router = APIRouter()

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

app.include_router(router)

参数	描述
`path`	用于此路径操作的 URL 路径。例如，在 `http://example.com/items` 中，路径是 `/items`。类型: `str`
`response_model`	用于响应的类型。它可以是任何有效的 Pydantic 字段类型。因此，它不一定是 Pydantic 模型，也可以是其他类型，例如 `list`, `dict` 等。它将用于：文档：生成的 OpenAPI（以及 `/docs` 处的 UI）会将其显示为响应（JSON 模式）。序列化：你可以返回一个任意对象，`response_model` 将用于将该对象序列化为对应的 JSON。过滤：发送给客户端的 JSON 只会包含 `response_model` 中定义的字段。如果你返回了一个包含 `password` 属性的对象，但 `response_model` 不包含该字段，那么发送给客户端的 JSON 将不会有 `password`。校验：你返回的任何内容都将使用 `response_model` 进行序列化，根据需要转换任何数据以生成对应的 JSON。但如果对象中的数据无效，则意味着违反了与客户端的契约，这是 API 开发者的错误。因此，FastAPI 将抛出错误并返回 500 错误码（内部服务器错误）。更多信息请阅读 FastAPI 文档：响应模型。类型: `Any` 默认值: `Default(None)`
`status_code`	用于响应的默认状态码。你可以通过直接返回一个响应来覆盖状态码。更多信息请阅读 FastAPI 文档：响应状态码。类型： `int \| None` 默认值： `None`
`tags`	应用于此路径操作的标签列表。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型: `list[str \| Enum] \| None` 默认值: `None`
`dependencies`	应用于此路径操作的依赖项列表（使用 `Depends()`）。更多信息请阅读 FastAPI 文档：路径操作装饰器中的依赖项。类型: `Sequence[Depends] \| None` 默认值: `None`
`summary`	此路径操作的摘要。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型： `str \| None` 默认值： `None`
`description`	此路径操作的描述。如果未提供，它将从路径操作函数的文档字符串中自动提取。它可以包含 Markdown。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型： `str \| None` 默认值： `None`
`response_description`	默认响应的描述。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型: `str` 默认值: `'Successful Response'`
`responses`	此路径操作可能返回的附加响应。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型: `dict[int \| str, dict[str, Any]] \| None` 默认值: `None`
`deprecated`	将此路径操作标记为已弃用。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型： `bool \| None` 默认值： `None`
`operation_id`	此路径操作使用的自定义操作 ID。默认情况下，它是自动生成的。如果你提供了自定义操作 ID，请确保它在整个 API 中是唯一的。你可以使用 `FastAPI` 类中的 `generate_unique_id_function` 参数自定义操作 ID 的生成。更多信息请阅读 FastAPI 文档：如何生成客户端。类型： `str \| None` 默认值： `None`
`response_model_include`	传递给 Pydantic 的配置，仅在响应数据中包含特定字段。更多信息请阅读 FastAPI 文档：响应模型 - 返回类型。类型: `IncEx \| None` 默认值: `None`
`response_model_exclude`	传递给 Pydantic 的配置，在响应数据中排除特定字段。更多信息请阅读 FastAPI 文档：响应模型 - 返回类型。类型: `IncEx \| None` 默认值: `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)`
`name`	此路径操作的名称。仅在内部使用。类型： `str \| None` 默认值： `None`
`callbacks`	将用作 OpenAPI 回调的路径操作列表。这仅用于 OpenAPI 文档，回调不会被直接使用。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：OpenAPI 回调。类型: `list[BaseRoute] \| None` 默认值: `None`
`openapi_extra`	要包含在此路径操作的 OpenAPI 模式中的额外元数据。更多信息请阅读 FastAPI 文档：路径操作高级配置。类型: `dict[str, Any] \| None` 默认值: `None`
`generate_unique_id_function`	自定义用于为生成的 OpenAPI 中显示的路径操作生成唯一 ID 的函数。这在为 API 自动生成客户端或 SDK 时特别有用。更多信息请阅读 FastAPI 文档：如何生成客户端。类型: `Callable[[APIRoute], str]` 默认值: `Default(generate_unique_id)`

源代码位于 fastapi/routing.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.org.cn/tutorial/response-model/).
            """
        ),
    ] = Default(None),
    status_code: Annotated[
        int | None,
        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.org.cn/tutorial/response-status-code/).
            """
        ),
    ] = None,
    tags: Annotated[
        list[str | Enum] | None,
        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.org.cn/tutorial/path-operation-configuration/#tags).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Sequence[params.Depends] | None,
        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.org.cn/tutorial/dependencies/dependencies-in-path-operation-decorators/).
            """
        ),
    ] = None,
    summary: Annotated[
        str | None,
        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.org.cn/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    description: Annotated[
        str | None,
        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.org.cn/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[
        dict[int | str, dict[str, Any]] | None,
        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[
        bool | None,
        Doc(
            """
            Mark this *path operation* as deprecated.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    operation_id: Annotated[
        str | None,
        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.org.cn/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = None,
    response_model_include: Annotated[
        IncEx | None,
        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.org.cn/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_exclude: Annotated[
        IncEx | None,
        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.org.cn/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.org.cn/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.org.cn/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.org.cn/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.org.cn/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.org.cn/tutorial/query-params-str-validations/#exclude-parameters-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.org.cn/advanced/custom-response/#redirectresponse).
            """
        ),
    ] = Default(JSONResponse),
    name: Annotated[
        str | None,
        Doc(
            """
            Name for this *path operation*. Only used internally.
            """
        ),
    ] = None,
    callbacks: Annotated[
        list[BaseRoute] | None,
        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.org.cn/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    openapi_extra: Annotated[
        dict[str, Any] | None,
        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.org.cn/advanced/path-operation-advanced-configuration/#custom-openapi-path-operation-schema).
            """
        ),
    ] = None,
    generate_unique_id_function: Annotated[
        Callable[[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.org.cn/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 APIRouter, FastAPI
    from pydantic import BaseModel

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

    app = FastAPI()
    router = APIRouter()

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

    app.include_router(router)
    ```
    """
    return self.api_route(
        path=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,
        methods=["POST"],
        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 APIRouter, FastAPI

app = FastAPI()
router = APIRouter()

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

app.include_router(router)

参数	描述
`path`	用于此路径操作的 URL 路径。例如，在 `http://example.com/items` 中，路径是 `/items`。类型: `str`
`response_model`	用于响应的类型。它可以是任何有效的 Pydantic 字段类型。因此，它不一定是 Pydantic 模型，也可以是其他类型，例如 `list`, `dict` 等。它将用于：文档：生成的 OpenAPI（以及 `/docs` 处的 UI）会将其显示为响应（JSON 模式）。序列化：你可以返回一个任意对象，`response_model` 将用于将该对象序列化为对应的 JSON。过滤：发送给客户端的 JSON 只会包含 `response_model` 中定义的字段。如果你返回了一个包含 `password` 属性的对象，但 `response_model` 不包含该字段，那么发送给客户端的 JSON 将不会有 `password`。校验：你返回的任何内容都将使用 `response_model` 进行序列化，根据需要转换任何数据以生成对应的 JSON。但如果对象中的数据无效，则意味着违反了与客户端的契约，这是 API 开发者的错误。因此，FastAPI 将抛出错误并返回 500 错误码（内部服务器错误）。更多信息请阅读 FastAPI 文档：响应模型。类型: `Any` 默认值: `Default(None)`
`status_code`	用于响应的默认状态码。你可以通过直接返回一个响应来覆盖状态码。更多信息请阅读 FastAPI 文档：响应状态码。类型： `int \| None` 默认值： `None`
`tags`	应用于此路径操作的标签列表。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型: `list[str \| Enum] \| None` 默认值: `None`
`dependencies`	应用于此路径操作的依赖项列表（使用 `Depends()`）。更多信息请阅读 FastAPI 文档：路径操作装饰器中的依赖项。类型: `Sequence[Depends] \| None` 默认值: `None`
`summary`	此路径操作的摘要。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型： `str \| None` 默认值： `None`
`description`	此路径操作的描述。如果未提供，它将从路径操作函数的文档字符串中自动提取。它可以包含 Markdown。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型： `str \| None` 默认值： `None`
`response_description`	默认响应的描述。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型: `str` 默认值: `'Successful Response'`
`responses`	此路径操作可能返回的附加响应。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型: `dict[int \| str, dict[str, Any]] \| None` 默认值: `None`
`deprecated`	将此路径操作标记为已弃用。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型： `bool \| None` 默认值： `None`
`operation_id`	此路径操作使用的自定义操作 ID。默认情况下，它是自动生成的。如果你提供了自定义操作 ID，请确保它在整个 API 中是唯一的。你可以使用 `FastAPI` 类中的 `generate_unique_id_function` 参数自定义操作 ID 的生成。更多信息请阅读 FastAPI 文档：如何生成客户端。类型： `str \| None` 默认值： `None`
`response_model_include`	传递给 Pydantic 的配置，仅在响应数据中包含特定字段。更多信息请阅读 FastAPI 文档：响应模型 - 返回类型。类型: `IncEx \| None` 默认值: `None`
`response_model_exclude`	传递给 Pydantic 的配置，在响应数据中排除特定字段。更多信息请阅读 FastAPI 文档：响应模型 - 返回类型。类型: `IncEx \| None` 默认值: `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)`
`name`	此路径操作的名称。仅在内部使用。类型： `str \| None` 默认值： `None`
`callbacks`	将用作 OpenAPI 回调的路径操作列表。这仅用于 OpenAPI 文档，回调不会被直接使用。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：OpenAPI 回调。类型: `list[BaseRoute] \| None` 默认值: `None`
`openapi_extra`	要包含在此路径操作的 OpenAPI 模式中的额外元数据。更多信息请阅读 FastAPI 文档：路径操作高级配置。类型: `dict[str, Any] \| None` 默认值: `None`
`generate_unique_id_function`	自定义用于为生成的 OpenAPI 中显示的路径操作生成唯一 ID 的函数。这在为 API 自动生成客户端或 SDK 时特别有用。更多信息请阅读 FastAPI 文档：如何生成客户端。类型: `Callable[[APIRoute], str]` 默认值: `Default(generate_unique_id)`

源代码位于 fastapi/routing.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.org.cn/tutorial/response-model/).
            """
        ),
    ] = Default(None),
    status_code: Annotated[
        int | None,
        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.org.cn/tutorial/response-status-code/).
            """
        ),
    ] = None,
    tags: Annotated[
        list[str | Enum] | None,
        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.org.cn/tutorial/path-operation-configuration/#tags).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Sequence[params.Depends] | None,
        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.org.cn/tutorial/dependencies/dependencies-in-path-operation-decorators/).
            """
        ),
    ] = None,
    summary: Annotated[
        str | None,
        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.org.cn/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    description: Annotated[
        str | None,
        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.org.cn/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[
        dict[int | str, dict[str, Any]] | None,
        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[
        bool | None,
        Doc(
            """
            Mark this *path operation* as deprecated.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    operation_id: Annotated[
        str | None,
        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.org.cn/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = None,
    response_model_include: Annotated[
        IncEx | None,
        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.org.cn/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_exclude: Annotated[
        IncEx | None,
        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.org.cn/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.org.cn/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.org.cn/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.org.cn/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.org.cn/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.org.cn/tutorial/query-params-str-validations/#exclude-parameters-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.org.cn/advanced/custom-response/#redirectresponse).
            """
        ),
    ] = Default(JSONResponse),
    name: Annotated[
        str | None,
        Doc(
            """
            Name for this *path operation*. Only used internally.
            """
        ),
    ] = None,
    callbacks: Annotated[
        list[BaseRoute] | None,
        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.org.cn/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    openapi_extra: Annotated[
        dict[str, Any] | None,
        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.org.cn/advanced/path-operation-advanced-configuration/#custom-openapi-path-operation-schema).
            """
        ),
    ] = None,
    generate_unique_id_function: Annotated[
        Callable[[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.org.cn/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 APIRouter, FastAPI

    app = FastAPI()
    router = APIRouter()

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

    app.include_router(router)
    ```
    """
    return self.api_route(
        path=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,
        methods=["DELETE"],
        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 APIRouter, FastAPI

app = FastAPI()
router = APIRouter()

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

app.include_router(router)

参数	描述
`path`	用于此路径操作的 URL 路径。例如，在 `http://example.com/items` 中，路径是 `/items`。类型: `str`
`response_model`	用于响应的类型。它可以是任何有效的 Pydantic 字段类型。因此，它不一定是 Pydantic 模型，也可以是其他类型，例如 `list`, `dict` 等。它将用于：文档：生成的 OpenAPI（以及 `/docs` 处的 UI）会将其显示为响应（JSON 模式）。序列化：你可以返回一个任意对象，`response_model` 将用于将该对象序列化为对应的 JSON。过滤：发送给客户端的 JSON 只会包含 `response_model` 中定义的字段。如果你返回了一个包含 `password` 属性的对象，但 `response_model` 不包含该字段，那么发送给客户端的 JSON 将不会有 `password`。校验：你返回的任何内容都将使用 `response_model` 进行序列化，根据需要转换任何数据以生成对应的 JSON。但如果对象中的数据无效，则意味着违反了与客户端的契约，这是 API 开发者的错误。因此，FastAPI 将抛出错误并返回 500 错误码（内部服务器错误）。更多信息请阅读 FastAPI 文档：响应模型。类型: `Any` 默认值: `Default(None)`
`status_code`	用于响应的默认状态码。你可以通过直接返回一个响应来覆盖状态码。更多信息请阅读 FastAPI 文档：响应状态码。类型： `int \| None` 默认值： `None`
`tags`	应用于此路径操作的标签列表。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型: `list[str \| Enum] \| None` 默认值: `None`
`dependencies`	应用于此路径操作的依赖项列表（使用 `Depends()`）。更多信息请阅读 FastAPI 文档：路径操作装饰器中的依赖项。类型: `Sequence[Depends] \| None` 默认值: `None`
`summary`	此路径操作的摘要。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型： `str \| None` 默认值： `None`
`description`	此路径操作的描述。如果未提供，它将从路径操作函数的文档字符串中自动提取。它可以包含 Markdown。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型： `str \| None` 默认值： `None`
`response_description`	默认响应的描述。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型: `str` 默认值: `'Successful Response'`
`responses`	此路径操作可能返回的附加响应。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型: `dict[int \| str, dict[str, Any]] \| None` 默认值: `None`
`deprecated`	将此路径操作标记为已弃用。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型： `bool \| None` 默认值： `None`
`operation_id`	此路径操作使用的自定义操作 ID。默认情况下，它是自动生成的。如果你提供了自定义操作 ID，请确保它在整个 API 中是唯一的。你可以使用 `FastAPI` 类中的 `generate_unique_id_function` 参数自定义操作 ID 的生成。更多信息请阅读 FastAPI 文档：如何生成客户端。类型： `str \| None` 默认值： `None`
`response_model_include`	传递给 Pydantic 的配置，仅在响应数据中包含特定字段。更多信息请阅读 FastAPI 文档：响应模型 - 返回类型。类型: `IncEx \| None` 默认值: `None`
`response_model_exclude`	传递给 Pydantic 的配置，在响应数据中排除特定字段。更多信息请阅读 FastAPI 文档：响应模型 - 返回类型。类型: `IncEx \| None` 默认值: `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)`
`name`	此路径操作的名称。仅在内部使用。类型： `str \| None` 默认值： `None`
`callbacks`	将用作 OpenAPI 回调的路径操作列表。这仅用于 OpenAPI 文档，回调不会被直接使用。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：OpenAPI 回调。类型: `list[BaseRoute] \| None` 默认值: `None`
`openapi_extra`	要包含在此路径操作的 OpenAPI 模式中的额外元数据。更多信息请阅读 FastAPI 文档：路径操作高级配置。类型: `dict[str, Any] \| None` 默认值: `None`
`generate_unique_id_function`	自定义用于为生成的 OpenAPI 中显示的路径操作生成唯一 ID 的函数。这在为 API 自动生成客户端或 SDK 时特别有用。更多信息请阅读 FastAPI 文档：如何生成客户端。类型: `Callable[[APIRoute], str]` 默认值: `Default(generate_unique_id)`

源代码位于 fastapi/routing.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.org.cn/tutorial/response-model/).
            """
        ),
    ] = Default(None),
    status_code: Annotated[
        int | None,
        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.org.cn/tutorial/response-status-code/).
            """
        ),
    ] = None,
    tags: Annotated[
        list[str | Enum] | None,
        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.org.cn/tutorial/path-operation-configuration/#tags).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Sequence[params.Depends] | None,
        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.org.cn/tutorial/dependencies/dependencies-in-path-operation-decorators/).
            """
        ),
    ] = None,
    summary: Annotated[
        str | None,
        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.org.cn/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    description: Annotated[
        str | None,
        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.org.cn/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[
        dict[int | str, dict[str, Any]] | None,
        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[
        bool | None,
        Doc(
            """
            Mark this *path operation* as deprecated.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    operation_id: Annotated[
        str | None,
        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.org.cn/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = None,
    response_model_include: Annotated[
        IncEx | None,
        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.org.cn/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_exclude: Annotated[
        IncEx | None,
        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.org.cn/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.org.cn/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.org.cn/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.org.cn/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.org.cn/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.org.cn/tutorial/query-params-str-validations/#exclude-parameters-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.org.cn/advanced/custom-response/#redirectresponse).
            """
        ),
    ] = Default(JSONResponse),
    name: Annotated[
        str | None,
        Doc(
            """
            Name for this *path operation*. Only used internally.
            """
        ),
    ] = None,
    callbacks: Annotated[
        list[BaseRoute] | None,
        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.org.cn/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    openapi_extra: Annotated[
        dict[str, Any] | None,
        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.org.cn/advanced/path-operation-advanced-configuration/#custom-openapi-path-operation-schema).
            """
        ),
    ] = None,
    generate_unique_id_function: Annotated[
        Callable[[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.org.cn/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 APIRouter, FastAPI

    app = FastAPI()
    router = APIRouter()

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

    app.include_router(router)
    ```
    """
    return self.api_route(
        path=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,
        methods=["OPTIONS"],
        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 APIRouter, FastAPI
from pydantic import BaseModel

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

app = FastAPI()
router = APIRouter()

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

app.include_router(router)

参数	描述
`path`	用于此路径操作的 URL 路径。例如，在 `http://example.com/items` 中，路径是 `/items`。类型: `str`
`response_model`	用于响应的类型。它可以是任何有效的 Pydantic 字段类型。因此，它不一定是 Pydantic 模型，也可以是其他类型，例如 `list`, `dict` 等。它将用于：文档：生成的 OpenAPI（以及 `/docs` 处的 UI）会将其显示为响应（JSON 模式）。序列化：你可以返回一个任意对象，`response_model` 将用于将该对象序列化为对应的 JSON。过滤：发送给客户端的 JSON 只会包含 `response_model` 中定义的字段。如果你返回了一个包含 `password` 属性的对象，但 `response_model` 不包含该字段，那么发送给客户端的 JSON 将不会有 `password`。校验：你返回的任何内容都将使用 `response_model` 进行序列化，根据需要转换任何数据以生成对应的 JSON。但如果对象中的数据无效，则意味着违反了与客户端的契约，这是 API 开发者的错误。因此，FastAPI 将抛出错误并返回 500 错误码（内部服务器错误）。更多信息请阅读 FastAPI 文档：响应模型。类型: `Any` 默认值: `Default(None)`
`status_code`	用于响应的默认状态码。你可以通过直接返回一个响应来覆盖状态码。更多信息请阅读 FastAPI 文档：响应状态码。类型： `int \| None` 默认值： `None`
`tags`	应用于此路径操作的标签列表。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型: `list[str \| Enum] \| None` 默认值: `None`
`dependencies`	应用于此路径操作的依赖项列表（使用 `Depends()`）。更多信息请阅读 FastAPI 文档：路径操作装饰器中的依赖项。类型: `Sequence[Depends] \| None` 默认值: `None`
`summary`	此路径操作的摘要。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型： `str \| None` 默认值： `None`
`description`	此路径操作的描述。如果未提供，它将从路径操作函数的文档字符串中自动提取。它可以包含 Markdown。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型： `str \| None` 默认值： `None`
`response_description`	默认响应的描述。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型: `str` 默认值: `'Successful Response'`
`responses`	此路径操作可能返回的附加响应。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型: `dict[int \| str, dict[str, Any]] \| None` 默认值: `None`
`deprecated`	将此路径操作标记为已弃用。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型： `bool \| None` 默认值： `None`
`operation_id`	此路径操作使用的自定义操作 ID。默认情况下，它是自动生成的。如果你提供了自定义操作 ID，请确保它在整个 API 中是唯一的。你可以使用 `FastAPI` 类中的 `generate_unique_id_function` 参数自定义操作 ID 的生成。更多信息请阅读 FastAPI 文档：如何生成客户端。类型： `str \| None` 默认值： `None`
`response_model_include`	传递给 Pydantic 的配置，仅在响应数据中包含特定字段。更多信息请阅读 FastAPI 文档：响应模型 - 返回类型。类型: `IncEx \| None` 默认值: `None`
`response_model_exclude`	传递给 Pydantic 的配置，在响应数据中排除特定字段。更多信息请阅读 FastAPI 文档：响应模型 - 返回类型。类型: `IncEx \| None` 默认值: `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)`
`name`	此路径操作的名称。仅在内部使用。类型： `str \| None` 默认值： `None`
`callbacks`	将用作 OpenAPI 回调的路径操作列表。这仅用于 OpenAPI 文档，回调不会被直接使用。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：OpenAPI 回调。类型: `list[BaseRoute] \| None` 默认值: `None`
`openapi_extra`	要包含在此路径操作的 OpenAPI 模式中的额外元数据。更多信息请阅读 FastAPI 文档：路径操作高级配置。类型: `dict[str, Any] \| None` 默认值: `None`
`generate_unique_id_function`	自定义用于为生成的 OpenAPI 中显示的路径操作生成唯一 ID 的函数。这在为 API 自动生成客户端或 SDK 时特别有用。更多信息请阅读 FastAPI 文档：如何生成客户端。类型: `Callable[[APIRoute], str]` 默认值: `Default(generate_unique_id)`

源代码位于 fastapi/routing.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.org.cn/tutorial/response-model/).
            """
        ),
    ] = Default(None),
    status_code: Annotated[
        int | None,
        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.org.cn/tutorial/response-status-code/).
            """
        ),
    ] = None,
    tags: Annotated[
        list[str | Enum] | None,
        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.org.cn/tutorial/path-operation-configuration/#tags).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Sequence[params.Depends] | None,
        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.org.cn/tutorial/dependencies/dependencies-in-path-operation-decorators/).
            """
        ),
    ] = None,
    summary: Annotated[
        str | None,
        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.org.cn/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    description: Annotated[
        str | None,
        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.org.cn/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[
        dict[int | str, dict[str, Any]] | None,
        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[
        bool | None,
        Doc(
            """
            Mark this *path operation* as deprecated.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    operation_id: Annotated[
        str | None,
        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.org.cn/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = None,
    response_model_include: Annotated[
        IncEx | None,
        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.org.cn/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_exclude: Annotated[
        IncEx | None,
        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.org.cn/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.org.cn/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.org.cn/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.org.cn/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.org.cn/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.org.cn/tutorial/query-params-str-validations/#exclude-parameters-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.org.cn/advanced/custom-response/#redirectresponse).
            """
        ),
    ] = Default(JSONResponse),
    name: Annotated[
        str | None,
        Doc(
            """
            Name for this *path operation*. Only used internally.
            """
        ),
    ] = None,
    callbacks: Annotated[
        list[BaseRoute] | None,
        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.org.cn/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    openapi_extra: Annotated[
        dict[str, Any] | None,
        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.org.cn/advanced/path-operation-advanced-configuration/#custom-openapi-path-operation-schema).
            """
        ),
    ] = None,
    generate_unique_id_function: Annotated[
        Callable[[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.org.cn/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 APIRouter, FastAPI
    from pydantic import BaseModel

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

    app = FastAPI()
    router = APIRouter()

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

    app.include_router(router)
    ```
    """
    return self.api_route(
        path=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,
        methods=["HEAD"],
        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 APIRouter, FastAPI
from pydantic import BaseModel

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

app = FastAPI()
router = APIRouter()

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

app.include_router(router)

参数	描述
`path`	用于此路径操作的 URL 路径。例如，在 `http://example.com/items` 中，路径是 `/items`。类型: `str`
`response_model`	用于响应的类型。它可以是任何有效的 Pydantic 字段类型。因此，它不一定是 Pydantic 模型，也可以是其他类型，例如 `list`, `dict` 等。它将用于：文档：生成的 OpenAPI（以及 `/docs` 处的 UI）会将其显示为响应（JSON 模式）。序列化：你可以返回一个任意对象，`response_model` 将用于将该对象序列化为对应的 JSON。过滤：发送给客户端的 JSON 只会包含 `response_model` 中定义的字段。如果你返回了一个包含 `password` 属性的对象，但 `response_model` 不包含该字段，那么发送给客户端的 JSON 将不会有 `password`。校验：你返回的任何内容都将使用 `response_model` 进行序列化，根据需要转换任何数据以生成对应的 JSON。但如果对象中的数据无效，则意味着违反了与客户端的契约，这是 API 开发者的错误。因此，FastAPI 将抛出错误并返回 500 错误码（内部服务器错误）。更多信息请阅读 FastAPI 文档：响应模型。类型: `Any` 默认值: `Default(None)`
`status_code`	用于响应的默认状态码。你可以通过直接返回一个响应来覆盖状态码。更多信息请阅读 FastAPI 文档：响应状态码。类型： `int \| None` 默认值： `None`
`tags`	应用于此路径操作的标签列表。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型: `list[str \| Enum] \| None` 默认值: `None`
`dependencies`	应用于此路径操作的依赖项列表（使用 `Depends()`）。更多信息请阅读 FastAPI 文档：路径操作装饰器中的依赖项。类型: `Sequence[Depends] \| None` 默认值: `None`
`summary`	此路径操作的摘要。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型： `str \| None` 默认值： `None`
`description`	此路径操作的描述。如果未提供，它将从路径操作函数的文档字符串中自动提取。它可以包含 Markdown。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型： `str \| None` 默认值： `None`
`response_description`	默认响应的描述。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型: `str` 默认值: `'Successful Response'`
`responses`	此路径操作可能返回的附加响应。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型: `dict[int \| str, dict[str, Any]] \| None` 默认值: `None`
`deprecated`	将此路径操作标记为已弃用。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型： `bool \| None` 默认值： `None`
`operation_id`	此路径操作使用的自定义操作 ID。默认情况下，它是自动生成的。如果你提供了自定义操作 ID，请确保它在整个 API 中是唯一的。你可以使用 `FastAPI` 类中的 `generate_unique_id_function` 参数自定义操作 ID 的生成。更多信息请阅读 FastAPI 文档：如何生成客户端。类型： `str \| None` 默认值： `None`
`response_model_include`	传递给 Pydantic 的配置，仅在响应数据中包含特定字段。更多信息请阅读 FastAPI 文档：响应模型 - 返回类型。类型: `IncEx \| None` 默认值: `None`
`response_model_exclude`	传递给 Pydantic 的配置，在响应数据中排除特定字段。更多信息请阅读 FastAPI 文档：响应模型 - 返回类型。类型: `IncEx \| None` 默认值: `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)`
`name`	此路径操作的名称。仅在内部使用。类型： `str \| None` 默认值： `None`
`callbacks`	将用作 OpenAPI 回调的路径操作列表。这仅用于 OpenAPI 文档，回调不会被直接使用。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：OpenAPI 回调。类型: `list[BaseRoute] \| None` 默认值: `None`
`openapi_extra`	要包含在此路径操作的 OpenAPI 模式中的额外元数据。更多信息请阅读 FastAPI 文档：路径操作高级配置。类型: `dict[str, Any] \| None` 默认值: `None`
`generate_unique_id_function`	自定义用于为生成的 OpenAPI 中显示的路径操作生成唯一 ID 的函数。这在为 API 自动生成客户端或 SDK 时特别有用。更多信息请阅读 FastAPI 文档：如何生成客户端。类型: `Callable[[APIRoute], str]` 默认值: `Default(generate_unique_id)`

源代码位于 fastapi/routing.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.org.cn/tutorial/response-model/).
            """
        ),
    ] = Default(None),
    status_code: Annotated[
        int | None,
        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.org.cn/tutorial/response-status-code/).
            """
        ),
    ] = None,
    tags: Annotated[
        list[str | Enum] | None,
        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.org.cn/tutorial/path-operation-configuration/#tags).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Sequence[params.Depends] | None,
        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.org.cn/tutorial/dependencies/dependencies-in-path-operation-decorators/).
            """
        ),
    ] = None,
    summary: Annotated[
        str | None,
        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.org.cn/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    description: Annotated[
        str | None,
        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.org.cn/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[
        dict[int | str, dict[str, Any]] | None,
        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[
        bool | None,
        Doc(
            """
            Mark this *path operation* as deprecated.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    operation_id: Annotated[
        str | None,
        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.org.cn/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = None,
    response_model_include: Annotated[
        IncEx | None,
        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.org.cn/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_exclude: Annotated[
        IncEx | None,
        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.org.cn/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.org.cn/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.org.cn/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.org.cn/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.org.cn/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.org.cn/tutorial/query-params-str-validations/#exclude-parameters-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.org.cn/advanced/custom-response/#redirectresponse).
            """
        ),
    ] = Default(JSONResponse),
    name: Annotated[
        str | None,
        Doc(
            """
            Name for this *path operation*. Only used internally.
            """
        ),
    ] = None,
    callbacks: Annotated[
        list[BaseRoute] | None,
        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.org.cn/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    openapi_extra: Annotated[
        dict[str, Any] | None,
        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.org.cn/advanced/path-operation-advanced-configuration/#custom-openapi-path-operation-schema).
            """
        ),
    ] = None,
    generate_unique_id_function: Annotated[
        Callable[[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.org.cn/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 APIRouter, FastAPI
    from pydantic import BaseModel

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

    app = FastAPI()
    router = APIRouter()

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

    app.include_router(router)
    ```
    """
    return self.api_route(
        path=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,
        methods=["PATCH"],
        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 APIRouter, FastAPI
from pydantic import BaseModel

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

app = FastAPI()
router = APIRouter()

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

app.include_router(router)

参数	描述
`path`	用于此路径操作的 URL 路径。例如，在 `http://example.com/items` 中，路径是 `/items`。类型: `str`
`response_model`	用于响应的类型。它可以是任何有效的 Pydantic 字段类型。因此，它不一定是 Pydantic 模型，也可以是其他类型，例如 `list`, `dict` 等。它将用于：文档：生成的 OpenAPI（以及 `/docs` 处的 UI）会将其显示为响应（JSON 模式）。序列化：你可以返回一个任意对象，`response_model` 将用于将该对象序列化为对应的 JSON。过滤：发送给客户端的 JSON 只会包含 `response_model` 中定义的字段。如果你返回了一个包含 `password` 属性的对象，但 `response_model` 不包含该字段，那么发送给客户端的 JSON 将不会有 `password`。校验：你返回的任何内容都将使用 `response_model` 进行序列化，根据需要转换任何数据以生成对应的 JSON。但如果对象中的数据无效，则意味着违反了与客户端的契约，这是 API 开发者的错误。因此，FastAPI 将抛出错误并返回 500 错误码（内部服务器错误）。更多信息请阅读 FastAPI 文档：响应模型。类型: `Any` 默认值: `Default(None)`
`status_code`	用于响应的默认状态码。你可以通过直接返回一个响应来覆盖状态码。更多信息请阅读 FastAPI 文档：响应状态码。类型： `int \| None` 默认值： `None`
`tags`	应用于此路径操作的标签列表。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型: `list[str \| Enum] \| None` 默认值: `None`
`dependencies`	应用于此路径操作的依赖项列表（使用 `Depends()`）。更多信息请阅读 FastAPI 文档：路径操作装饰器中的依赖项。类型: `Sequence[Depends] \| None` 默认值: `None`
`summary`	此路径操作的摘要。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型： `str \| None` 默认值： `None`
`description`	此路径操作的描述。如果未提供，它将从路径操作函数的文档字符串中自动提取。它可以包含 Markdown。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：路径操作配置。类型： `str \| None` 默认值： `None`
`response_description`	默认响应的描述。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型: `str` 默认值: `'Successful Response'`
`responses`	此路径操作可能返回的附加响应。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型: `dict[int \| str, dict[str, Any]] \| None` 默认值: `None`
`deprecated`	将此路径操作标记为已弃用。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。类型： `bool \| None` 默认值： `None`
`operation_id`	此路径操作使用的自定义操作 ID。默认情况下，它是自动生成的。如果你提供了自定义操作 ID，请确保它在整个 API 中是唯一的。你可以使用 `FastAPI` 类中的 `generate_unique_id_function` 参数自定义操作 ID 的生成。更多信息请阅读 FastAPI 文档：如何生成客户端。类型： `str \| None` 默认值： `None`
`response_model_include`	传递给 Pydantic 的配置，仅在响应数据中包含特定字段。更多信息请阅读 FastAPI 文档：响应模型 - 返回类型。类型: `IncEx \| None` 默认值: `None`
`response_model_exclude`	传递给 Pydantic 的配置，在响应数据中排除特定字段。更多信息请阅读 FastAPI 文档：响应模型 - 返回类型。类型: `IncEx \| None` 默认值: `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)`
`name`	此路径操作的名称。仅在内部使用。类型： `str \| None` 默认值： `None`
`callbacks`	将用作 OpenAPI 回调的路径操作列表。这仅用于 OpenAPI 文档，回调不会被直接使用。它将被添加到生成的 OpenAPI (例如在 `/docs` 中可见)。更多信息请阅读 FastAPI 文档：OpenAPI 回调。类型: `list[BaseRoute] \| None` 默认值: `None`
`openapi_extra`	要包含在此路径操作的 OpenAPI 模式中的额外元数据。更多信息请阅读 FastAPI 文档：路径操作高级配置。类型: `dict[str, Any] \| None` 默认值: `None`
`generate_unique_id_function`	自定义用于为生成的 OpenAPI 中显示的路径操作生成唯一 ID 的函数。这在为 API 自动生成客户端或 SDK 时特别有用。更多信息请阅读 FastAPI 文档：如何生成客户端。类型: `Callable[[APIRoute], str]` 默认值: `Default(generate_unique_id)`

源代码位于 fastapi/routing.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.org.cn/tutorial/response-model/).
            """
        ),
    ] = Default(None),
    status_code: Annotated[
        int | None,
        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.org.cn/tutorial/response-status-code/).
            """
        ),
    ] = None,
    tags: Annotated[
        list[str | Enum] | None,
        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.org.cn/tutorial/path-operation-configuration/#tags).
            """
        ),
    ] = None,
    dependencies: Annotated[
        Sequence[params.Depends] | None,
        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.org.cn/tutorial/dependencies/dependencies-in-path-operation-decorators/).
            """
        ),
    ] = None,
    summary: Annotated[
        str | None,
        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.org.cn/tutorial/path-operation-configuration/).
            """
        ),
    ] = None,
    description: Annotated[
        str | None,
        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.org.cn/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[
        dict[int | str, dict[str, Any]] | None,
        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[
        bool | None,
        Doc(
            """
            Mark this *path operation* as deprecated.

            It will be added to the generated OpenAPI (e.g. visible at `/docs`).
            """
        ),
    ] = None,
    operation_id: Annotated[
        str | None,
        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.org.cn/advanced/generate-clients/#custom-generate-unique-id-function).
            """
        ),
    ] = None,
    response_model_include: Annotated[
        IncEx | None,
        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.org.cn/tutorial/response-model/#response_model_include-and-response_model_exclude).
            """
        ),
    ] = None,
    response_model_exclude: Annotated[
        IncEx | None,
        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.org.cn/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.org.cn/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.org.cn/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.org.cn/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.org.cn/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.org.cn/tutorial/query-params-str-validations/#exclude-parameters-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.org.cn/advanced/custom-response/#redirectresponse).
            """
        ),
    ] = Default(JSONResponse),
    name: Annotated[
        str | None,
        Doc(
            """
            Name for this *path operation*. Only used internally.
            """
        ),
    ] = None,
    callbacks: Annotated[
        list[BaseRoute] | None,
        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.org.cn/advanced/openapi-callbacks/).
            """
        ),
    ] = None,
    openapi_extra: Annotated[
        dict[str, Any] | None,
        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.org.cn/advanced/path-operation-advanced-configuration/#custom-openapi-path-operation-schema).
            """
        ),
    ] = None,
    generate_unique_id_function: Annotated[
        Callable[[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.org.cn/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 APIRouter, FastAPI
    from pydantic import BaseModel

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

    app = FastAPI()
    router = APIRouter()

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

    app.include_router(router)
    ```
    """
    return self.api_route(
        path=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,
        methods=["TRACE"],
        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/routing.py

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

    Read more about it in the
    [FastAPI docs for Lifespan Events](https://fastapi.org.cn/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 router.

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

    Read more about it in the
    [FastAPI docs for Lifespan Events](https://fastapi.org.cn/advanced/events/#alternative-events-deprecated).
    """

    def decorator(func: DecoratedCallable) -> DecoratedCallable:
        self.add_event_handler(event_type, func)
        return func

    return decorator

APIRouter 类¶

fastapi.APIRouter ¶

示例¶

websocket ¶

示例¶

include_router ¶

示例¶

get ¶

示例¶

put ¶

示例¶

post ¶

示例¶

delete ¶

示例¶

options ¶

示例¶

head ¶

示例¶

patch ¶

示例¶

trace ¶

示例¶

on_event ¶

`APIRouter` 类¶