fastapi list[dict]转list[BaseModel]

可以使用 FastAPI 中的 `BaseModel` 来定义模型，然后使用列表推导式将列表中的字典转换为模型的列表。以下是一个示例代码：

from typing import List
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

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

items = [
    {"name": "item one", "price": 9.99},
    {"name": "item two", "price": 19.99, "is_offer": True},
    {"name": "item three", "price": 29.99},
]

@app.get("/items/")
async def read_items():
    # 将列表中的字典转换为模型的列表
    item_models = [Item(**item) for item in items]
    return item_models

在上面的代码中，我们定义了一个 `Item` 模型，然后创建了一个包含字典的列表 `items`。在 `read_items` 路由中，我们使用列表推导式将 `items` 列表中的字典转换为 `Item` 模型的列表 `item_models`，最终返回这个列表。

相关问题

fastapi 新增数据库接口

### 如何在 FastAPI 中新增数据库接口的最佳实践

#### 1. 安装依赖库
为了使 FastAPI 应用程序能够连接并操作数据库，通常需要安装相应的 ORM 或者驱动工具。SQLAlchemy 是一种常用的 Python SQL 工具包和对象关系映射器 (ORM)，可以很好地与 FastAPI 集成。

pip install fastapi sqlalchemy databases uvicorn

#### 2. 创建项目结构
合理的文件夹布局有助于维护项目的清晰度：

project/
│
├── app/
│   ├── __init__.py
│   ├── main.py           # 主应用入口
│   ├── models.py        # 数据库模型定义
│   ├── schemas.py       # Pydantic 模型验证
│   └── crud.py          # CRUD 操作逻辑封装
└── alembic/             # 数据库迁移配置（可选）
    └── ...

#### 3. 初始化 SQLAlchemy 和 Databases 实例
`main.py` 文件中初始化必要的组件来管理数据库会话以及异步查询支持。

from typing import AsyncGenerator, Generator
import databases
import sqlalchemy
from fastapi import Depends, FastAPI
from pydantic import BaseModel

DATABASE_URL = "sqlite:///./test.db"

database = databases.Database(DATABASE_URL)

metadata = sqlalchemy.MetaData()

engine = sqlalchemy.create_engine(
    DATABASE_URL,
    connect_args={"check_same_thread": False}
)


def get_db() -> Generator:
    try:
        yield database
    finally:
        pass


app = FastAPI()


@app.on_event("startup")
async def startup():
    await database.connect()
    

@app.on_event("shutdown")
async def shutdown():
    await database.disconnect()

#### 4. 定义数据表模式
通过 `models.py` 来描述实体类及其字段属性，并将其映射到实际的关系型表格上。

from sqlalchemy import Column, Integer, String, Table, ForeignKey
from .main import metadata

users_table = Table(
    'users', metadata,
    Column('id', Integer, primary_key=True),
    Column('name', String(50)),
    Column('email', String(100))
)

#### 5. 构建 API 请求体校验规则
`schemas.py` 使用 Pydantic 提供的数据解析功能确保传入参数的有效性和一致性。

from pydantic import BaseModel, EmailStr

class UserCreate(BaseModel):
    name: str
    email: EmailStr
    
class UserRead(UserCreate):
    id: int

    class Config:
        orm_mode = True

#### 6. 封装基本增删改查函数
`crud.py` 负责处理具体的业务流程，比如插入新纪录、检索现有条目等。

from sqlalchemy.sql import select
from sqlalchemy.engine.base import Connection
from .schemas import UserCreate
from .models import users_table

async def create_user(conn: Connection, user: UserCreate) -> dict:
    query = users_table.insert().values(**user.dict())
    result = await conn.execute(query)
    return {**user.dict(), "id": result.lastrowid}

async def read_users(conn: Connection) -> list[dict]:
    query = select([users_table])
    results = await conn.fetch_all(query=query)
    return [{column: value for column, value in row.items()} for row in results]

#### 7. 设计 RESTful 接口路由
最后，在 `main.py` 添加路径处理器完成对外服务暴露。

from fastapi import HTTPException
from starlette.status import HTTP_404_NOT_FOUND
from .crud import create_user, read_users
from .schemas import UserCreate, UserRead

@app.post("/users/", response_model=UserRead)
async def post_create_user(user: UserCreate, db=Depends(get_db)):
    new_user = await create_user(db, user=user)
    return new_user


@app.get("/users/")
async def get_read_users(db=Depends(get_db)):
    all_users = await read_users(db)
    if not all_users:
        raise HTTPException(status_code=HTTP_404_NOT_FOUND, detail="No Users Found.")
    return {"data": all_users}

上述过程展示了如何构建一个简单的 FastAPI Web Service 并集成 SQLite 数据库存储能力[^1]。当然，具体实现细节可能因所选用的不同类型的数据库而有所差异；此外，考虑到生产环境下的性能优化需求，还可以引入诸如缓存机制、分页加载等功能特性进一步增强系统的健壮性。

fastapi接收json数据类型

在FastAPI中，您可以使用`pydantic`库定义模型来验证传入的JSON数据类型。以下是一些常见的JSON数据类型：

- 字符串：`str`
- 整数：`int`
- 浮点数：`float`
- 布尔值：`bool`
- 数组：`List`
- 字典：`Dict`

您可以使用这些类型来定义模型中的字段。例如，以下是一个使用不同类型定义的模型：

from typing import List, Dict
from pydantic import BaseModel

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

class User(BaseModel):
    username: str
    email: str
    full_name: str = None

class Order(BaseModel):
    items: List[Item]
    total_price: float
    user: User
    shipping_address: Dict[str, str]

在上面的示例中，我们定义了三个模型：`Item`，`User`和`Order`。`Item`模型包含三个字段：`name`，`price`和`is_offer`，其中`is_offer`的默认值为`None`。`User`模型包含三个字段：`username`，`email`和`full_name`，其中`full_name`的默认值为`None`。`Order`模型包含四个字段：`items`，`total_price`，`user`和`shipping_address`。`items`是一个`Item`类型的列表，`user`是一个`User`类型，`shipping_address`是一个字符串键和字符串值的字典。

当您在FastAPI路由函数中使用这些模型作为参数时，FastAPI将自动验证传入的JSON数据类型并进行转换。例如，以下是一个使用`Order`模型的路由函数：

@app.post("/orders/")
async def create_order(order: Order):
    return {"order": order, "total_items": len(order.items)}

在上面的示例中，我们使用`Order`模型作为`create_order`函数的参数。当客户端发送JSON数据到`/orders/`端点时，FastAPI将验证JSON数据的类型，并将其转换为`Order`对象。您可以像使用任何其他Python对象一样使用`order`对象，例如在响应中返回它或对其进行操作。