Bạn có thể khai báo loại được sử dụng cho phản hồi bằng cách chú thích kiểu trả về của hàm thao tác đường dẫn
Bạn có thể sử dụng các chú thích kiểu giống như cách bạn làm với dữ liệu đầu vào trong các tham số hàm, bạn có thể sử dụng các mô hình Pydantic, danh sách, từ điển, giá trị vô hướng như số nguyên, booleans, v.v.
Trăn 3. 6 trở lênPython 3. 9 trở lên Python 3. 10 trở lên
from typing import List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> List[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
FastAPI sẽ sử dụng kiểu trả về này để
- Xác thực dữ liệu trả về
- Nếu dữ liệu không hợp lệ [e. g. bạn đang thiếu một trường], điều đó có nghĩa là mã ứng dụng của bạn bị hỏng, không trả về đúng như mong muốn và nó sẽ trả về lỗi máy chủ thay vì trả về dữ liệu không chính xác. Bằng cách này, bạn và khách hàng của mình có thể chắc chắn rằng họ sẽ nhận được dữ liệu và hình dạng dữ liệu như mong đợi
- Thêm Lược đồ JSON cho phản hồi, trong thao tác đường dẫn OpenAPI
- Điều này sẽ được sử dụng bởi các tài liệu tự động
- Nó cũng sẽ được sử dụng bởi các công cụ tạo mã máy khách tự động
Nhưng quan trọng nhất
- Nó sẽ giới hạn và lọc dữ liệu đầu ra theo những gì được xác định trong kiểu trả về
- Điều này đặc biệt quan trọng đối với bảo mật, chúng ta sẽ xem thêm về điều đó bên dưới
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
7 Tham số
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
Có một số trường hợp bạn cần hoặc muốn trả về một số dữ liệu không chính xác như kiểu khai báo
Ví dụ: bạn có thể muốn trả về một từ điển hoặc đối tượng cơ sở dữ liệu, nhưng khai báo nó dưới dạng mô hình Pydantic. Bằng cách này, mô hình Pydantic sẽ thực hiện tất cả tài liệu dữ liệu, xác thực, v.v. cho đối tượng mà bạn đã trả lại [e. g. một từ điển hoặc đối tượng cơ sở dữ liệu]
Nếu bạn đã thêm chú thích kiểu trả về, các công cụ và trình chỉnh sửa sẽ phàn nàn về lỗi [chính xác] cho bạn biết rằng hàm của bạn đang trả về kiểu [e. g. a dict] khác với những gì bạn đã khai báo [e. g. một mô hình Pydantic]
Trong những trường hợp đó, bạn có thể sử dụng tham số trang trí hoạt động đường dẫn
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
7 thay vì kiểu trả vềBạn có thể sử dụng tham số
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
7 trong bất kỳ hoạt động đường dẫn nào
0from typing import Any, Union from fastapi import FastAPI from pydantic import BaseModel app = FastAPI[] class Item[BaseModel]: name: str description: Union[str, None] = None price: float tax: Union[float, None] = None tags: list[str] = [] @app.post["/items/", response_model=Item] async def create_item[item: Item] -> Any: return item @app.get["/items/", response_model=list[Item]] async def read_items[] -> Any: return [ {"name": "Portal Gun", "price": 42.0}, {"name": "Plumbus", "price": 32.0}, ]
1from typing import Any, Union from fastapi import FastAPI from pydantic import BaseModel app = FastAPI[] class Item[BaseModel]: name: str description: Union[str, None] = None price: float tax: Union[float, None] = None tags: list[str] = [] @app.post["/items/", response_model=Item] async def create_item[item: Item] -> Any: return item @app.get["/items/", response_model=list[Item]] async def read_items[] -> Any: return [ {"name": "Portal Gun", "price": 42.0}, {"name": "Plumbus", "price": 32.0}, ]
2from typing import Any, Union from fastapi import FastAPI from pydantic import BaseModel app = FastAPI[] class Item[BaseModel]: name: str description: Union[str, None] = None price: float tax: Union[float, None] = None tags: list[str] = [] @app.post["/items/", response_model=Item] async def create_item[item: Item] -> Any: return item @app.get["/items/", response_model=list[Item]] async def read_items[] -> Any: return [ {"name": "Portal Gun", "price": 42.0}, {"name": "Plumbus", "price": 32.0}, ]
3from typing import Any, Union from fastapi import FastAPI from pydantic import BaseModel app = FastAPI[] class Item[BaseModel]: name: str description: Union[str, None] = None price: float tax: Union[float, None] = None tags: list[str] = [] @app.post["/items/", response_model=Item] async def create_item[item: Item] -> Any: return item @app.get["/items/", response_model=list[Item]] async def read_items[] -> Any: return [ {"name": "Portal Gun", "price": 42.0}, {"name": "Plumbus", "price": 32.0}, ]
- vân vân
Trăn 3. 6 trở lênPython 3. 9 trở lên Python 3. 10 trở lên
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
from typing import Any, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=list[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
from typing import Any
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=list[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
Ghi chú
Lưu ý rằng
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
7 là một tham số của phương thức "decorator" [from typing import Any, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=list[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
5, from typing import Any, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=list[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
6, v.v.]. Không phải chức năng vận hành đường dẫn của bạn, giống như tất cả các tham số và nội dungfrom typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
7 nhận được cùng loại mà bạn sẽ khai báo cho trường mô hình Pydantic, vì vậy, nó có thể là mô hình Pydantic, nhưng cũng có thể là, e. g. một from typing import Any, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=list[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
8 trong số các mô hình Pydantic, như from typing import Any, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=list[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
9FastAPI sẽ sử dụng
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
7 này để thực hiện tất cả tài liệu dữ liệu, xác thực, v.v. và cũng để chuyển đổi và lọc dữ liệu đầu ra thành khai báo kiểu của nóMẹo
Nếu bạn có kiểm tra loại nghiêm ngặt trong trình chỉnh sửa của mình, mypy, v.v., bạn có thể khai báo loại trả về của hàm là
from typing import Any
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=list[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
1Bằng cách đó, bạn nói với biên tập viên rằng bạn đang cố tình trả lại bất kỳ thứ gì. Nhưng FastAPI vẫn sẽ thực hiện tài liệu dữ liệu, xác thực, lọc, v.v. với
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
7from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
7 Ưu tiên
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
Nếu bạn khai báo cả loại trả về và
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
7, thì from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
7 sẽ được ưu tiên và được FastAPI sử dụngBằng cách này, bạn có thể thêm các chú thích loại chính xác vào các chức năng của mình ngay cả khi bạn trả về một loại khác với mô hình phản hồi, được sử dụng bởi trình chỉnh sửa và các công cụ như mypy. Và bạn vẫn có thể yêu cầu FastAPI thực hiện xác thực dữ liệu, tài liệu, v.v. sử dụng
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
7Bạn cũng có thể sử dụng
from typing import Any
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=list[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
7 để tắt tạo mô hình phản hồi cho thao tác đường dẫn đó, bạn có thể cần làm điều đó nếu bạn đang thêm chú thích loại cho những thứ không phải là trường Pydantic hợp lệ, bạn sẽ thấy ví dụ về điều đó ở một trong các phần bên dướiTrả về cùng một dữ liệu đầu vào
Ở đây chúng tôi đang khai báo một mô hình
from typing import Any
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=list[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
8, nó sẽ chứa mật khẩu văn bản gốcTrăn 3. 6 trở lênPython 3. 10 trở lên
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
Thông tin
Để sử dụng
from typing import Any
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=list[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
9, trước tiên hãy cài đặt 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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
0E. g.
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
1 hoặc 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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
2Và chúng tôi đang sử dụng mô hình này để khai báo đầu vào và mô hình tương tự để khai báo đầu ra của chúng tôi
Trăn 3. 6 trở lênPython 3. 10 trở lên
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
Bây giờ, bất cứ khi nào trình duyệt tạo người dùng bằng mật khẩu, API sẽ trả về cùng một mật khẩu trong phản hồi
Trong trường hợp này, đó có thể không phải là vấn đề vì đó là cùng một người dùng gửi mật khẩu
Nhưng nếu chúng tôi sử dụng cùng một mô hình cho hoạt động đường dẫn khác, chúng tôi có thể gửi mật khẩu của người dùng cho mọi khách hàng
Sự nguy hiểm
Không bao giờ lưu trữ mật khẩu đơn giản của người dùng hoặc gửi nó dưới dạng phản hồi như thế này, trừ khi bạn biết tất cả các cảnh báo và bạn biết mình đang làm gì
Thêm một mô hình đầu ra
Thay vào đó, chúng ta có thể tạo một mô hình đầu vào bằng mật khẩu văn bản gốc và một mô hình đầu ra không có nó
Trăn 3. 6 trở lênPython 3. 10 trở lên
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
0from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
1Ở đây, mặc dù chức năng vận hành đường dẫn của chúng tôi đang trả về cùng một người dùng đầu vào có chứa mật khẩu
Trăn 3. 6 trở lênPython 3. 10 trở lên
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
2from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
3chúng tôi đã tuyên bố
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
7 là mẫu của chúng tôi 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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
4, không bao gồm mật khẩuTrăn 3. 6 trở lênPython 3. 10 trở lên
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
4from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
5Vì vậy, FastAPI sẽ đảm nhiệm việc lọc ra tất cả dữ liệu không được khai báo trong mô hình đầu ra [sử dụng Pydantic]
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
7 hoặc Loại trả lại
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
Trong trường hợp này, vì hai mô hình khác nhau, nếu chúng ta chú thích kiểu trả về của hàm là
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
4, trình chỉnh sửa và công cụ sẽ phàn nàn rằng chúng ta đang trả về một kiểu không hợp lệ, vì đó là các lớp khác nhauChính vì vậy trong ví dụ này chúng ta phải khai báo nó trong tham số
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
7nhưng hãy tiếp tục đọc phần dưới đây để xem cách vượt qua điều đó
Loại trả về và lọc dữ liệu
Hãy tiếp tục từ ví dụ trước. Chúng tôi muốn chú thích hàm bằng một loại nhưng trả về thứ gì đó bao gồm nhiều dữ liệu hơn
Chúng tôi muốn FastAPI tiếp tục lọc dữ liệu bằng mô hình phản hồi
Trong ví dụ trước, vì các lớp khác nhau nên chúng ta phải sử dụng tham số
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
7. Nhưng điều đó cũng có nghĩa là chúng ta không nhận được sự hỗ trợ từ trình soạn thảo và các công cụ kiểm tra kiểu trả về của hàmNhưng trong hầu hết các trường hợp chúng ta cần làm điều gì đó như thế này, chúng ta muốn mô hình chỉ lọc/xóa một số dữ liệu như trong ví dụ này
Và trong những trường hợp đó, chúng ta có thể sử dụng các lớp và tính kế thừa để tận dụng các chú thích kiểu hàm để được hỗ trợ tốt hơn trong trình chỉnh sửa và công cụ, đồng thời vẫn nhận được tính năng lọc dữ liệu FastAPI
Trăn 3. 6 trở lênPython 3. 10 trở lên
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
6from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
7Với điều này, chúng tôi nhận được hỗ trợ công cụ, từ người chỉnh sửa và mypy vì mã này đúng về loại, nhưng chúng tôi cũng nhận được bộ lọc dữ liệu từ FastAPI
Cái này hoạt động ra sao? . 🤓
Nhập Chú thích và Công cụ
Trước tiên, hãy xem trình chỉnh sửa, mypy và các công cụ khác sẽ thấy điều này như thế nào
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
9 có các trường cơ sở. Sau đó, from typing import Any
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=list[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
8 kế thừa từ 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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
9 và thêm trường 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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
2, vì vậy, nó sẽ bao gồm tất cả các trường từ cả hai mô hìnhChúng tôi chú thích kiểu trả về của hàm là
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
9, nhưng chúng tôi thực sự đang trả về một phiên bản from typing import Any
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=list[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
8Trình chỉnh sửa, mypy và các công cụ khác sẽ không phàn nàn về điều này bởi vì, theo thuật ngữ đánh máy,
from typing import Any
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=list[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
8 là một phân lớp của 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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
9, có nghĩa là đây là một loại hợp lệ khi những gì được mong đợi là bất kỳ thứ gì là một 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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
9Lọc dữ liệu FastAPI
Bây giờ, đối với FastAPI, nó sẽ thấy kiểu trả về và đảm bảo rằng những gì bạn trả về chỉ bao gồm các trường được khai báo trong kiểu
FastAPI thực hiện một số điều trong nội bộ với Pydantic để đảm bảo rằng các quy tắc kế thừa lớp tương tự đó không được sử dụng để lọc dữ liệu trả về, nếu không, cuối cùng bạn có thể trả về nhiều dữ liệu hơn những gì bạn mong đợi
Bằng cách này, bạn có thể tận dụng tối đa cả hai thế giới. gõ chú thích với hỗ trợ công cụ và lọc dữ liệu
Xem nó trong các tài liệu
Khi bạn thấy các tài liệu tự động, bạn có thể kiểm tra xem cả mô hình đầu vào và mô hình đầu ra đều có Lược đồ JSON của riêng chúng không
Và cả hai mô hình sẽ được sử dụng cho tài liệu API tương tác
Chú thích loại trả lại khác
Có thể có trường hợp bạn trả về một thứ không phải là trường Pydantic hợp lệ và bạn chú thích nó trong hàm, chỉ để nhận được sự hỗ trợ do công cụ cung cấp [trình chỉnh sửa, mypy, v.v.]
Trả lại phản hồi trực tiếp
Trường hợp phổ biến nhất sẽ trả về một Phản hồi trực tiếp như được giải thích sau trong tài liệu nâng cao
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
8Trường hợp đơn giản này được FastAPI xử lý tự động vì chú thích kiểu trả về là lớp [hoặc lớp con] của
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
8Và các công cụ cũng sẽ rất vui vì cả
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
9 và 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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
0 đều là các lớp con của 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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
8, vì vậy chú thích loại là chính xácChú thích một lớp con phản hồi
Bạn cũng có thể sử dụng một lớp con của
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
8 trong chú thích loạifrom typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
9Điều này cũng sẽ hiệu quả vì
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
9 là một lớp con của 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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
8 và FastAPI sẽ tự động xử lý trường hợp đơn giản nàyChú thích loại trả lại không hợp lệ
Nhưng khi bạn trả về một số đối tượng tùy ý khác không phải là loại Pydantic hợp lệ [e. g. một đối tượng cơ sở dữ liệu] và bạn chú thích nó như vậy trong hàm, FastAPI sẽ cố gắng tạo một mô hình phản hồi Pydantic từ chú thích loại đó và sẽ không thành công
Điều tương tự cũng xảy ra nếu bạn có thứ gì đó giống như sự kết hợp giữa các loại khác nhau trong đó một hoặc nhiều trong số chúng không phải là loại Pydantic hợp lệ, chẳng hạn như điều này sẽ thất bại 💥
Trăn 3. 6 trở lênPython 3. 10 trở lên
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
0from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
1điều này không thành công vì chú thích loại không phải là loại Pydantic và không chỉ là một lớp hoặc lớp con
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
8 đơn lẻ, nó là sự kết hợp [bất kỳ trong hai loại] giữa 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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
8 và 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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
7Vô hiệu hóa mô hình phản hồi
Tiếp tục từ ví dụ trên, bạn có thể không muốn xác thực dữ liệu mặc định, tài liệu, lọc, v.v. được thực hiện bởi FastAPI
Nhưng bạn có thể vẫn muốn giữ chú thích kiểu trả về trong hàm để nhận được sự hỗ trợ từ các công cụ như trình chỉnh sửa và trình kiểm tra kiểu [e. g. mypy]
Trong trường hợp này, bạn có thể tắt tính năng tạo mô hình phản hồi bằng cách cài đặt ____12_______7
Trăn 3. 6 trở lênPython 3. 10 trở lên
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
2from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
3Điều này sẽ làm cho FastAPI bỏ qua việc tạo mô hình phản hồi và theo cách đó bạn có thể có bất kỳ chú thích kiểu trả về nào bạn cần mà không ảnh hưởng đến ứng dụng FastAPI của bạn. 🤓
Thông số mã hóa Mô hình Phản hồi
Mô hình phản hồi của bạn có thể có các giá trị mặc định, như
Trăn 3. 6 trở lênPython 3. 9 trở lên Python 3. 10 trở lên
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
4from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
5from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
6
9 [hoặcfrom 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 # Don't do this in production! @app.post["/user/"] async def create_user[user: UserIn] -> UserIn: return user
0 trong Python 3. 10] có giá trị mặc định là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 # Don't do this in production! @app.post["/user/"] async def create_user[user: UserIn] -> UserIn: return user
1from fastapi import FastAPI from pydantic import BaseModel, EmailStr app = FastAPI[] class UserIn[BaseModel]: username: str password: str email: EmailStr full_name: str | None = None # Don't do this in production! @app.post["/user/"] async def create_user[user: UserIn] -> UserIn: return user
2 có giá trị mặc định là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 # Don't do this in production! @app.post["/user/"] async def create_user[user: UserIn] -> UserIn: return user
3from fastapi import FastAPI from pydantic import BaseModel, EmailStr app = FastAPI[] class UserIn[BaseModel]: username: str password: str email: EmailStr full_name: str | None = None # Don't do this in production! @app.post["/user/"] async def create_user[user: UserIn] -> UserIn: return user
4 làm mặc định của danh sách trống.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 # Don't do this in production! @app.post["/user/"] async def create_user[user: UserIn] -> UserIn: return user
5from fastapi import FastAPI from pydantic import BaseModel, EmailStr app = FastAPI[] class UserIn[BaseModel]: username: str password: str email: EmailStr full_name: str | None = None # Don't do this in production! @app.post["/user/"] async def create_user[user: UserIn] -> UserIn: return user
nhưng bạn có thể muốn loại bỏ chúng khỏi kết quả nếu chúng không thực sự được lưu trữ
Ví dụ: nếu bạn có các mô hình với nhiều thuộc tính tùy chọn trong cơ sở dữ liệu NoSQL, nhưng bạn không muốn gửi các phản hồi JSON rất dài chứa đầy các giá trị mặc định
Sử dụng tham số 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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
6
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
Bạn có thể đặt tham số trang trí hoạt động đường dẫn
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
7Trăn 3. 6 trở lênPython 3. 9 trở lên Python 3. 10 trở lên
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
7from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
8from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: str | None = None
price: float
tax: float | None = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
9và những giá trị mặc định đó sẽ không được đưa vào phản hồi, chỉ những giá trị thực sự được đặt
Vì vậy, nếu bạn gửi yêu cầu tới thao tác đường dẫn đó cho mục có ID
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
8, thì phản hồi [không bao gồm các giá trị mặc định] sẽ làfrom typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
0Thông tin
FastAPI sử dụng
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
9 của mô hình Pydantic để đạt được điều nàyThông tin
Bạn cũng có thể dùng
01from typing import Union from fastapi import FastAPI from pydantic import BaseModel app = FastAPI[] class Item[BaseModel]: name: str description: Union[str, None] = None price: float tax: Union[float, None] = None tags: list[str] = [] @app.post["/items/"] async def create_item[item: Item] -> Item: return item @app.get["/items/"] async def read_items[] -> list[Item]: return [ Item[name="Portal Gun", price=42.0], Item[name="Plumbus", price=32.0], ]
02from typing import Union from fastapi import FastAPI from pydantic import BaseModel app = FastAPI[] class Item[BaseModel]: name: str description: Union[str, None] = None price: float tax: Union[float, None] = None tags: list[str] = [] @app.post["/items/"] async def create_item[item: Item] -> Item: return item @app.get["/items/"] async def read_items[] -> list[Item]: return [ Item[name="Portal Gun", price=42.0], Item[name="Plumbus", price=32.0], ]
như được mô tả trong
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
03 và from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
04Dữ liệu có giá trị cho các trường có giá trị mặc định
Nhưng nếu dữ liệu của bạn có giá trị cho các trường của mô hình có giá trị mặc định, chẳng hạn như mục có ID
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
05from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
1chúng sẽ được đưa vào phản hồi
Dữ liệu có cùng giá trị với giá trị mặc định
Nếu dữ liệu có cùng giá trị với giá trị mặc định, chẳng hạn như mục có ID
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
06from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
2FastAPI đủ thông minh [trên thực tế, Pydantic đủ thông minh] để nhận ra rằng, mặc dù
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
07, from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
08 và from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
09 có cùng giá trị như giá trị mặc định, nhưng chúng được đặt rõ ràng [thay vì lấy từ giá trị mặc định]Vì vậy, chúng sẽ được đưa vào phản hồi JSON
Mẹo
Lưu ý rằng các giá trị mặc định có thể là bất kỳ thứ gì, không chỉ
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
1Chúng có thể là một danh sách [
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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
5], một from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
12 của 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
# Don't do this in production!
@app.post["/user/"]
async def create_user[user: UserIn] -> UserIn:
return user
3, v.v.from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
14 và from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
15
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
Bạn cũng có thể sử dụng các tham số trang trí hoạt động đường dẫn
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
14 và from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
15Họ lấy một
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
18 của from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
19 với tên của các thuộc tính để bao gồm [bỏ qua phần còn lại] hoặc để loại trừ [bao gồm phần còn lại]Điều này có thể được sử dụng như một phím tắt nhanh nếu bạn chỉ có một mô hình Pydantic và muốn xóa một số dữ liệu khỏi đầu ra
Mẹo
Nhưng vẫn nên sử dụng các ý tưởng ở trên, sử dụng nhiều lớp, thay vì các tham số này
Điều này là do Lược đồ JSON được tạo trong OpenAPI của ứng dụng của bạn [và các tài liệu] sẽ vẫn là lược đồ cho mô hình hoàn chỉnh, ngay cả khi bạn sử dụng
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
14 hoặc from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
15 để bỏ qua một số thuộc tínhĐiều này cũng áp dụng cho
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
22 hoạt động tương tựTrăn 3. 6 trở lênPython 3. 10 trở lên
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
3from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
4Mẹo
Cú pháp
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
23 tạo một from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
18 với hai giá trị đóNó tương đương với
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
25Sử dụng from typing import Any, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=list[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
8 thay vì from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
18
from typing import Any, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=list[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
Nếu bạn quên sử dụng
from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
18 và thay vào đó sử dụng from typing import Any, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=list[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
8 hoặc from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
30, FastAPI sẽ vẫn chuyển đổi nó thành from typing import Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: list[str] = []
@app.post["/items/"]
async def create_item[item: Item] -> Item:
return item
@app.get["/items/"]
async def read_items[] -> list[Item]:
return [
Item[name="Portal Gun", price=42.0],
Item[name="Plumbus", price=32.0],
]
18 và nó sẽ hoạt động bình thườngTrăn 3. 6 trở lênPython 3. 10 trở lên
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
5from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
6Tóm tắt lại
Sử dụng tham số của trình trang trí hoạt động đường dẫn
from typing import Any, List, Union
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI[]
class Item[BaseModel]:
name: str
description: Union[str, None] = None
price: float
tax: Union[float, None] = None
tags: List[str] = []
@app.post["/items/", response_model=Item]
async def create_item[item: Item] -> Any:
return item
@app.get["/items/", response_model=List[Item]]
async def read_items[] -> Any:
return [
{"name": "Portal Gun", "price": 42.0},
{"name": "Plumbus", "price": 32.0},
]
7 để xác định các mô hình phản hồi và đặc biệt là để đảm bảo dữ liệu riêng tư được lọc ra