FastAPI 4 - Response

已于 2023-07-29 10:18:32 修改
阅读量686 收藏
点赞数
分类专栏： # Python 文章标签： fastapi response
于 2021-12-15 12:23:18 首次发布
原文链接：https://github.com/oinsd/FastAPI-Learning-Example
版权
本文介绍了FastAPI中的响应模型，包括响应状态码、错误处理机制，如基本错误处理、自定义异常处理、覆盖原有错误和请求验证错误。此外，还讲解了json兼容编码器的使用以及Body的更新操作，如PUT和PATCH方法的应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

文章目录

from : https://www.bilibili.com/video/BV1oE411M7tF

一、响应模型

No.18

1、

from typing import List

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()


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


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

if __name__ == '__main__':
    import uvicorn
    uvicorn.run(app, host="127.0.0.1", port=8000)

import requests
import json

def test1():
    url = 'http://127.0.0.1:8000/items/'
    body =   {
  "name": "string",
  "description": "string",
  "price": 0,
  "tax": 0,
  "tags": ['1']
} 
    data = json.dumps(body)
    ret = requests.post(url=url, data=data)

    print(ret)
    print(ret.text) # {"name":"string","description":"string","price":0.0,"tax":0.0,"tags":["1"]}

 

if __name__ == "__main__":

    test1()

2

需要安装

pip install pydantic[email]

from fastapi import FastAPI
from pydantic import BaseModel, EmailStr

app = FastAPI()


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


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


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



def test1():
    url = 'http://127.0.0.1:8000/user/'
    body =   {
            "username": "string",
            "password": "string",
            "email": "user@example.com",
            "full_name": "string"
            }
    data = json.dumps(body)
    ret = requests.post(url=url, data=data)

    print(ret)
    print(ret.text) # {"username":"string","email":"user@example.com","full_name":"string"}

三、响应状态码

from fastapi import FastAPI
from starlette import status

app = FastAPI()


@app.post("/items/", status_code=201)
async def create_item(name: str):
    return {"name": name}
'''
post http://127.0.0.1:8000/items/?name=123
<Response [201]>
{"name":"123"}
'''

@app.get("/items2/", status_code=201)
async def create_item2(name: str):
    return {"name": name}
'''
get  http://127.0.0.1:8000/items2/?name=123
<Response [201]>
{"name":"123"}
'''


@app.post("/items3/", status_code=status.HTTP_404_NOT_FOUND)
async def create_item3(name: str):
    print('HTTP_404:', status.HTTP_404_NOT_FOUND)
    return {"name": name}
'''
post http://127.0.0.1:8000/items3/?name=123
<Response [404]>
{"name":"123"}

'''

@app.get("/i/", status_code=status.HTTP_404_NOT_FOUND)
async def i(name: str):
    print('HTTP_404:', status.HTTP_404_NOT_FOUND)
    return {"name": name}
'''
get http://127.0.0.1:8000/i/?name=123
<Response [404]>
{"name":"123"}
'''

if __name__ == '__main__':
    import uvicorn
    uvicorn.run(app, host="127.0.0.1", port=8000)

四、错误处理

1、基本错误处理

from fastapi import FastAPI, HTTPException

app = FastAPI()

items = {"foo": "The Foo Wrestlers"}


@app.get("/items/{item_id}")
async def read_item(item_id: str):
    if item_id not in items:
        raise HTTPException(status_code=404, detail="Item not found")
    pass
    pass
    return {"item": items[item_id]}
'''
get http://127.0.0.1:8000/items/hi
<Response [404]>
{"detail":"Item not found"}

get http://127.0.0.1:8000/items/foo 
<Response [200]>
{"item":"The Foo Wrestlers"}
'''


# 添加自定义标题
@app.get("/items-header/{item_id}")
async def read_item_header(item_id: str):
    if item_id not in items:
        raise HTTPException(
            status_code=404,
            detail="Item not found",
            headers={"X-Error": "There goes my error"}, 
            # X-Error 自定义。例如，对于某些类型的安全性。OAuth 2.0和某些安全实用程序在内部需要/使用此功能。
        )
    return {"item": items[item_id]}

'''
get http://127.0.0.1:8000/items-header/foo
<Response [200]>
{"item":"The Foo Wrestlers"}

get http://127.0.0.1:8000/items-header/jack
<Response [404]>
{"detail":"Item not found"}
'''

2、安装自定义异常处理程序

使用装饰器

from fastapi import FastAPI
# from fastapi import FastAPI, Request
# from fastapi.responses import JSONResponse
from starlette.requests import Request
from starlette.responses import JSONResponse

# 安装自定义异常处理程序
# 自定义异常UnicornException
class UnicornException(Exception):  # Exception 常规错误的基类
    def __init__(self, name: str):
        self.name = name

app = FastAPI()

@app.exception_handler(UnicornException)
async def unicorn_exception_handler(request: Request, exc: UnicornException):
    return JSONResponse(
        status_code=404, # 418 I'm a teapot
        content={"message": f"Oops! {exc.name} did something. There goes a rainbow..."},
    )


@app.get("/unicorns/{name}")
async def read_unicorn(name: str):
    if name == "yolo":
        raise UnicornException(name=name)
    return {"unicorn_name": name}

'''
get http://127.0.0.1:8000/unicorns/jack
<Response [200]>
{"unicorn_name":"jack"}

get http://127.0.0.1:8000/unicorns/yolo
<Response [404]>
{"message":"Oops! yolo did something. There goes a rainbow..."}
'''

3、覆盖原有错误

from fastapi import FastAPI, HTTPException
from fastapi.exceptions import RequestValidationError
# from fastapi.responses import PlainTextResponse
from starlette.responses import PlainTextResponse
from starlette.exceptions import HTTPException as StarletteHTTPException

app = FastAPI()

# 覆盖默认的异常处理程序
@app.exception_handler(StarletteHTTPException)  # 重写HTTPException错误处理程序
async def http_exception_handler(request, exc):
    return PlainTextResponse(str(exc.detail), status_code=exc.status_code)


@app.exception_handler(RequestValidationError)  # 导入超越请求验证异常
async def validation_exception_handler(request, exc):
    return PlainTextResponse(str(exc), status_code=400)


@app.get("/items/{item_id}")
async def read_item(item_id: int):
    if item_id == 3:
        raise HTTPException(status_code=418, detail="Nope! I don't like 3.") # 418 I'm a teapot
    return {"item_id": item_id}
'''
get http://127.0.0.1:8000/items/4
<Response [200]>
{"item_id":4}

get http://127.0.0.1:8000/items/3 
<Response [418]>
Nope! I don't like 3.
'''

4、请求验证错误

from fastapi import FastAPI
# from fastapi import FastAPI, Request, status
from starlette.requests import Request
from starlette import status
from fastapi.encoders import jsonable_encoder
from fastapi.exceptions import RequestValidationError
# from fastapi.responses import JSONResponse
from starlette.responses import JSONResponse
from pydantic import BaseModel

app = FastAPI()


@app.exception_handler(RequestValidationError)  # 请求验证错误
async def validation_exception_handler(request: Request, exc: RequestValidationError):
    return JSONResponse(
        # 拿出错误重写
        status_code=status.HTTP_422_UNPROCESSABLE_ENTITY,
        content=jsonable_encoder({"detail": exc.errors(), "body": exc.body}),
    )


class Item(BaseModel):
    title: str
    size: int


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

def test1():
    url = 'http://127.0.0.1:8000/items/' 
    body = {
  "title": "string",
  "size": 0
}

    data = json.dumps(body)
    ret = requests.post(url=url, data=data)
    # ret = requests.post(url=url) 
    print(ret)
    print(ret.text)  # {"title":"string","size":0}



...
    body = {
  "title": "string",
  "size": "a" # 修改此处类型为非 int
}
...

<Response [422]>
{"detail":[{"loc":["body","size"],"msg":"value is not a valid integer","type":"type_error.integer"}],"body":{"title":"string","size":"a"}}

5、抽出异常和错误

from fastapi import FastAPI, HTTPException
from fastapi.exception_handlers import (
    http_exception_handler,
    request_validation_exception_handler,
)

from fastapi.exceptions import RequestValidationError
from starlette.exceptions import HTTPException as StarletteHTTPException

app = FastAPI()
# FastAPI、starlette都有自己的HTTPException，
# 区别是，FastAPI的HTTPException允许您添加要包含在响应头。OAuth 2.0和某些安全实用程序在内部需要/使用此功能。
@app.exception_handler(StarletteHTTPException)
async def custom_http_exception_handler(request, exc):
    print(f"OMG! An HTTP error!: {exc}")
    return await http_exception_handler(request, exc) # 重用Starlette的异常处理程序


@app.exception_handler(RequestValidationError) 
async def validation_exception_handler(request, exc):
    print(f"OMG! The client sent invalid data!: {exc}")
    return await request_validation_exception_handler(request, exc) # 重用FastAPI的异常处理程序


@app.get("/items/{item_id}")
async def read_item(item_id: int):
    if item_id == 3:
        raise HTTPException(status_code=418, detail="Nope! I don't like 3.") # 418 I'm a teapot
    return {"item_id": item_id}
    
'''
get http://127.0.0.1:8000/items/3
<Response [418]>
{"detail":"Nope! I don't like 3."}

get http://127.0.0.1:8000/items/ab 
<Response [422]>
{"detail":[{"loc":["path","item_id"],"msg":"value is not a valid integer","type":"type_error.integer"}]}
'''

五、json 兼容编码器

from datetime import datetime

from fastapi import FastAPI
from fastapi.encoders import jsonable_encoder
from pydantic import BaseModel

fake_db = {}


class Item(BaseModel):
    title: str
    timestamp: datetime # datetime 是 python 格式
    description: str = None


app = FastAPI()


@app.put("/items/{id}")
def update_item(id: str, item: Item):
    json_compatible_item_data = jsonable_encoder(item)
    # jsonable_encoder实际上由FastAPI在内部用于转换数据。但这在许多其他情况下很有用。
    fake_db[id] = json_compatible_item_data
    print(json_compatible_item_data)
    print(type(json_compatible_item_data))
    print(fake_db)
    print(type(fake_db))
    # return fake_db




def test1():
    url = 'http://127.0.0.1:8000/items/a' 
    body = {
                "title": "string",
                "timestamp": "2021-12-15T06:29:52.037Z",
                "description": "string"
            }   

    data = json.dumps(body)
    ret = requests.put(url=url, data=data) 
    print(ret)
    print(ret.text)  # {"title":"string","size":0}


'''
{'title': 'string', 'timestamp': '2021-12-15T06:29:52.037000+00:00', 'description': 'string'}
<class 'dict'>

{'ab': {'title': 'string', 'timestamp': '2021-12-15T06:32:18.631000+00:00', 'description': 'string'}, 'a': {'title': 'string', 'timestamp': '2021-12-15T06:29:52.037000+00:00', 'description': 'string'}}
<class 'dict'>
'''

六、Body 的更新

1、put

put 更新已有的，没有的不添加

from typing import List

from fastapi import FastAPI
from fastapi.encoders import jsonable_encoder
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str = None
    description: str = None
    price: float = None
    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)
async def read_item(item_id: str):
    return items[item_id]


@app.put("/items/{item_id}", response_model=Item)
async def update_item(item_id: str, item: Item):
    update_item_encoded = jsonable_encoder(item)
    items[item_id] = update_item_encoded
    print(items)
    return update_item_encoded


def test1():
    url = 'http://127.0.0.1:8000/items/foo' 
    body = {
        # "name": "string",
        "description": "string",
        "price": 5,
        "tax": 11,
        "tags": []
        }

    data = json.dumps(body)
    ret = requests.put(url=url, data=data)
    # ret = requests.post(url=url) 
    print(ret)
    print(ret.text)   # {"name":null,"description":"string","price":5.0,"tax":11.0,"tags":[]}

2、 patch

局部更新

from typing import List

from fastapi import FastAPI
from fastapi.encoders import jsonable_encoder
from pydantic import BaseModel

app = FastAPI()


class Item(BaseModel):
    name: str = None
    description: str = None
    price: float = None
    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)
async def read_item(item_id: str):
    return items[item_id]


# patch 数据的局部更新
@app.patch("/items/{item_id}", response_model=Item)
async def update_item(item_id: str, item: Item):
    stored_item_data = items[item_id] # 存储项目数据
    stored_item_model = Item(**stored_item_data)   # 存储项目模型
    update_data = item.dict(exclude_unset=True)                 
    print('update_data', update_data) 
    updated_item = stored_item_model.copy(update=update_data)
    # print('update_item', update_item)
    print('updated_item', jsonable_encoder(updated_item)) 
    items[item_id] = jsonable_encoder(updated_item)
    print('items[item_id]', items[item_id])#
    return updated_item


def test1():
    url = 'http://127.0.0.1:8000/items/foo' 
    body = {
        # "name": "string",
        "description": "string",
        "price": 5,
        "tax": 11,
        "tags": []
        }

    data = json.dumps(body)
    ret = requests.patch(url=url, data=data)
    # ret = requests.post(url=url) 
    print(ret)
    print(ret.text)  # {"name":"Foo","description":"string","price":5.0,"tax":11.0,"tags":[]}

伊织 2021-12-15（三）
凌晨下了小雨，白天又没下了，期望下雨
没去上班

开源模型应用落地-Gradio正确集成Fastapi-助力模型交互-实践篇（二）
没有卑微的工作，只有卑微的心态，与其抱怨，不如埋头实干
05-22 1万+
Gradio与Fastapi正确集成，qwen1.5-7b-chat模型实践，同时提供界面交互和接口服务两种能力
fastAPI响应模型：response_model
zhengzaifeidelushang的博客
09-30 548
fastAPI响应模型：response model一、输出数据转化为模型格式数据 fastAPI响应模型response model作用： 将输出数据转化为模型的数据 一、输出数据转化为模型格式数据 from fastapi import FastAPI,APIRouter from pydantic import BaseModel,Field from typing import Optional,Union,List import uvicorn class Stuinfo(BaseMode
Python框架篇(3):FastApi-响应模型
weixin_68789096的博客
01-03 1215
在..."""学生信息"""name: constr(min_length=2, max_length=4) # 长度age: conint(ge=18, le=30) # 整数范围：18
13.FastAPI Response对象
chenhaiy的博客
01-18 3127
13.FastAPI Response对象 在某些情况下，可能会需要对请求返回特定的数据，而不是采用默认的方式，此时，就可以直接使用Response对象。在FastAPI中，可以在路由操作函数声明一个fastapi.Response类型的参数，然后在函数的代码直接操作Response对象。 13.1更改响应状态码 可以在路由操作函数中，通过对Response对象的 status_code 赋值来修改响应状态码，代码如下： from fastapi import FastAPI from fasta
FastAPI系列06：FastAPI响应（Response）
最新发布
GeekABC
04-27 1030
本节我们通过FastAPI实现大文件断点续传等示例，来详细讨论FastAPI响应。
FastAPI之响应模型
silk_java的专栏
12-11 1005
响应模型我认为最主要的作用就是在自动化文档的显示时，可以直接给查看文档的小伙伴显示返回的数据格式。对于后端开发的伙伴来说，其编码的实际意义不大，但是为了可以不用再额外的提供文档，我们只需要添加一个，还是很爽的。
FastAPI学习-21.response 参数-设置响应Cookies
qq_27371025的博客
09-17 601
前言 可以在路径函数中定义一个类型为Response的参数，这样你就可以在这个临时响应对象中设置cookie了。 response 参数 设置cookies from fastapi import FastAPI, Response app = FastAPI() @app.post("/cookie-and-object/") def create_cookie(response:...
No.63-FastApi中的Response使用response_model序列化字段
洛水之风的博客
12-05 844
温馨提示: 读完本文大约需要 3 分钟； 这是一篇技术类文章； 需要对fastapi有一定的了解； 代码部分横屏观看更佳。 前言 前面介绍了header和cookie的使用方法，也介绍了请求参数的几种传递方法：query body path，今天这篇文章将介绍如何自定义返回字段。 response_model 适用于哪些请求方法 restfulapi 规范内定义的方法基本都适用，例如： @app.get() @app.post() @app.put() @app.delete() 举个简单的例子 f
fastapi-template:正确的FastAPI设置可加快您的开发速度！
03-28
**FastAPI 模板：加速你的开发流程** FastAPI 是一个现代、高性能的 Web 框架，用于构建 API。它基于 Python 3.6+，利用了 Pydantic 进行数据验证和模型化，提供了简洁而强大的接口定义方式。在本文中，我们将深入...
FastAPI学习-ResponseModel响应模型
愤怒的小兵
03-28 2567
FastAPI源码分析-ResponseModel响应模型 ResponseModel响应模型，可用在GET/POST/PUT/DELETE方法中。 ResponseModel响应模型的声明，和RequestBody一样使用BaseModel，只是传入时的位置不一样。 from fastapi import FastAPI from pydantic import BaseModel, Email...
FastAPI与Tortoise-ORM实现关系型数据库关联
04-21 1093
反向关系查询字段。
fastapi日志重复打印_FastAPI--响应报文(4)
weixin_39958631的博客
12-19 327
一、概述使用response_model定义请求一个接口返回来我们客户端可见的东西都是所谓的响应报文，如响应头，响应码，响应内容等。通常不会那么傻的用户输入什么就返回什么。以下的官网示例纯粹的演示看：importuvicornfrom fastapi importFastAPIfrom pydantic importBaseModel, EmailStrapp=FastAPI()classUser...
FastAPI 请求和响应
2401_89581675的博客
12-11 1714
在 FastAPI 中，请求（Request）和响应（Response）是与客户端交互的核心。 FastAPI 提供了强大的工具来解析请求数据，并根据需要生成规范的响应。 接下来我们来详细看下 FastAPI 的请求和响应。 请求数据 查询参数 以下实例中我们定义了一个/items/路由，接受两个查询参数skip和limit，它们的类型均为整数，默认值分别为0和10。
14.FastAPI响应头
chenhaiy的博客
01-18 1964
14.FastAPI响应头 14.1通过Response参数设置 可以通过Response参数的headers来设置标头。代码如下： from fastapi import FastAPI from fastapi import Response ​ app = FastAPI() ​ @app.get(path='/test') async def hello(response: Response): response.headers['X-Cat-Dog'] = 'world' ...
fastapi-请求与响应
奔跑的豆子的专栏
11-06 1430
FastAPI中的Request和Response是用于处理HTTP请求和响应的两个核心对象。它们提供了许多功能和属性，使你能够更灵活地处理和构建HTTP请求和响应。
FastAPI 学习之路（四十一）定制返回Response
mr~li的博客
07-11 717
我们看下实际返回：返回的类型是xml格式的，说明返回成功。
【python】fastapi response返回文本、音视频多媒体资源实现
qq_41604569的博客
04-06 6490
media解释返回HTMLimage/jpeg返回图片audio/mpeg返回音频video/mp4返回视频返回PDF。
全面拥抱 FastApi — 响应模型
Python编程与实战的博客
09-08 560
大家好，我是村长~~ 今日fastApi 干货来了，文末还有书籍赠送噢~~在 fastApi 中可以定义请求体body模型，关于这部分内容可以查看之前的文章 地址：同样的，fastApi...
fastapi X-Custom-Header
09-13
FastAPI中的`X-Custom-Header`通常指的是在HTTP请求或响应中设置或获取自定义的HTTP头字段。在FastAPI中，你可以通过定义函数参数或使用依赖项注入的方式来接收和设置自定义的HTTP头。 当你需要在FastAPI应用中获取自定义HTTP头时，可以将函数参数设置为`Header(...)`，这样FastAPI会自动从请求头中提取对应的字段。而如果你想在响应中添加一个自定义HTTP头，可以在返回响应时使用`response.headers`字典来设置。 示例代码如下： ```python from fastapi import FastAPI, Header app = FastAPI() @app.get("/items/") async def read_items(x_token: str = Header(...)): return {"X-Token values": x_token} @app.get("/users/me") async def read_user_me(response: Response): response.headers["X-Custom-Header"] = "MyValue" return {"message": "Hello World"} ``` 在上述例子中，`/items/` 路径操作期望从请求头中获取`X-Token`字段，并将其作为参数`x_token`传递给函数。而`/users/me`路径操作则在响应中添加了一个`X-Custom-Header`头。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值