1
from pydantic import BaseModel
2

3
class TodoItem(BaseModel):
4
    title: str              # 必须是字符串，必填
5
    is_done: bool = False   # 必须是布尔值，默认为 False

1
POST /todos
2
{
3
  "title": "学习 FastAPI",
4
  "is_done": false
5
}

1
POST /todos
2
{
3
  "title": 123,
4
  "is_done": "yes"
5
}

1
{
2
  "detail": [
3
    {
4
      "loc": ["body", "title"],
5
      "msg": "str type expected",
6
      "type": "type_error.str"
7
    },
8
    {
9
      "loc": ["body", "is_done"],
10
      "msg": "value could not be parsed to a boolean",
11
      "type": "type_error.bool"
12
    }
13
  ]
14
}

1
from pydantic import BaseModel, Field
2
from typing import Optional
3

4
class TodoItem(BaseModel):
5
    # 字段描述（显示在文档中）
6
    title: str = Field(..., description="待办事项标题", min_length=1, max_length=100)
7

8
    # 可选字段
9
    description: Optional[str] = Field(None, description="详细描述")
10

11
    # 带默认值
12
    is_done: bool = Field(False, description="是否完成")
13

14
    # 数值范围
15
    priority: int = Field(1, ge=1, le=5, description="优先级 1-5")
16

17
# 创建实例
18
todo = TodoItem(title="学习", description="学习 FastAPI", priority=3)
19

20
# 转换为字典
21
data = todo.dict()
22
# {'title': '学习', 'description': '学习 FastAPI', 'is_done': False, 'priority': 3}
23

24
# 转换为 JSON
25
json_str = todo.json()

1
fake_db = []

1
fake_db = [
2
    TodoItem(title="买牛奶", is_done=False),
3
    TodoItem(title="学习 Python", is_done=True),
4
]

1
@app.post("/todos")
2
def create_todo(todoItem: TodoItem):
3
    """
4
    创建新的待办事项
5

6
    - FastAPI 自动将请求体 JSON 转换为 TodoItem 对象
7
    - 校验失败时自动返回 422 错误
8
    """
9
    fake_db.append(todoItem)
10
    return {"message": "Todo item created successfully"}

1
客户端发送 POST 请求:
2
POST /todos
3
Content-Type: application/json
4

5
{
6
  "title": "学习 FastAPI",
7
  "is_done": false
8
}
9
        ↓
10
FastAPI 接收请求
11
        ↓
12
解析请求体 JSON
13
        ↓
14
根据 TodoItem 模型校验数据
15
    - title 是字符串？✅
16
    - is_done 是布尔值？✅
17
        ↓
18
创建 TodoItem 实例
19
todoItem = TodoItem(title="学习 FastAPI", is_done=False)
20
        ↓
21
调用 create_todo(todoItem)
22
        ↓
23
添加到 fake_db
24
fake_db.append(todoItem)
25
        ↓
26
返回 JSON 响应
27
{"message": "Todo item created successfully"}

1
import requests
2

3
response = requests.post(
4
    "http://localhost:8000/todos",
5
    json={"title": "学习 FastAPI", "is_done": False}
6
)
7
print(response.json())
8
# {'message': 'Todo item created successfully'}

1
@app.get("/todos")
2
def get_todos():
3
    """
4
    获取所有待办事项
5

6
    - 返回待办总数和列表
7
    - FastAPI 自动将 Pydantic 对象列表转换为 JSON
8
    """
9
    return {
10
        "total": len(fake_db),
11
        "todos": fake_db
12
    }

1
{
2
  "total": 2,
3
  "todos": [
4
    {
5
      "title": "买牛奶",
6
      "is_done": false
7
    },
8
    {
9
      "title": "学习 Python",
10
      "is_done": true
11
    }
12
  ]
13
}

1
@app.get("/todos/{index}")
2
def get_todo(index: int):
3
    """获取指定索引的待办事项"""
4
    if 0 <= index < len(fake_db):
5
        return {
6
            "status": "success",
7
            "todo": fake_db[index]
8
        }
9
    return {
10
        "status": "error",
11
        "message": "Index out of range"
12
    }

1
@app.delete("/todos/{index}")
2
def delete_todo(index: int):
3
    """
4
    删除指定索引的待办事项
5

6
    - index: 路径参数，待办事项在列表中的位置
7
    - 返回操作结果和删除的数据
8
    """
9
    if 0 <= index < len(fake_db):
10
        del_item = fake_db.pop(index)
11
        return {
12
            "status": "success",
13
            "message": f"Deleted item: {del_item}"
14
        }
15
    return {
16
        "status": "error",
17
        "message": "I dont know this item"
18
    }

1
if 0 <= index < len(fake_db):

1
del_item = fake_db.pop(index)

1
情况1：删除存在的待办
2
DELETE /todos/0
3
        ↓
4
index = 0
5
        ↓
6
检查 0 <= 0 < len(fake_db)? 假设 len=2，True
7
        ↓
8
del_item = fake_db.pop(0)  # 删除并返回第0个元素
9
        ↓
10
返回成功响应
11
{"status": "success", "message": "Deleted item: title='买牛奶' is_done=False"}
12

13
情况2：删除不存在的待办
14
DELETE /todos/10
15
        ↓
16
index = 10
17
        ↓
18
检查 0 <= 10 < len(fake_db)? 假设 len=2，False
19
        ↓
20
返回错误响应
21
{"status": "error", "message": "I dont know this item"}

1
fake_db = {}  # 改用字典，key 是 ID，value 是待办事项
2
id_counter = 0
3

4
@app.post("/todos")
5
def create_todo(todoItem: TodoItem):
6
    global id_counter
7
    id_counter += 1
8
    fake_db[id_counter] = todoItem
9
    return {"id": id_counter, "message": "Created"}
10

11
@app.delete("/todos/{todo_id}")
12
def delete_todo(todo_id: int):
13
    if todo_id in fake_db:
14
        del fake_db[todo_id]
15
        return {"status": "success"}
16
    return {"status": "error", "message": "Not found"}

1
from fastapi import HTTPException, status
2

3
@app.post("/todos", status_code=status.HTTP_201_CREATED)
4
def create_todo(todoItem: TodoItem):
5
    fake_db.append(todoItem)
6
    return {"message": "Created"}
7

8
@app.delete("/todos/{index}")
9
def delete_todo(index: int):
10
    if 0 <= index < len(fake_db):
11
        del_item = fake_db.pop(index)
12
        return {"message": "Deleted"}
13
    # 抛出 404 错误
14
    raise HTTPException(
15
        status_code=status.HTTP_404_NOT_FOUND,
16
        detail="Item not found"
17
    )

1
from fastapi import HTTPException
2

3
raise HTTPException(
4
    status_code=404,                    # HTTP 状态码
5
    detail="Item not found",            # 错误详情（返回给客户端）
6
    headers={"X-Error": "There goes my error"}  # 可选的响应头
7
)

1
HTTP/1.1 404 Not Found
2
content-type: application/json
3

4
{
5
  "detail": "Item not found"
6
}

1
from pydantic import BaseModel
2
from typing import Optional
3

4
class Model(BaseModel):
5
    # 必填字段
6
    name: str
7

8
    # 可选字段（有默认值）
9
    age: int = 18
10

11
    # 可选字段（可为 None）
12
    email: Optional[str] = None

1
from fastapi import FastAPI, HTTPException, status
2
from pydantic import BaseModel
3

4
app = FastAPI()
5

6
# 数据存储（实际项目用数据库）
7
db = []
8

9
# Create
10
@app.post("/items", status_code=status.HTTP_201_CREATED)
11
def create_item(item: Item):
12
    db.append(item)
13
    return item
14

15
# Read All
16
@app.get("/items")
17
def get_items():
18
    return db
19

20
# Read One
21
@app.get("/items/{item_id}")
22
def get_item(item_id: int):
23
    if item_id < len(db):
24
        return db[item_id]
25
    raise HTTPException(status_code=404, detail="Not found")
26

27
# Update
28
@app.put("/items/{item_id}")
29
def update_item(item_id: int, item: Item):
30
    if item_id < len(db):
31
        db[item_id] = item
32
        return item
33
    raise HTTPException(status_code=404, detail="Not found")
34

35
# Delete
36
@app.delete("/items/{item_id}")
37
def delete_item(item_id: int):
38
    if item_id < len(db):
39
        return db.pop(item_id)
40
    raise HTTPException(status_code=404, detail="Not found")