python

关注公众号 jb51net

关闭
首页 > 脚本专栏 > python > Python FastAPI教学

从入门到生产详解Python中FastAPI的全攻略

作者：xiaoyu❅

在 Python Web 开发领域,FastAPI 正以惊人的速度崛起,本文将从零开始,带你全面掌握 FastAPI 的核心知识点,从环境搭建到生产部署,一次讲清楚

引言：Python Web 开发的新宠儿

在 Python Web 开发领域，FastAPI 正以惊人的速度崛起。截至 2025 年，FastAPI 在 GitHub 上的 Star 数已突破 80k，成为增长最快的 Python Web 框架。根据统计，2025 年已有 38% 的 Python 开发者在使用 FastAPI（较 2024 年增长 40%），超过一半的财富 500 强企业也在生产环境中部署了 FastAPI 应用。

那么，是什么让 FastAPI 如此受欢迎？本文将从零开始，带你全面掌握 FastAPI 的核心知识点，从环境搭建到生产部署，一次讲清楚。

一、FastAPI 是什么

FastAPI 是一个用于构建 API 的现代、高性能 Web 框架，基于 Python 3.7+ 的类型提示。它的核心架构建立在两个强大的底层库之上：Starlette（高性能 ASGI 框架）和 Pydantic（高性能数据校验库）。

1.1 核心特性

特性描述
高性能基于 Starlette + Pydantic，性能可媲美 Node.js 和 Go
自动 API 文档内置 Swagger UI（/docs）和 ReDoc（/redoc）
类型提示驱动利用 Python 类型注解自动校验请求和响应
原生异步支持完全支持 async/await，适合高并发 I/O 场景
依赖注入系统灵活的 Depends 机制，支持权限校验、数据库会话管理等

1.2 FastAPI 架构：ASGI + Pydantic

FastAPI 通过 ASGI 异步框架突破了传统 WSGI（如 Flask、Django）同步阻塞模型的性能天花板。实测数据显示，FastAPI 单节点 QPS 可达 3000+，约为 Flask 的 5-8 倍。

下面是 FastAPI 请求处理的整体流程：

二、环境搭建与第一个 FastAPI 应用

2.1 安装依赖

确保你的 Python 版本 ≥ 3.7，推荐使用虚拟环境隔离项目依赖：

# 创建并激活虚拟环境
python -m venv fastapi_env
source fastapi_env/bin/activate  # Linux/macOS
# 或 fastapi_env\Scripts\activate  # Windows

# 安装 FastAPI 和 Uvicorn（ASGI 服务器）
pip install fastapi uvicorn[standard]

2.2 第一个 Hello World 应用

创建一个 main.py 文件：

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def read_root():
    return {"message": "Hello, FastAPI!"}

运行服务：

uvicorn main:app --reload --host 0.0.0.0 --port 8000

现在打开浏览器访问 http://localhost:8000，你会看到返回的 JSON 数据。再访问 http://localhost:8000/docs，你会惊喜地发现 Swagger UI 自动生成了交互式 API 文档——无需编写任何额外的文档代码。

三、路由与请求参数

3.1 请求处理的完整流程

在深入各种参数之前，我们先理解 FastAPI 的请求处理流程：

3.2 路径参数

路径参数直接从 URL 路径中提取：

from fastapi import FastAPI

app = FastAPI()

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    return {"user_id": user_id}

FastAPI 会自动将 user_id 转换为 int 类型，如果传入非数字值会自动返回 422 校验错误。

3.3 查询参数

查询参数通过函数参数的默认值或 Query 类来定义：

from fastapi import FastAPI, Query

@app.get("/items/")
async def read_items(
    item_id: int = Query(..., description="商品ID", ge=1),
    q: str = None,
    limit: int = Query(10, ge=1, le=100)
):
    return {"item_id": item_id, "q": q, "limit": limit}

3.4 请求体与 Pydantic 模型

对于 POST、PUT 请求，使用 Pydantic 模型来定义和校验请求体：

from fastapi import FastAPI
from pydantic import BaseModel, Field

app = FastAPI()

class Item(BaseModel):
    name: str = Field(..., min_length=1, max_length=100)
    description: str | None = None
    price: float = Field(..., gt=0, description="价格必须大于0")
    tax: float | None = None
    
    # Pydantic v2 支持 model_config 进行额外配置
    model_config = {
        "json_schema_extra": {
            "example": {
                "name": "iPhone 15",
                "description": "最新款智能手机",
                "price": 6999.0,
                "tax": 699.9
            }
        }
    }

@app.post("/items/")
async def create_item(item: Item):
    item_dict = item.model_dump()  # Pydantic v2 使用 model_dump 替代 dict
    if item.tax:
        price_with_tax = item.price + item.tax
        item_dict["price_with_tax"] = price_with_tax
    return item_dict

Pydantic 在运行时自动完成：

3.5 路由分组（APIRouter）

对于大型项目，使用 APIRouter 进行模块化拆分：

from fastapi import APIRouter, FastAPI

# 创建路由模块
user_router = APIRouter(prefix="/users", tags=["users"])
item_router = APIRouter(prefix="/items", tags=["items"])

@user_router.get("/{user_id}")
async def get_user(user_id: int):
    return {"user_id": user_id}

@item_router.get("/")
async def list_items():
    return {"items": []}

# 注册到主应用
app = FastAPI()
app.include_router(user_router)
app.include_router(item_router)

APIRouter 支持 prefix（路径前缀）、tags（文档分组标签）、responses（统一响应格式）等配置，非常适合微服务架构的模块拆分。

四、依赖注入（Depends）

依赖注入是 FastAPI 最强大的特性之一。它的本质是通过外部传入依赖对象，而非在函数内部直接创建，从而将依赖管理从业务逻辑中解耦。

4.1 依赖注入的工作原理

4.2 基础函数依赖

from fastapi import FastAPI, Depends

app = FastAPI()

# 定义一个可复用的依赖函数
def get_current_user(token: str = "fake_token"):
    # 实际项目中会从 Header 或 Cookie 中解析 token
    return {"username": "john_doe", "role": "admin"}

@app.get("/profile")
async def read_profile(user: dict = Depends(get_current_user)):
    return {"message": f"Hello, {user['username']}!"}

4.3 数据库连接依赖

这是依赖注入最经典的应用场景——管理数据库会话生命周期：

from sqlalchemy.orm import Session
from database import SessionLocal

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()  # 请求结束后自动关闭连接

@app.get("/users/")
async def read_users(db: Session = Depends(get_db)):
    return db.query(User).all()

yield 关键字让 FastAPI 能够在请求处理完毕后执行 finally 块中的清理代码，优雅地管理资源生命周期。

4.4 依赖链与缓存

from functools import lru_cache

# 使用 lru_cache 缓存昂贵资源，避免重复创建
@lru_cache()
def get_settings():
    # 模拟从配置文件或环境变量加载
    return {"debug": True, "database_url": "..."}

def get_db(settings: dict = Depends(get_settings)):
    db_url = settings["database_url"]
    # 创建数据库连接...
    return db

@app.get("/config")
async def read_config(settings: dict = Depends(get_settings)):
    return settings

使用 @lru_cache 装饰的依赖在整个应用生命周期中只会执行一次，适合配置加载、模型加载等场景。

五、中间件与 CORS 跨域

5.1 中间件的执行流程

5.2 CORS 中间件配置

前后端分离项目中，CORS 跨域问题是必须要解决的：

from fastapi import FastAPI
from fastapi.middleware.cors import CORSMiddleware

app = FastAPI()

# 开发环境：允许所有来源
origins = ["*"]

# 生产环境：精确控制
origins = [
    "https://yourdomain.com",
    "https://admin.yourdomain.com",
    "http://localhost:3000",  # 本地开发
]

app.add_middleware(
    CORSMiddleware,
    allow_origins=origins,
    allow_credentials=True,  # 允许携带 Cookie
    allow_methods=["GET", "POST", "PUT", "DELETE"],
    allow_headers=["Content-Type", "Authorization"],
    max_age=86400,  # 预检请求缓存 24 小时
)

关键注意点：当 allow_credentials=True 时，allow_origins 不能使用 ["*"]，必须明确列出允许的来源列表。

5.3 自定义中间件

from fastapi import Request
import time

@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    start_time = time.time()
    response = await call_next(request)
    process_time = time.time() - start_time
    response.headers["X-Process-Time"] = str(process_time)
    return response

六、数据库集成（SQLAlchemy 2.0 异步）

FastAPI 的异步特性与 SQLAlchemy 2.0 的异步支持是天作之合。传统同步 ORM 在高并发场景下会成为性能瓶颈，而异步 ORM 可以在等待数据库响应的 I/O 空闲期处理其他请求，极大提升并发能力。

6.1 异步数据库架构

6.2 配置异步引擎

首先安装依赖：

pip install sqlalchemy asyncpg alembic

配置异步引擎和会话工厂：

from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker
from sqlalchemy.orm import DeclarativeBase

# PostgreSQL 异步驱动 URL
DATABASE_URL = "postgresql+asyncpg://user:password@localhost/dbname"

# 创建异步引擎
engine = create_async_engine(
    DATABASE_URL,
    echo=True,          # 开发时打印 SQL
    future=True,        # 使用 2.0 风格 API
    pool_size=10,       # 连接池大小
    max_overflow=20,    # 最大溢出连接数
)

# 创建异步会话工厂
AsyncSessionLocal = async_sessionmaker(
    bind=engine,
    class_=AsyncSession,
    expire_on_commit=False,  # commit 后不使属性过期
    autocommit=False,
    autoflush=False,
)

# 定义模型基类
class Base(DeclarativeBase):
    pass

expire_on_commit=False 是一个重要的性能优化配置——在 Web 请求上下文中，我们通常在请求结束时就丢弃会话，无需让属性过期后再查询。

6.3 异步依赖注入

from fastapi import Depends

async def get_db() -> AsyncSession:
    async with AsyncSessionLocal() as session:
        try:
            yield session
            await session.commit()
        except Exception:
            await session.rollback()
            raise
        # async with 上下文会自动关闭 session

@app.get("/users/")
async def list_users(db: AsyncSession = Depends(get_db)):
    from sqlalchemy import select
    result = await db.execute(select(User))
    return result.scalars().all()

@app.post("/users/")
async def create_user(user_data: UserCreate, db: AsyncSession = Depends(get_db)):
    new_user = User(**user_data.model_dump())
    db.add(new_user)
    await db.flush()  # 获取数据库生成的 ID
    await db.refresh(new_user)
    return new_user

七、测试与部署

7.1 使用 TestClient 进行单元测试

FastAPI 提供了 TestClient，它基于 httpx，可以模拟 HTTP 请求而无需真正启动服务器：

# test_main.py
from fastapi.testclient import TestClient
from main import app

client = TestClient(app)

def test_read_root():
    response = client.get("/")
    assert response.status_code == 200
    assert response.json() == {"message": "Hello, FastAPI!"}

运行测试：

pip install pytest httpx
pytest test_main.py -v

7.2 依赖覆盖——数据库测试的杀手锏

FastAPI 的 dependency_overrides 是测试数据库相关 API 的利器。你可以将真实的数据库依赖替换为 SQLite 内存数据库，实现“跑完即焚”：

from fastapi.testclient import TestClient
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from main import app, get_db

# 创建内存数据库
SQLALCHEMY_DATABASE_URL = "sqlite:///:memory:"
engine = create_engine(SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False})
TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

def override_get_db():
    try:
        db = TestingSessionLocal()
        yield db
    finally:
        db.close()

# 覆盖真实依赖
app.dependency_overrides[get_db] = override_get_db

client = TestClient(app)

def test_create_user():
    response = client.post("/users/", json={"name": "test", "email": "test@example.com"})
    assert response.status_code == 200

7.3 生产部署建议

生产环境部署命令示例：

# 使用 Gunicorn 管理 Uvicorn 多进程
gunicorn main:app \
    --workers 4 \
    --worker-class uvicorn.workers.UvicornWorker \
    --bind 0.0.0.0:8000 \
    --access-logfile - \
    --error-logfile -

八、总结

FastAPI 凭借其类型提示驱动、自动文档生成、异步高性能、依赖注入系统四大核心优势，已经成为 Python Web 开发的主流框架选择。

本文从零开始，涵盖了 FastAPI 的核心知识点：

掌握这些内容，你已经可以独立开发一个生产级别的 FastAPI 应用了。接下来，你可以进一步学习 FastAPI 的高级特性，如 WebSocket 支持、后台任务（BackgroundTasks）、自定义异常处理等，让你的 FastAPI 技能更加全面。

以上就是从入门到生产详解Python中FastAPI的全攻略的详细内容，更多关于Python FastAPI教学的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:
阅读全文