书接上文，多个关联模型这种情况很常见。

特别是用户模型，因为：

  • 输入模型应该含密码
  • 输出模型不应含密码
  • 数据库模型需要加密的密码

千万不要存储用户的明文密码。始终存储可以进行验证的安全哈希值。

如果不了解这方面的知识，请参阅安全性中的章节，了解什么是密码哈希。

多个模型

下面的代码展示了不同模型处理密码字段的方式，及使用位置的大致思路：

Python 3.10+ Python 3.8+

  1. from fastapi import FastAPI
  2. from pydantic import BaseModel, EmailStr
  4. app = FastAPI()
  6. class UserIn(BaseModel):
  7.     username: str
  8.  password: str    email: EmailStr
  9.     full_name: str | None = None
  11. class UserOut(BaseModel):
  12.     username: str
  13.     email: EmailStr
  14.     full_name: str | None = None
  16. class UserInDB(BaseModel):
  17.     username: str
  18.  hashed_password: str    email: EmailStr
  19.     full_name: str | None = None
  21. def fake_password_hasher(raw_password: str):
  22.  return "supersecret" + raw_password 
  24. def fake_save_user(user_in: UserIn):
  25.  hashed_password = fake_password_hasher(user_in.password) user_in_db = UserInDB(**user_in.dict(), hashed_password=hashed_password)    print("User saved! ..not really")
  26.     return user_in_db
  28. @app.post("/user/", response_model=UserOut) async def create_user(user_in: UserIn):
  29.     user_saved = fake_save_user(user_in)
  30.     return user_saved
  1. from typing import Union
  3. from fastapi import FastAPI
  4. from pydantic import BaseModel, EmailStr
  6. app = FastAPI()
  8. class UserIn(BaseModel):
  9.     username: str
  10.  password: str    email: EmailStr
  11.     full_name: Union[str, None] = None
  13. class UserOut(BaseModel):
  14.     username: str
  15.     email: EmailStr
  16.     full_name: Union[str, None] = None
  18. class UserInDB(BaseModel):
  19.     username: str
  20.  hashed_password: str    email: EmailStr
  21.     full_name: Union[str, None] = None
  23. def fake_password_hasher(raw_password: str):
  24.  return "supersecret" + raw_password 
  26. def fake_save_user(user_in: UserIn):
  27.  hashed_password = fake_password_hasher(user_in.password) user_in_db = UserInDB(**user_in.dict(), hashed_password=hashed_password)    print("User saved! ..not really")
  28.     return user_in_db
  30. @app.post("/user/", response_model=UserOut) async def create_user(user_in: UserIn):
  31.     user_saved = fake_save_user(user_in)
  32.     return user_saved

**user_in.dict() 简介

Pydantic 的 .dict()

user_in 是类 UserIn 的 Pydantic 模型。

Pydantic 模型支持 .dict() 方法，能返回包含模型数据的字典。

因此，如果使用如下方式创建 Pydantic 对象 user_in：

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

就能以如下方式调用：

user_dict = user_in.dict()

现在，变量 user_dict中的就是包含数据的字典（变量 user_dict 是字典，不是 Pydantic 模型对象）。

以如下方式调用：

print(user_dict)

输出的就是 Python 字典：

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

解包 dict

把字典 user_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() 是字典，在传递给 UserInDB 时，把 ** 加在 user_in.dict() 前，可以让 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, )

警告

辅助的附加函数只是为了演示可能的数据流，但它们显然不能提供任何真正的安全机制。

减少重复

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

代码重复会导致 bug、安全问题、代码失步等问题（更新了某个位置的代码，但没有同步更新其它位置的代码）。

上面的这些模型共享了大量数据，拥有重复的属性名和类型。

FastAPI 可以做得更好。

声明 UserBase 模型作为其它模型的基类。然后，用该类衍生出继承其属性（类型声明、验证等）的子类。

所有数据转换、校验、文档等功能仍将正常运行。

这样，就可以仅声明模型之间的差异部分（具有明文的 password、具有 hashed_password 以及不包括密码）。

通过这种方式，可以只声明模型之间的区别（分别包含明文密码、哈希密码，以及无密码的模型）。

Python 3.10+Python 3.8+

  1. from fastapi import FastAPI
  2. from pydantic import BaseModel, EmailStr
  4. app = FastAPI()
  6. class UserBase(BaseModel):
  7.     username: str
  8.     email: EmailStr
  9.     full_name: str | None = None
  11. class UserIn(UserBase):
  12.  password: str 
  14. class UserOut(UserBase):
  15.  pass 
  17. class UserInDB(UserBase):
  18.  hashed_password: str 
  20. def fake_password_hasher(raw_password: str):
  21.     return "supersecret" + raw_password
  23. def fake_save_user(user_in: UserIn):
  24.     hashed_password = fake_password_hasher(user_in.password)
  25.     user_in_db = UserInDB(**user_in.dict(), hashed_password=hashed_password)
  26.     print("User saved! ..not really")
  27.     return user_in_db
  29. @app.post("/user/", response_model=UserOut)
  30. async def create_user(user_in: UserIn):
  31.     user_saved = fake_save_user(user_in)
  32.     return user_saved
  1. from typing import Union
  3. from fastapi import FastAPI
  4. from pydantic import BaseModel, EmailStr
  6. app = FastAPI()
  8. class UserBase(BaseModel):
  9.     username: str
  10.     email: EmailStr
  11.     full_name: Union[str, None] = None
  13. class UserIn(UserBase):
  14.  password: str 
  16. class UserOut(UserBase):
  17.  pass 
  19. class UserInDB(UserBase):
  20.  hashed_password: str 
  22. def fake_password_hasher(raw_password: str):
  23.     return "supersecret" + raw_password
  25. def fake_save_user(user_in: UserIn):
  26.     hashed_password = fake_password_hasher(user_in.password)
  27.     user_in_db = UserInDB(**user_in.dict(), hashed_password=hashed_password)
  28.     print("User saved! ..not really")
  29.     return user_in_db
  31. @app.post("/user/", response_model=UserOut)
  32. async def create_user(user_in: UserIn):
  33.     user_saved = fake_save_user(user_in)
  34.     return user_saved

Union 或者 anyOf

响应可以声明为两种类型的 Union 类型，即该响应可以是两种类型中的任意类型。

在 OpenAPI 中可以使用 anyOf 定义。

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

笔记

定义 Union 类型时，要把详细的类型写在前面，然后是不太详细的类型。下例中，更详细的 PlaneItem 位于 Union[PlaneItem，CarItem] 中的 CarItem 之前。

Python 3.10+Python 3.8+

  1. from typing import Union 
  2. from fastapi import FastAPI
  3. from pydantic import BaseModel
  5. app = FastAPI()
  7. class BaseItem(BaseModel):
  8.     description: str
  9.     type: str
  11. class CarItem(BaseItem):
  12.  type: str = "car" 
  14. class PlaneItem(BaseItem):
  15.  type: str = "plane" size: int 
  17. items = {
  18.     "item1": {"description": "All my friends drive a low rider", "type": "car"},
  19.     "item2": {
  20.         "description": "Music is my aeroplane, it's my aeroplane",
  21.         "type": "plane",
  22.         "size": 5,
  23.     },
  24. }
  26. @app.get("/items/{item_id}", response_model=Union[PlaneItem, CarItem]) async def read_item(item_id: str):
  27.     return items[item_id]
  1. from typing import Union 
  2. from fastapi import FastAPI
  3. from pydantic import BaseModel
  5. app = FastAPI()
  7. class BaseItem(BaseModel):
  8.     description: str
  9.     type: str
  11. class CarItem(BaseItem):
  12.  type: str = "car" 
  14. class PlaneItem(BaseItem):
  15.  type: str = "plane" size: int 
  17. items = {
  18.     "item1": {"description": "All my friends drive a low rider", "type": "car"},
  19.     "item2": {
  20.         "description": "Music is my aeroplane, it's my aeroplane",
  21.         "type": "plane",
  22.         "size": 5,
  23.     },
  24. }
  26. @app.get("/items/{item_id}", response_model=Union[PlaneItem, CarItem]) async def read_item(item_id: str):
  27.     return items[item_id]

模型列表

使用同样的方式也可以声明由对象列表构成的响应。

为此，请使用标准的 Python typing.List：

Python 3.9+Python 3.8+

  1. from fastapi import FastAPI
  2. from pydantic import BaseModel
  4. app = FastAPI()
  6. class Item(BaseModel):
  7.     name: str
  8.     description: str
  10. items = [
  11.     {"name": "Foo", "description": "There comes my hero"},
  12.     {"name": "Red", "description": "It's my aeroplane"},
  13. ]
  15. @app.get("/items/", response_model=list[Item]) async def read_items():
  16.     return items
  1. from typing import List 
  2. from fastapi import FastAPI
  3. from pydantic import BaseModel
  5. app = FastAPI()
  7. class Item(BaseModel):
  8.     name: str
  9.     description: str
  11. items = [
  12.     {"name": "Foo", "description": "There comes my hero"},
  13.     {"name": "Red", "description": "It's my aeroplane"},
  14. ]
  16. @app.get("/items/", response_model=List[Item]) async def read_items():
  17.     return items

任意 dict 构成的响应

任意的 dict 都能用于声明响应，只要声明键和值的类型，无需使用 Pydantic 模型。

事先不知道可用的字段 / 属性名时（Pydantic 模型必须知道字段是什么），这种方式特别有用。

此时，可以使用 typing.Dict：

Python 3.9+Python 3.8+

  1. from fastapi import FastAPI
  3. app = FastAPI()
  5. @app.get("/keyword-weights/", response_model=dict[str, float]) async def read_keyword_weights():
  6.     return {"foo": 2.3, "bar": 3.4}
  1. from typing import Dict 
  2. from fastapi import FastAPI
  4. app = FastAPI()
  6. @app.get("/keyword-weights/", response_model=Dict[str, float]) async def read_keyword_weights():
  7.     return {"foo": 2.3, "bar": 3.4}

小结

针对不同场景，可以随意使用不同的 Pydantic 模型继承定义的基类。

实体必须具有不同的状态时，不必为不同状态的实体单独定义数据模型。例如，用户实体就有包含 password、包含 password_hash 以及不含密码等多种状态。