FastAPI官方教程太棒了（上）

阿新 • • 發佈：2022-06-06

Python第三流行的Web框架

在2020年的Python開發者調查結果中，有這樣一段話：“FastAPI在此次調查迭代中首次被引為選項，表現為Python第三流行的Web框架。”

FastAPI創立於2018年12月，不到2年就成為僅次於Flask和Django的第三流行的Web框架。而又經過了一年發展來到2022年，雖然2021年Python開發者調查結果還沒有出來，但是從GitHub的star來看，Flask 58.7k，Django 63.6k，FastAPI 44.2k，這個差距縮得越來越小。

FastAPI特性

這裡就不做機器翻譯了，大家看下原文：

我說下我選擇FastAPI的理由：首先就是HttpRunner集成了FastAPI，有大佬背書，相信這個框架足以優秀。其次是註解，用多了SpringBoot以後，越來越喜歡註解，層次清晰。對於前後端分離專案來說，Flask雖然非常精簡卻又自帶了Jinja模板引擎，Django雖然是百寶箱卻又顯得太重，而FastAPI介於兩者之間，就是一個純粹的後端應用。並且FastAPI是基於Starlette框架的，集成了實用功能比如型別檢查、OpenAPI（Swagger）等等，這跟我基於pytest框架做tep測試工具的理念很相似。

安裝

對Python版本要求是3.6+。

先安裝FastAPI：

pip install fastapi

再安裝ASGI伺服器，比如Uvicorn：

pip install "uvicorn[standard]"

也可以同時安裝fastapi和uvicorn：

pip install "fastapi[all]"

執行

寫個main.py檔案：

from typing import Optional

from fastapi import FastAPI

app = FastAPI()


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Optional[str] = None):
    return {"item_id": item_id, "q": q}

在命令列輸入啟動應用：

uvicorn main:app --reload

main是Python模組名。

app是app = FastAPI()。

--reload在程式碼變化時自動重啟伺服器。

開啟瀏覽器訪問：

http://127.0.0.1:8000/items/5?q=somequery

就能看到JSON響應：

{"item_id": 5, "q": "somequery"}

訪問：

http://127.0.0.1:8000/docs

就能看到Swagger介面文件：

pydantic

pydantic是一個數據驗證的庫，FastAPI使用它來做模型校驗。比如：

from typing import Optional

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    price: float
    is_offer: Optional[bool] = None


@app.get("/")
def read_root():
    return {"Hello": "World"}


@app.get("/items/{item_id}")
def read_item(item_id: int, q: Optional[str] = None):
    return {"item_id": item_id, "q": q}


@app.put("/items/{item_id}")
def update_item(item_id: int, item: Item):
    return {"item_name": item.name, "item_id": item_id}

Item是個入參模型，它的name必須str型別，price必須float型別，is_offer是可選的，可以為bool型別或不傳。

PUT http://127.0.0.1:8000/items/6
{
    "name": "dongfanger",
    "price": 2.3,
    "is_offer":  true
}


{
    "item_name": "dongfanger",
    "item_id": 6
}

路徑引數

把路徑引數傳遞給函式：

from fastapi import FastAPI

app = FastAPI()


@app.get("/items/{item_id}")
async def read_item(item_id):
    return {"item_id": item_id}

也可以指定Python型別：

from fastapi import FastAPI

app = FastAPI()


@app.get("/items/{item_id}")
async def read_item(item_id: int):
    return {"item_id": item_id}

效果是訪問 http://127.0.0.1:8000/items/foo 會返回{"item_id":"foo"}。

指定了Python型別後，FastAPI會強制檢查，比如傳str會報錯：

http://127.0.0.1:8000/items/foo

{
    "detail": [
        {
            "loc": [
                "path",
                "item_id"
            ],
            "msg": "value is not a valid integer",
            "type": "type_error.integer"
        }
    ]
}

傳float也會報錯：

http://127.0.0.1:8000/items/4.2

匹配先後順序

程式碼定義的先後順序會決定匹配結果，比如正常來說，下面的/users/me會返回{"user_id": "the current user"}：

from fastapi import FastAPI

app = FastAPI()


@app.get("/users/me")
async def read_user_me():
    return {"user_id": "the current user"}


@app.get("/users/{user_id}")
async def read_user(user_id: str):
    return {"user_id": user_id}

假如這2個path定義順序反過來，那麼/users/me就會匹配到/users/{user_id}而返回{"user_id": me}了。

列舉路徑

藉助於Enun類，可以實現列舉路徑：

from enum import Enum

from fastapi import FastAPI


class ModelName(str, Enum):
    alexnet = "alexnet"
    resnet = "resnet"
    lenet = "lenet"


app = FastAPI()


@app.get("/models/{model_name}")
async def get_model(model_name: ModelName):
    if model_name == ModelName.alexnet:
        return {"model_name": model_name, "message": "Deep Learning FTW!"}

    if model_name.value == "lenet":
        return {"model_name": model_name, "message": "LeCNN all the images"}

    return {"model_name": model_name, "message": "Have some residuals"}

效果：

path匹配

FastAPI提供了一個path型別，可以用來對檔案路徑進行格式匹配：

from fastapi import FastAPI

app = FastAPI()


@app.get("/files/{file_path:path}")
async def read_file(file_path: str):
    return {"file_path": file_path}

查詢引數

查詢引數是跟在路徑引數後面，用?分隔用&連線的引數，比如http://127.0.0.1:8000/items/?skip=0&limit=10。

實現：

from fastapi import FastAPI

app = FastAPI()

fake_items_db = [{"item_name": "Foo"}, {"item_name": "Bar"}, {"item_name": "Baz"}]


@app.get("/items/")
async def read_item(skip: int = 0, limit: int = 10):
    return fake_items_db[skip : skip + limit]

引數是可選的並且設定了預設值：limit: int = 10

引數是可選的，無預設值：limit: Optional[int] = None

注意：是否可選是由None來決定的，而Optional只是為編譯器提供支援，跟FastAPI沒有關係。

引數是必填的：limit: int

請求體

FastAPI的請求體藉助於pydantic來實現：

from typing import Optional

from fastapi import FastAPI
from pydantic import BaseModel


class Item(BaseModel):
    name: str
    description: Optional[str] = None
    price: float
    tax: Optional[float] = None


app = FastAPI()


@app.post("/items/")
async def create_item(item: Item):
    return item

繼承於BaseModel來自定義Model，FastAPI會自動轉換為JSON。

Pydantic PyCharm Plugin外掛提高編碼體驗：

auto-completion

type checks

refactoring

searching

inspections

路徑引數+查詢引數+請求體

總結一下，在函式引數中，url path中定義的叫做路徑引數，沒有定義的叫做查詢引數，型別是pydantic model的叫做請求體，FastAPI會根據這套規則來自動識別：

from typing import Optional

from fastapi import FastAPI
from pydantic import BaseModel


class Item(BaseModel):
    name: str
    description: Optional[str] = None
    price: float
    tax: Optional[float] = None


app = FastAPI()


@app.put("/items/{item_id}")
async def create_item(item_id: int, item: Item, q: Optional[str] = None):
    result = {"item_id": item_id, **item.dict()}
    if q:
        result.update({"q": q})
    return result

查詢引數字串校驗

FastAPI提供了Query來支援對入參的字串校驗，比如最小長度和最大長度：

from typing import Optional

from fastapi import FastAPI, Query

app = FastAPI()


@app.get("/items/")
async def read_items(
    q: Optional[str] = Query(None, min_length=3, max_length=50, regex="^fixedquery$")
):
    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
    if q:
        results.update({"q": q})
    return results

甚至其中也能包含正則表示式：regex="^fixedquery$"。

用Query時指定預設值：

from fastapi import FastAPI, Query

app = FastAPI()


@app.get("/items/")
async def read_items(q: str = Query("fixedquery", min_length=3)):
    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
    if q:
        results.update({"q": q})
    return results

用Query時必填：

from fastapi import FastAPI, Query

app = FastAPI()


@app.get("/items/")
async def read_items(q: str = Query(..., min_length=3)):
    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
    if q:
        results.update({"q": q})
    return results

查詢引數傳list

from typing import List, Optional

from fastapi import FastAPI, Query

app = FastAPI()


@app.get("/items/")
async def read_items(q: Optional[List[str]] = Query(None)):
    query_items = {"q": q}
    return query_items

指定預設值：

from typing import List

from fastapi import FastAPI, Query

app = FastAPI()


@app.get("/items/")
async def read_items(q: List[str] = Query(["foo", "bar"])):
    query_items = {"q": q}
    return query_items

url就像這樣：http://localhost:8000/items/?q=foo&q=bar

指定別名，比如http://127.0.0.1:8000/items/?item-query=foobaritems中的item-query不是Python變數命名，那麼可以設定別名：

from typing import Optional

from fastapi import FastAPI, Query

app = FastAPI()


@app.get("/items/")
async def read_items(q: Optional[str] = Query(None, alias="item-query")):
    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}
    if q:
        results.update({"q": q})
    return results

路徑引數數字校驗

查詢引數用Query做字串（String）校驗，路徑引數用Path做數字（Numeric）校驗：

from fastapi import FastAPI, Path

app = FastAPI()


@app.get("/items/{item_id}")
async def read_items(
    *,
    item_id: int = Path(..., title="The ID of the item to get", gt=0, le=1000),
    q: str,
):
    results = {"item_id": item_id}
    if q:
        results.update({"q": q})
    return results

路徑引數永遠都是必填的，因為它是url一部分。...表示必填，就算設定為None也沒有用，仍然是必填。

ge表示大於等於，greater equal。

le表示小於等於，less equal。

gt表示大於，greater than。

lt表示小於，less than。

請求體-多引數

一、如果請求體嵌套了多個JSON：

{
    "item": {
        "name": "Foo",
        "description": "The pretender",
        "price": 42.0,
        "tax": 3.2
    },
    "user": {
        "username": "dave",
        "full_name": "Dave Grohl"
    }
}

那麼就需要在FastAPI中定義多引數：

from typing import Optional

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: Optional[str] = None
    price: float
    tax: Optional[float] = None


class User(BaseModel):
    username: str
    full_name: Optional[str] = None


@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item, user: User):
    results = {"item_id": item_id, "item": item, "user": user}
    return results

這裡定義了2個Model：Item和User。

二、而如果多個引數中有個引數只是單個值，比如這裡的importance：

{
    "item": {
        "name": "Foo",
        "description": "The pretender",
        "price": 42.0,
        "tax": 3.2
    },
    "user": {
        "username": "dave",
        "full_name": "Dave Grohl"
    },
    "importance": 5
}

那麼定義成變數並賦值= Body()即可：

@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item, user: User, importance: int = Body()):
    results = {"item_id": item_id, "item": item, "user": user, "importance": importance}
    return results

三、在只有一個Item的時候，FastAPI預設會接收這樣的body：

{
    "name": "Foo",
    "description": "The pretender",
    "price": 42.0,
    "tax": 3.2
}

假如想把item也放到JSON中：

{
    "item": {
        "name": "Foo",
        "description": "The pretender",
        "price": 42.0,
        "tax": 3.2
    }
}

那麼可以使用Body(embed=True))：

from typing import Union

from fastapi import Body, FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: Union[str, None] = None
    price: float
    tax: Union[float, None] = None


@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item = Body(embed=True)):
    results = {"item_id": item_id, "item": item}
    return results

請求體-欄位

Pydantic提供了Field來給body中的欄位新增額外校驗：

from typing import Union

from fastapi import Body, FastAPI
from pydantic import BaseModel, Field

app = FastAPI()


class Item(BaseModel):
    name: str
    description: Union[str, None] = Field(
        default=None, title="The description of the item", max_length=300
    )
    price: float = Field(gt=0, description="The price must be greater than zero")
    tax: Union[float, None] = None


@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item = Body(embed=True)):
    results = {"item_id": item_id, "item": item}
    return results

跟FastAPI提供的Query、Path、Body作用類似。

請求體-巢狀模型

傳List：

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.put("/items/{item_id}")
async def update_item(item_id: int, item: Item):
    results = {"item_id": item_id, "item": item}
    return results

傳Set，自動去重：

from typing import Set, 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: Set[str] = set()


@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item):
    results = {"item_id": item_id, "item": item}
    return results

傳Model：

from typing import Set, Union

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


class Image(BaseModel):
    url: str
    name: str


class Item(BaseModel):
    name: str
    description: Union[str, None] = None
    price: float
    tax: Union[float, None] = None
    tags: Set[str] = set()
    image: Union[Image, None] = None


@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item):
    results = {"item_id": item_id, "item": item}
    return results

入參會像這樣：

{
    "name": "Foo",
    "description": "The pretender",
    "price": 42.0,
    "tax": 3.2,
    "tags": ["rock", "metal", "bar"],
    "image": {
        "url": "http://example.com/baz.jpg",
        "name": "The Foo live"
    }
}

對於url，pydantic提供了HttpUrl來做校驗：
class Image(BaseModel):
    url: HttpUrl
    name: str

傳Model的List：

from typing import List, Set, Union

from fastapi import FastAPI
from pydantic import BaseModel, HttpUrl

app = FastAPI()


class Image(BaseModel):
    url: HttpUrl
    name: str


class Item(BaseModel):
    name: str
    description: Union[str, None] = None
    price: float
    tax: Union[float, None] = None
    tags: Set[str] = set()
    images: Union[List[Image], None] = None


@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item):
    results = {"item_id": item_id, "item": item}
    return results

入參像這樣：

{
    "name": "Foo",
    "description": "The pretender",
    "price": 42.0,
    "tax": 3.2,
    "tags": [
        "rock",
        "metal",
        "bar"
    ],
    "images": [
        {
            "url": "http://example.com/baz.jpg",
            "name": "The Foo live"
        },
        {
            "url": "http://example.com/dave.jpg",
            "name": "The Baz"
        }
    ]
}

新增示例請求

通過Config和schema_extra新增示例請求：

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

    class Config:
        schema_extra = {
            "example": {
                "name": "Foo",
                "description": "A very nice Item",
                "price": 35.4,
                "tax": 3.2,
            }
        }


@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item):
    results = {"item_id": item_id, "item": item}
    return results

在使用以下任一時，都可以新增example：

Path()
Query()
Header()
Cookie()
Body()
Form()
File()

比如：

from typing import Union

from fastapi import FastAPI
from pydantic import BaseModel, Field

app = FastAPI()


class Item(BaseModel):
    name: str = Field(example="Foo")
    description: Union[str, None] = Field(default=None, example="A very nice Item")
    price: float = Field(example=35.4)
    tax: Union[float, None] = Field(default=None, example=3.2)


@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item):
    results = {"item_id": item_id, "item": item}
    return results

from typing import Union

from fastapi import Body, FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: Union[str, None] = None
    price: float
    tax: Union[float, None] = None


@app.put("/items/{item_id}")
async def update_item(
    item_id: int,
    item: Item = Body(
        example={
            "name": "Foo",
            "description": "A very nice Item",
            "price": 35.4,
            "tax": 3.2,
        },
    ),
):
    results = {"item_id": item_id, "item": item}
    return results

from typing import Union

from fastapi import Body, FastAPI
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str
    description: Union[str, None] = None
    price: float
    tax: Union[float, None] = None


@app.put("/items/{item_id}")
async def update_item(
    *,
    item_id: int,
    item: Item = Body(
        examples={
            "normal": {
                "summary": "A normal example",
                "description": "A **normal** item works correctly.",
                "value": {
                    "name": "Foo",
                    "description": "A very nice Item",
                    "price": 35.4,
                    "tax": 3.2,
                },
            },
            "converted": {
                "summary": "An example with converted data",
                "description": "FastAPI can convert price `strings` to actual `numbers` automatically",
                "value": {
                    "name": "Bar",
                    "price": "35.4",
                },
            },
            "invalid": {
                "summary": "Invalid data is rejected with an error",
                "value": {
                    "name": "Baz",
                    "price": "thirty five point four",
                },
            },
        },
    ),
):
    results = {"item_id": item_id, "item": item}
    return results

額外資料型別

FastAPI除了支援常見的資料型別：

int
float
str
bool

還支援額外的資料型別：

UUID
datetime.datetime
datetime.date
datetime.time
datetime.timedelta
frozenset
bytes
Decimal

示例：

from datetime import datetime, time, timedelta
from typing import Union
from uuid import UUID

from fastapi import Body, FastAPI

app = FastAPI()


@app.put("/items/{item_id}")
async def read_items(
    item_id: UUID,
    start_datetime: Union[datetime, None] = Body(default=None),
    end_datetime: Union[datetime, None] = Body(default=None),
    repeat_at: Union[time, None] = Body(default=None),
    process_after: Union[timedelta, None] = Body(default=None),
):
    start_process = start_datetime + process_after
    duration = end_datetime - start_process
    return {
        "item_id": item_id,
        "start_datetime": start_datetime,
        "end_datetime": end_datetime,
        "repeat_at": repeat_at,
        "process_after": process_after,
        "start_process": start_process,
        "duration": duration,
    }

from typing import Union

from fastapi import Cookie, FastAPI

app = FastAPI()


@app.get("/items/")
async def read_items(ads_id: Union[str, None] = Cookie(default=None)):
    return {"ads_id": ads_id}

跟Query和 Path用法類似。

from typing import Union

from fastapi import FastAPI, Header

app = FastAPI()


@app.get("/items/")
async def read_items(user_agent: Union[str, None] = Header(default=None)):
    return {"User-Agent": user_agent}

多重header用List，比如：

from typing import Union

from fastapi import FastAPI, Header

app = FastAPI()


@app.get("/items/")
async def read_items(user_agent: Union[str, None] = Header(default=None)):
    return {"User-Agent": user_agent}

X-Token: foo
X-Token: bar

{
    "X-Token values": [
        "bar",
        "foo"
    ]
}

響應模型

通過response_model定義返回模型：

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/", response_model=Item)
async def create_item(item: Item):
    return item

response_model的作用是對函式返回值進行過濾，比如：

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


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

函式返回值是UserIn模型的物件user，而response_model的值為UserOut（UserOut相比於UserIn來說，沒有password），那麼FastAPI的響應，就是用UserOut對UserIn進行了過濾，返回的是沒有password的UserOut。

響應模型可以返回預設值：

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: float = 10.5
    tags: List[str] = []


items = {
    "foo": {"name": "Foo", "price": 50.2},
    "bar": {"name": "Bar", "description": "The bartenders", "price": 62, "tax": 20.2},
    "baz": {"name": "Baz", "description": None, "price": 50.2, "tax": 10.5, "tags": []},
}


@app.get("/items/{item_id}", response_model=Item, response_model_exclude_unset=True)
async def read_item(item_id: str):
    return items[item_id]

response_model_exclude_unset=True不返回未顯式設定的欄位，response_model_exclude_defaults不返回帶預設值的欄位，response_model_exclude_none不返回None的欄位。

附加模型

在上面的示例中，UserIn是入參，UserOut是出參，不包含password，但是在實際情況中，還需要第三個模型UserInDB，在存入資料庫時，把password進行加密。

程式碼實現如下：

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

重點是user_in_db = UserInDB(**user_in.dict(), hashed_password=hashed_password)裡面的**user_in.dict()。

user_in是UserIn類的Pydantic模型，它有個dict()方法能返回字典。**是拆包，把字典拆成key value的形式，上面這行程式碼等價於：

UserInDB(
    username="john",
    password="secret",
    email="[email protected]",
    full_name=None,
    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的一大設計原則是儘量減少重複程式碼，所以對於UserIn、UserOut、UserInDB可以把裡面的相同欄位抽象為一個UserBase，其他Model繼承即可：

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

response_model除了定義一個Model以外，也能定義多個附加模型。

比如Union：

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 = "car"


class PlaneItem(BaseItem):
    type = "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]

比如List：

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：

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}

參考資料：

https://fastapi.tiangolo.com/

FastAPI官方教程太棒了（上）

Python第三流行的Web框架

FastAPI特性

安裝

執行

pydantic

路徑引數

查詢引數

請求體

查詢引數字串校驗

路徑引數數字校驗

請求體-多引數

請求體-欄位

請求體-巢狀模型

新增示例請求

額外資料型別

Header

響應模型

附加模型

FastAPI官方教程太棒了（上）

MySQL面試題全在這裡了（上）

19 | 案例篇：為什麼系統的Swap變高了（上）

19-案例篇：為什麼系統的Swap變高了（上）

覆盤今年Java架構師面試常問知識點（3000頁）+面試題（1000道）站在巨人的肩膀上，太棒了！

我以為我懂了系列之SpringSecurity（上）

史上最簡單的MySQL資料備份與還原教程（上）（三十五）

Java基礎教程----面向物件（上）----面向物件的特徵一：封裝性、

《手把手教你》系列基礎篇之（三）-java+ selenium自動化測試- 啟動三大瀏覽器（上）（詳細教程）

動力節點—2020最新Spring教程筆記（上）

臥槽！快取的問題太多了（雪崩、擊穿、穿透…）一個個解決！

喬治·馬丁盛讚《艾爾登法環》：這遊戲實在太棒了

第二天-表單及高階教程（上）

《艾爾登法環攻略》人物誌：殺我你後悔了嗎？門衛葛托克（上）

米哈遊終於捨得更新了！原神2.7新增128個世界聊天表情包（上）

我們的久誠太棒了

TSCTF2022（先挖個坑，太忙了嗚嗚嗚）

給小白的 PostgreSQL 容器化部署教程（上）

.NET7之MiniAPI(特別篇) ：Preview5優化了JWT驗證（上）

B社總監大讚《塞爾達：曠野之息》：很出色太棒了

FastAPI官方教程太棒了（上）

Python第三流行的Web框架

FastAPI特性

安裝

執行

pydantic

路徑引數

查詢引數

請求體

查詢引數字串校驗

路徑引數數字校驗

請求體-多引數

請求體-欄位

請求體-巢狀模型

新增示例請求

額外資料型別

Cookie

Header

響應模型

附加模型

相關推薦