FastAPI代码片段-02-认识请求

案例1

# FindSeaGoods.py
from fastapi import FastAPI
import uvicorn

app = FastAPI()
goods_table = {'野生大黄鱼': [20, '斤', 168],
               '对虾': [100, '斤', 48],
               '比目鱼': [200, '斤', 69],
               '黄花鱼': [500, '斤', 21]}


@app.get("/goods/")  # 注册路由路径
async def findGoods(name):  # 定义路径操作函数

    return name + '' + str(goods_table[name])


if __name__ == '__main__':
    uvicorn.run(app=app)

案例2

# FindSeaGoods1.py
import uvicorn
from fastapi import FastAPI
from pydantic import BaseModel  # 导入基础模型类


class Goods(BaseModel):  # 定义数据模型类，继承自BaseModel类
    name: str  # 定义字段name，类型 str
    num: float  # 定义字段num，类型float
    unit: str  # 定义字段unit，类型 str
    price: float  # 定义字段price，类型float


app = FastAPI()


@app.put("/goods/")  # 注册路由路径
async def findGoods(name, good: Goods):  # 定义路径操作函数

    return good


if __name__ == '__main__':
    uvicorn.run(app=app)

案例3

# 第二章 实验代码 exam02.py
from fastapi import FastAPI
import uvicorn
from typing import Optional
from pydantic import BaseModel
class Fruit(BaseModel):
    id: Optional[int]
    name: str = '菠萝'
    amount: int = 10
    price: Optional[float] = 9.0

app = FastAPI()

@app.post("/additem/{item_id}", response_model=Fruit)
async def additem(item_id: int, amount: Optional[int], item: Fruit):
    result = {'item_id': item_id, **item.dict()}
    if amount:
        result.update({'amount': amount})
    return result
if __name__ == "__main__":
    uvicorn.run(app=app)

基础代码

# 【示例2.1】 第二章 第2.2.1节 code2_1.py
from fastapi import FastAPI
import uvicorn
app = FastAPI()                  # 创建应用实例

@app.get("/items/{item_id}")     # 注册路由路径，使用{}定义路径参数，参数名为item_id
async def read_item(item_id):    # 函数操作函数中定义同名的路径参数
    print(item_id)               # 打印路径参数值
    return {"item_id": item_id}  # 用return关键字，将得到的参数返回给浏览器端

if __name__ == '__main__':
    uvicorn.run(app=app)

# 【示例2.2】 第二章 第2.2.2节 code2_2.py
from fastapi import FastAPI
import uvicorn
app = FastAPI()                  # 创建应用实例

@app.get("/items/{item_id}")     # 注册路由路径，使用{}定义路径参数，参数名为item_id
async def read_item(item_id: int):    # 函数操作函数中定义同名的路径参数
    print(item_id)               # 打印路径参数值
    return {"item_id": item_id}  # 用return关键字，将得到的参数返回给浏览器端

if __name__ == '__main__':
    uvicorn.run(app=app)

# 【示例2.3】 第二章 第2.2.4节 code2_3.py
from fastapi import FastAPI
import uvicorn

app = FastAPI()

@app.get("/users/me")                       # 注册静态路由路径 /users/me
async def read_user_me():
    return {"user_id": "the current user"}

@app.get("/users/{user_id}")               # 注册路由路径 /users/{user_id}
async def read_user(user_id: str):         # 定义路径参数user_id,类型str
    return {"user_id": user_id}

if __name__ == '__main__':
    uvicorn.run(app=app)

# 【示例2.4】 第二章 第2.2.5节 code2_4.py
from enum import Enum

from fastapi import FastAPI
import uvicorn

class ModelName(str, Enum):                 # 定义枚举类，继承str，Enum
    alexnet = "alexnet"
    resnet = "resnet"
    lenet = "lenet"

app = FastAPI()

@app.get("/models/{model_name}")             # 注册路由路径，包含一个路径参数model_name
async def get_model(model_name: ModelName):  # 参数类型是上面定义的枚举类
    if model_name == ModelName.alexnet:      # 使用枚举类型比较
        return {"model_name": model_name, "message": "深度学习模型精英：AlexNet!"}

    if model_name.value == "lenet":          # 使用值比较
        return {"model_name": model_name, "message": "深度学习模型元老：LeNet！"}

    return {"model_name": model_name, "message": "深度学习模型新秀：ResNet！"}

if __name__ == '__main__':
    uvicorn.run(app=app)

# 【示例2.5】 第二章 第2.3.1节 code2_5.py
from fastapi import FastAPI
import uvicorn

app = FastAPI()

# 定义列表items
items= [{"name": "泰迪"}, {"name": "科基"}, {"name": "加菲"}, {"name": "斗牛"}, {"name": "英短"}]

@app.get("/items/")                                   # 注册路由路径，未定义路径参数
async def read_item(skip: int = 0, limit: int = 10):  # 定义了两个参数，参数类型 int
    print('参数skip:', skip)
    print('参数limit:', limit)
    return items[skip : skip + limit]  # 用下标方式从列表items中取出数据

if __name__ == '__main__':
    uvicorn.run(app=app)

# 【示例2.6】 第二章 第2.3.2节 code2_6.py
from typing import Optional
import uvicorn
from fastapi import FastAPI

app = FastAPI()

@app.get("/items/{item_id}")         # 注册路由路径，定义路径参数
async def read_item(                 # 定义路径操作函数
        item_id: str,                # 定义路径参数item_id,参数类型str
        q: Optional[str] = None      # 定义可选查询参数q，参数类型str，默认值None
):
    if q:                            # 传入可选查询参数时，并返回item_id, q
        return {"item_id": item_id, "q": q}
    return {"item_id": item_id}      # 未传入可选查询参数时，返回item_id

if __name__ == '__main__':
    uvicorn.run(app=app)

# 【示例2.7】 第二章 第2.3.3节 code2_7.py
from fastapi import FastAPI
import uvicorn
app = FastAPI()

@app.get("/items/{item_id}")                       # 注册路由路径，定义了路径参数item_id
async def read_user_item(                          # 定义路径操作函数
        item_id: str,                              # 定义路径参数
        q: str                                     # 定义查询参数
):
    return {"item_id": item_id, "q": q}            # 返回参数值

if __name__ == '__main__':
    uvicorn.run(app=app)

# 【示例2.8】 第二章 第2.3.4节 code2_8.py
from typing import Optional
import uvicorn
from fastapi import FastAPI

app = FastAPI()

@app.get("/items/{item_id}")      # 注册路由路径，定义路径参数item_id
async def read_item(              # 定义路径操作函数
        item_id: str,             # 定义路径参数， 类型str
        q: Optional[str] = None,  # 定义可选查询参数， 类型str
        short: bool = False       # 定义查询参数，类型bool，默认值False
):
    item = {"item_id": item_id}   # 创建对象item，赋值路径参数
    if q:                         # 当传入了可选查询参数q时，更新item
        item.update({"q": q})
    if not short:                 # 当传入了查询参数short，并且其值为True时，更新数据
        item.update(
            {"description": "这是一个神奇的东西，而且名字还特别长"}
        )
    return item                   # 返回数据

if __name__ == '__main__':
    uvicorn.run(app=app)

# 【示例2.9】 第二章 第2.3.5节 code2_9.py
from typing import Optional
from fastapi import FastAPI
import uvicorn
app = FastAPI()

@app.get("/users/{user_id}/items/{item_id}")  # 注册路由路径，定义两个路径参数
async def read_user_item(      # 定义路径操作函数
    user_id: int,              # 定义路径参数，类型int
    item_id: str,              # 定义路径参数，类型str
    q: Optional[str] = None,   # 定义可选查询参数，类型str
    short: bool = False        # 定义带默认值的查询参数，类型bool
):
    item = {"item_id": item_id, "owner_id": user_id}
    if q:
        item.update({"q": q})
    if not short:
        item.update(
            {"description": "这是一个神奇的东西，而且名字还特别长"}
        )
    else:
        item.update({'short': short})
    return item

if __name__ == '__main__':
    uvicorn.run(app=app)

# 【示例2.10】 第二章 第2.4.1节 code2_10.py
from typing import Optional
import uvicorn
from fastapi import FastAPI
from pydantic import BaseModel         #导入基础模型类

class Item(BaseModel):                 # 定义数据模型类，继承自BaseModel类
    name: str                          #定义字段name，类型 str
    description: Optional[str] = None  #定义可选字段description，类型str
    price: float                       #定义字段price，类型float
    tax: Optional[float] = None        #定义可选字段tax，类型float

app = FastAPI()

@app.post("/items/")                  #注册路由路径，请求方式为post，不是get
async def create_item(item: Item):    #定义请求体，类型是数据模型类Item
    return item                       #直接返回请求体数据

if __name__ == '__main__':
    uvicorn.run(app=app)

# 【示例2.11】 第二章 第2.4.2节 code2_11.py
from typing import Optional
import uvicorn
from fastapi import FastAPI
from pydantic import BaseModel

class Item(BaseModel):                    # 定义数据模型类，继承自BaseModel类
    name: str                             # 定义字段name 类型str
    description: Optional[str] = None     # 定义可选字段description 类型str
    price: float                          # 定义字段price 类型float
    tax: Optional[float] = None           # 定义可选字段tax 类型float
app = FastAPI()
@app.post("/items/{item_id}")               # 注册路由，定义路径参数item_id
async def create_item(                      # 定义路径操作函数
item_id: int,                               # 定义路径参数，类型int
item: Item,                                 # 定义请求体，类型是数据模型
q: Optional[str] = None                     # 定义可选查询参数，类型str
):
    result = {"item_id": item_id, **item.dict()}  # 将路径参数和请求体参数组合为数据对象
    if q:
        result.update({"q": q})                   # 如果传入了查询参数，则更新查询参数
    return result                                 # 返回组合好的数据对象
if __name__ == '__main__':
    uvicorn.run(app=app)

# 【示例2.12】 第二章 第2.4.3节 code2_12.py
from typing import Optional
import uvicorn
from fastapi import FastAPI, Path
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):                # 定义数据模型类，继承自BaseModel
    name: str                         # 定义字段name，类型str
    description: Optional[str] = None # 定义可选字段description，类型str
    price: float                      # 定义字段price，类型float
    tax: Optional[float] = None       # 定义可选字段tax，类型float

@app.put("/items/{item_id}")          # 注册路由路径，使用PUT方法，定义路径参数
async def update_item(
    *,                                # python语法，表示后面的参数都是键值对
    item_id: int = Path(..., title="元素ID", ge=0, le=1000),  #路径参数，类型int，大于等于0小于等于1000
    q: Optional[str] = None,          # 可选查询参数，类型str
    item: Optional[Item] = None,      # 请求体，可选参数
):
    results = {"item_id": item_id}
    if q:
        results.update({"q": q})
    if item:
        results.update({"item": item})
    return results                 #  将各个请求参数组合在一起返回
if __name__ == '__main__':
    uvicorn.run(app=app)

# 【示例2.13】 第二章 第2.4.4节 code2_13.py
from typing import Optional
import uvicorn
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):                # 定义数据模型Item，继承自BaseModel
    name: str                         # 字义字段name， 类型 str
    description: Optional[str] = None # 定义可选字段description， 类型str
    price: float                      # 定义字段price， 类型float
    tax: Optional[float] = None       # 定义可选字段tax 类型float

class User(BaseModel):                # 定义数据模型User，继承自BaseModel
    username: str                     # 定义字段username，类型str
    full_name: Optional[str] = None   # 定义可选字段full_name，类型str

@app.put("/items/{item_id}")          # 注册路由路径，使用PUT方法，定义路径参数item_id
async def update_item(                # 定义路径操作函数
        item_id: int,                 # 定义路径参数
        item: Item,                   # 定义第一个请求体
        user: User                    # 定义第二个请求体
):
    results = {"item_id": item_id, "item": item, "user": user}
    return results

if __name__ == '__main__':
    uvicorn.run(app=app)

# 【示例2.14】 第二章 第2.4.5节 code2_14.py
from typing import Optional
import uvicorn
from fastapi import Body, FastAPI   # 导入Body
from pydantic import BaseModel

app = FastAPI()

class Item(BaseModel):                # 定义数据模型Item，继承自BaseModel
    name: str                         # 字义字段name， 类型 str
    description: Optional[str] = None # 定义可选字段description， 类型str
    price: float                      # 定义字段price， 类型float
    tax: Optional[float] = None       # 定义可选字段tax 类型float

class User(BaseModel):                # 定义数据模型User，继承自BaseModel
    username: str                     # 定义字段username，类型str
    full_name: Optional[str] = None   # 定义可选字段full_name，类型str

@app.put("/items/{item_id}")          # 注册路由路径，使用PUT方法，定义路径参数item_id
async def update_item(                # 定义路径操作函数
    item_id: int,                     # 定义路径参数
    item: Item,                       # 定义第一个请求体
    user: User,                       # 定义第一个请求体
    importance: int = Body(..., gt=0)  # 使用Body设置第3个请求体，类型int
):
    results = {"item_id": item_id, "item": item, "user": user, "importance": importance}
    return results

if __name__ == '__main__':
    uvicorn.run(app=app)

# 【示例2.15】 第二章 第2.5.1节 code2_15.py
from fastapi import FastAPI, Form  # 导入Form对象
import uvicorn
app = FastAPI()

@app.post("/login/")              # 注册路由路径
async def login(                  # 定义路径操作函数
        username: str = Form(...), # 定义查询参数，数据类型是str，初始值Form
        password: str = Form(...)  # 定义查询参数，数据类型是str，初始值Form
):
    ...                            # 处理登录的代码
    return {"username": username}

if __name__ == '__main__':
    uvicorn.run(app=app)

# 【示例2.16】 第二章 第2.5.2节 code2_16.py
from fastapi import FastAPI, File, UploadFile
import uvicorn
app = FastAPI()

@app.post("/files/")                 # 注册路由路径
async def create_file(               # 定义路径操作函数，第一种上传方式
        file: bytes = File(...)      # 定义文件参数，数据类型为bytes，初始值是File
):
    return {"file_size": len(file)}  # 返回文件大小

@app.post("/uploadfile/")            # 注册路由路径
async def create_upload_file(        # 定义路径操作函数，第二种上传方式
        file: UploadFile = File(...) # 定义文件参数，数据类型为UploadFile，初始值为File
):
    return {"filename": file.filename}  # 返回原始文件名
if __name__ == '__main__':
    uvicorn.run(app=app)

# 【示例2.17】 第二章 第2.5.3节 code2_17.py
from fastapi import FastAPI, File, Form, UploadFile
import uvicorn
app = FastAPI()

@app.post("/files/")                  # 注册路由路径
async def create_file(                # 定义路径操作函数
        file: UploadFile = File(...), # 定义文件，类型UploadFile
        file2: UploadFile = File(...), # 定义文件2，类型UploadFile
        token: str = Form(...)        # 定义表单数据
):
    return {
        "token": token,
        "fileb_content_type": file.filename,
        "fileb_content_type": file.content_type,
    }
if __name__ == '__main__':
    uvicorn.run(app=app)