后端框架（04）：Python FastAPI/Django——异步、Pydantic、ORM 性能瓶颈

更新时间：2026-09-01。本文是 backend/framework/ 后端框架第 04 篇，接 Go Gin。Python 后端有两个主流框架：FastAPI 现代化、异步、Pydantic 类型校验；Django 全能、开箱即用、ORM、自带 admin。理解它们的适用场景和性能瓶颈，才能选择合适的框架。

本文要回答的问题

• FastAPI 的异步和 Pydantic 校验有什么优势？
• Django 的 ORM 和 admin 是什么？为什么说 Django "开箱即用"？
• Python 后端常见性能瓶颈有哪些？怎么优化？
• FastAPI vs Django，什么时候选哪个？

一、FastAPI 基础

from fastapi import FastAPI
from pydantic import BaseModel
from typing import Optional

app = FastAPI()

class User(BaseModel):
    id: Optional[int] = None
    name: str
    age: int

@app.get("/users/{user_id}")
def get_user(user_id: int, q: Optional[str] = None):
    return {"user_id": user_id, "q": q}

@app.post("/users")
def create_user(user: User):  # Pydantic 自动校验
    return {"name": user.name, "age": user.age}

# uvicorn main:app --reload
# http://127.0.0.1:8000/docs → 自动生成 Swagger 文档

FastAPI 核心特性：

• 基于 Starlette（异步 ASGI）+ Pydantic
• 自动类型校验（Pydantic）
• 自动生成 OpenAPI 文档
• 异步支持（async def）
• 路径参数、查询参数自动绑定

二、FastAPI 异步

# 同步处理：每个请求在一个线程中，阻塞 I/O
@app.get("/sync")
def sync_handler():
    data = requests.get("https://example.com")  # 阻塞，线程等待
    return {"data": data.text}

# 异步处理：非阻塞，协程调度
import httpx

@app.get("/async")
async def async_handler():
    async with httpx.AsyncClient() as client:
        data = await client.get("https://example.com")  # 不阻塞，让出 CPU
        return {"data": data.text}

# 要点：异步只对 I/O 密集有用，CPU 密集还是会阻塞
# 如果用了同步阻塞函数，异步失去优势

三、Django 基础

# models.py
from django.db import models

class User(models.Model):
    name = models.CharField(max_length=100)
    age = models.IntegerField()
    email = models.EmailField(unique=True)
    created_at = models.DateTimeField(auto_now_add=True)

    class Meta:
        db_table = "users"

# views.py
from django.http import JsonResponse
from .models import User

def list_users(request):
    users = User.objects.all().values()
    return JsonResponse({"users": list(users)})

# urls.py
from django.urls import path
from . import views

urlpatterns = [
    path("users/", views.list_users),
]

Django 核心特性：

• 开箱即用：ORM、admin、认证、迁移都自带
• ORM：Python 风格，不用写 SQL
• 迁移工具：python manage.py makemigrations/migrate
• 自带 admin：自动生成后台管理界面
• 全栈：模板渲染、表单验证、静态文件

四、Django ORM 入门

# 查询所有
users = User.objects.all()

# 条件查询
adult_users = User.objects.filter(age__gte=18)
young_user = User.objects.filter(age__lt=18).first()

# 单条查询
user = User.objects.get(id=1)

# 创建
user = User.objects.create(name="Alice", age=20)

# 更新
user.age = 21
user.save()

# 删除
user.delete()

五、性能瓶颈和优化

1. N+1 查询问题

# ❌ N+1 查询：每个 post 都查询一次作者
posts = Post.objects.all()
for post in posts:
    print(post.author.name)  # 每个 post 都发一次查询

# ✅ select_related 预加载外键
posts = Post.objects.select_related("author").all()
# 一次 JOIN 查询，不会 N+1

# ✅ prefetch_related 预加载多对多
users = User.objects.prefetch_related("posts").all()

2. 索引缺失

# 频繁查询字段加索引
class User(models.Model):
    email = models.EmailField(unique=True, db_index=True)  # 加索引

3. 分页查询

# 不要一次取出所有数据
from django.core.paginator import Paginator

paginator = Paginator(User.objects.all(), 20)
page = paginator.page(1)
users = page.object_list

4. FastAPI 异步优化

# 不要在异步函数里调用同步阻塞函数
# 如果必须调用，用 to_thread 或 run_in_executor
import asyncio

@app.get("/blocking")
async def blocking_handler():
    # 阻塞操作放到线程池
    result = await asyncio.to_thread(blocking_function)
    return {"result": result}

六、FastAPI vs Django 选择

对比	FastAPI	Django
大小	轻量	全能，大
风格	API 优先	全栈
异步	原生支持	3.x 才开始支持
文档	自动生成	手动写
ORM	不自带，可选	自带强大 ORM
开箱即用	需要选组件	开箱即用

选择建议：

• 微服务、API 服务：FastAPI（轻量，异步，文档自动生成）
• 传统全栈 Web、CMS：Django（ORM、admin 开箱即用）
• 需要快速原型：Django（很快就能做出来）
• 需要高性能 API：FastAPI（异步，Pydantic 快）

七、常见坑对照

坑	现象	对策
N+1 查询	慢查询，数据库压力大	用 select_related/prefetch_related
异步函数里同步阻塞	整个事件循环阻塞	把阻塞操作放到线程池
Django 查询取出所有	内存占用大	分页查询，用迭代器
Pydantic 校验过度	校验开销大	复杂校验缓存结果

相关与延伸

下一篇：API 设计规范——版本管理、错误码、幂等、限流、OpenAPI；后端工程能力索引见 index.md。

一句话总结

Python FastAPI/Django：FastAPI 基于 Pydantic 自动类型校验，自动生成 OpenAPI 文档，原生支持异步，适合轻量 API 服务；Django 是全栈框架，自带 ORM、admin、迁移，开箱即用，适合快速开发全栈应用；N+1 查询是 Django ORM 最常见性能问题，用 select_related/prefetch_related 预加载避免；FastAPI 异步只对 I/O 密集有用，CPU 密集会阻塞事件循环；微服务 API 选 FastAPI，全栈应用选 Django。