额外模型¶

继续之前的示例，通常会有多个相关模型。

对于用户模型尤其如此，因为

输入模型需要能够包含密码。
输出模型不应包含密码。
数据库模型可能需要包含哈希密码。

危险

切勿存储用户的明文密码。始终存储一个“安全哈希”，然后您可以对其进行验证。

如果您不知道，您将在安全章节中学习什么是“密码哈希”。

多个模型¶

以下是模型及其密码字段以及它们用例的总体思路

Python 3.10+

from fastapi import FastAPI
from pydantic import BaseModel, EmailStr

app = FastAPI()


class UserIn(BaseModel):
    username: str
    password: str
    email: EmailStr
    full_name: str | None = None


class UserOut(BaseModel):
    username: str
    email: EmailStr
    full_name: str | None = None


class UserInDB(BaseModel):
    username: str
    hashed_password: str
    email: EmailStr
    full_name: str | None = None


def fake_password_hasher(raw_password: str):
    return "supersecret" + raw_password


def fake_save_user(user_in: UserIn):
    hashed_password = fake_password_hasher(user_in.password)
    user_in_db = UserInDB(**user_in.dict(), hashed_password=hashed_password)
    print("User saved! ..not really")
    return user_in_db


@app.post("/user/", response_model=UserOut)
async def create_user(user_in: UserIn):
    user_saved = fake_save_user(user_in)
    return user_saved

🤓 其他版本和变体

Python 3.8+

from typing import Union

from fastapi import FastAPI
from pydantic import BaseModel, EmailStr

app = FastAPI()


class UserIn(BaseModel):
    username: str
    password: str
    email: EmailStr
    full_name: Union[str, None] = None


class UserOut(BaseModel):
    username: str
    email: EmailStr
    full_name: Union[str, None] = None


class UserInDB(BaseModel):
    username: str
    hashed_password: str
    email: EmailStr
    full_name: Union[str, None] = None


def fake_password_hasher(raw_password: str):
    return "supersecret" + raw_password


def fake_save_user(user_in: UserIn):
    hashed_password = fake_password_hasher(user_in.password)
    user_in_db = UserInDB(**user_in.dict(), hashed_password=hashed_password)
    print("User saved! ..not really")
    return user_in_db


@app.post("/user/", response_model=UserOut)
async def create_user(user_in: UserIn):
    user_saved = fake_save_user(user_in)
    return user_saved

信息

在 Pydantic v1 中，该方法名为 .dict()，在 Pydantic v2 中已弃用（但仍受支持），并更名为 .model_dump()。

这里的示例使用 .dict() 以兼容 Pydantic v1，但如果您可以使用 Pydantic v2，则应改用 .model_dump()。

关于 `**user_in.dict()`¶

Pydantic 的 `.dict()`¶

user_in 是 UserIn 类的 Pydantic 模型。

Pydantic 模型有一个 .dict() 方法，它返回一个包含模型数据的 dict。

因此，如果我们像这样创建一个 Pydantic 对象 user_in

user_in = UserIn(username="john", password="secret", email="john.doe@example.com")

然后我们调用

user_dict = user_in.dict()

我们现在在变量 user_dict 中有一个包含数据的 dict（它是一个 dict 而不是 Pydantic 模型对象）。

如果我们调用

print(user_dict)

我们会得到一个 Python dict，其中包含

{
    'username': 'john',
    'password': 'secret',
    'email': 'john.doe@example.com',
    'full_name': None,
}

解包 `dict`¶

如果我们获取一个像 user_dict 这样的 dict 并将其与 **user_dict 一起传递给函数（或类），Python 将“解包”它。它将 user_dict 的键和值直接作为键值参数传递。

因此，继续使用上面提到的 user_dict，写入

UserInDB(**user_dict)

将得到与以下内容等效的结果

UserInDB(
    username="john",
    password="secret",
    email="john.doe@example.com",
    full_name=None,
)

更准确地说，直接使用 user_dict，无论它将来可能包含什么内容

UserInDB(
    username = user_dict["username"],
    password = user_dict["password"],
    email = user_dict["email"],
    full_name = user_dict["full_name"],
)

从另一个模型的内容创建 Pydantic 模型¶

正如上面的示例中，我们从 user_in.dict() 获得了 user_dict，这段代码

user_dict = user_in.dict()
UserInDB(**user_dict)

将等同于

UserInDB(**user_in.dict())

...因为 user_in.dict() 是一个 dict，然后我们通过在它前面加上 ** 将其传递给 UserInDB，使 Python "解包"它。

因此，我们从另一个 Pydantic 模型中的数据获取了一个 Pydantic 模型。

解包 `dict` 和额外关键字¶

然后添加额外的关键字参数 hashed_password=hashed_password，就像这样

UserInDB(**user_in.dict(), hashed_password=hashed_password)

...最终结果是

UserInDB(
    username = user_dict["username"],
    password = user_dict["password"],
    email = user_dict["email"],
    full_name = user_dict["full_name"],
    hashed_password = hashed_password,
)

警告

支持的额外函数 fake_password_hasher 和 fake_save_user 仅用于演示可能的数据流，但它们当然不提供任何真正的安全性。

减少重复¶

减少代码重复是 FastAPI 的核心思想之一。

因为代码重复会增加 bug、安全问题、代码不同步问题（当您在一个地方更新而不在其他地方更新时）等的可能性。

而且这些模型都共享大量数据并重复属性名称和类型。

我们可以做得更好。

我们可以声明一个 UserBase 模型作为其他模型的基础。然后我们可以创建该模型的子类，它们继承其属性（类型声明、验证等）。

所有数据转换、验证、文档等都将正常工作。

这样，我们只需声明模型之间的差异（带明文 password、带 hashed_password 和不带密码）

Python 3.10+

from fastapi import FastAPI
from pydantic import BaseModel, EmailStr

app = FastAPI()


class UserBase(BaseModel):
    username: str
    email: EmailStr
    full_name: str | None = None


class UserIn(UserBase):
    password: str


class UserOut(UserBase):
    pass


class UserInDB(UserBase):
    hashed_password: str


def fake_password_hasher(raw_password: str):
    return "supersecret" + raw_password


def fake_save_user(user_in: UserIn):
    hashed_password = fake_password_hasher(user_in.password)
    user_in_db = UserInDB(**user_in.dict(), hashed_password=hashed_password)
    print("User saved! ..not really")
    return user_in_db


@app.post("/user/", response_model=UserOut)
async def create_user(user_in: UserIn):
    user_saved = fake_save_user(user_in)
    return user_saved

🤓 其他版本和变体

Python 3.8+

from typing import Union

from fastapi import FastAPI
from pydantic import BaseModel, EmailStr

app = FastAPI()


class UserBase(BaseModel):
    username: str
    email: EmailStr
    full_name: Union[str, None] = None


class UserIn(UserBase):
    password: str


class UserOut(UserBase):
    pass


class UserInDB(UserBase):
    hashed_password: str


def fake_password_hasher(raw_password: str):
    return "supersecret" + raw_password


def fake_save_user(user_in: UserIn):
    hashed_password = fake_password_hasher(user_in.password)
    user_in_db = UserInDB(**user_in.dict(), hashed_password=hashed_password)
    print("User saved! ..not really")
    return user_in_db


@app.post("/user/", response_model=UserOut)
async def create_user(user_in: UserIn):
    user_saved = fake_save_user(user_in)
    return user_saved

`Union` 或 `anyOf`¶

您可以声明响应是两个或多个类型的 Union，这意味着响应可以是其中任何一个。

它将在 OpenAPI 中使用 anyOf 定义。

为此，请使用标准 Python 类型提示 typing.Union

注意

在定义 Union 时，请首先包含最具体的类型，然后是较不具体的类型。在下面的示例中，更具体的 PlaneItem 在 Union[PlaneItem, CarItem] 中位于 CarItem 之前。

Python 3.10+

from typing import Union

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class BaseItem(BaseModel):
    description: str
    type: str


class CarItem(BaseItem):
    type: str = "car"


class PlaneItem(BaseItem):
    type: str = "plane"
    size: int


items = {
    "item1": {"description": "All my friends drive a low rider", "type": "car"},
    "item2": {
        "description": "Music is my aeroplane, it's my aeroplane",
        "type": "plane",
        "size": 5,
    },
}


@app.get("/items/{item_id}", response_model=Union[PlaneItem, CarItem])
async def read_item(item_id: str):
    return items[item_id]

🤓 其他版本和变体

Python 3.8+

from typing import Union

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class BaseItem(BaseModel):
    description: str
    type: str


class CarItem(BaseItem):
    type: str = "car"


class PlaneItem(BaseItem):
    type: str = "plane"
    size: int


items = {
    "item1": {"description": "All my friends drive a low rider", "type": "car"},
    "item2": {
        "description": "Music is my aeroplane, it's my aeroplane",
        "type": "plane",
        "size": 5,
    },
}


@app.get("/items/{item_id}", response_model=Union[PlaneItem, CarItem])
async def read_item(item_id: str):
    return items[item_id]

Python 3.10 中的 `Union`¶

在此示例中，我们将 Union[PlaneItem, CarItem] 作为参数 response_model 的值传递。

因为我们将其作为参数的值传递，而不是将其放在类型注解中，所以即使在 Python 3.10 中，我们也必须使用 Union。

如果它在类型注解中，我们可以使用竖线，例如

some_variable: PlaneItem | CarItem

但是如果我们将它放在赋值语句 response_model=PlaneItem | CarItem 中，我们将收到一个错误，因为 Python 会尝试在 PlaneItem 和 CarItem 之间执行无效操作，而不是将其解释为类型注解。

模型列表¶

同样，您可以声明对象列表的响应。

为此，请使用标准 Python typing.List（或在 Python 3.9 及更高版本中仅使用 list）

Python 3.9+

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: str


items = [
    {"name": "Foo", "description": "There comes my hero"},
    {"name": "Red", "description": "It's my aeroplane"},
]


@app.get("/items/", response_model=list[Item])
async def read_items():
    return items

🤓 其他版本和变体

Python 3.8+

from typing import List

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: str


items = [
    {"name": "Foo", "description": "There comes my hero"},
    {"name": "Red", "description": "It's my aeroplane"},
]


@app.get("/items/", response_model=List[Item])
async def read_items():
    return items

响应任意 `dict`¶

您还可以使用普通的任意 dict 声明响应，仅声明键和值的类型，而不使用 Pydantic 模型。

如果您事先不知道有效的字段/属性名称（Pydantic 模型所需的），这将非常有用。

在这种情况下，您可以使用 typing.Dict（或在 Python 3.9 及更高版本中仅使用 dict）

Python 3.9+

from fastapi import FastAPI

app = FastAPI()


@app.get("/keyword-weights/", response_model=dict[str, float])
async def read_keyword_weights():
    return {"foo": 2.3, "bar": 3.4}

🤓 其他版本和变体

Python 3.8+

from typing import Dict

from fastapi import FastAPI

app = FastAPI()


@app.get("/keyword-weights/", response_model=Dict[str, float])
async def read_keyword_weights():
    return {"foo": 2.3, "bar": 3.4}

总结¶

使用多个 Pydantic 模型并根据每个用例自由继承。

如果实体必须能够具有不同的“状态”，则您无需为每个实体只拥有一个数据模型。就像用户“实体”具有包含 password、password_hash 和无密码的状态一样。

额外模型¶

多个模型¶

关于 **user_in.dict()¶

Pydantic 的 .dict()¶

解包 dict¶

从另一个模型的内容创建 Pydantic 模型¶

解包 dict 和额外关键字¶

减少重复¶

Union 或 anyOf¶

Python 3.10 中的 Union¶

模型列表¶

响应任意 dict¶

总结¶

关于 `**user_in.dict()`¶

Pydantic 的 `.dict()`¶

解包 `dict`¶

解包 `dict` 和额外关键字¶

`Union` 或 `anyOf`¶

Python 3.10 中的 `Union`¶

响应任意 `dict`¶