FastAPI GitHub项目示例：快速掌握实战应用 – wiki基地

作者： /

FastAPI GitHub项目示例：快速掌握实战应用——从源码到实践的深度解析

在当今瞬息万变的Web开发领域，选择一个高效、现代且易于维护的框架至关重要。Python生态中的FastAPI正以其卓越的性能、直观的设计和自动化的文档生成能力，迅速成为构建高性能API和Web服务的首选。然而，仅仅阅读官方文档可能不足以完全掌握其精髓，最有效的学习方式之一是深入研究其官方及社区的GitHub项目示例。这些示例不仅是功能演示，更是最佳实践、高级用法的宝库，能帮助开发者从理论走向实践，快速搭建起健壮的Web应用。

本文将带领读者深入探索FastAPI在GitHub上的各类项目示例，从官方教程代码到实际应用模板，再到丰富的社区项目，详细解析其结构、核心思想和应用场景。通过对这些宝贵资源的透彻理解和实践，你将能够快速掌握FastAPI的实战技能，为自己的项目保驾护航。

引言：为何选择FastAPI，为何从示例入手？

FastAPI的崛起并非偶然，它融合了Python 3.6+的类型提示（Type Hints）、Pydantic的数据验证与序列化、Starlette的高性能Web工具包以及Uvicorn的异步服务器能力，构建了一个既能满足高并发需求，又能大幅提升开发效率的现代化框架。它的核心优势体现在：

  1. 极高的性能： 基于Starlette和Uvicorn，性能可与Go和Node.js相媲美。
  2. 快速开发： 利用类型提示自动生成OpenAPI（Swagger UI）和ReDoc文档，减少了大量手动编写文档和接口测试的时间。
  3. 强大的数据验证： Pydantic模型自动进行数据解析、验证和序列化，确保数据一致性和安全性。
  4. 优秀的开发体验： 极简的代码风格、清晰的错误提示、完善的IDE支持，让开发过程充满愉悦。
  5. 依赖注入系统： 灵活地管理组件、数据库连接、认证逻辑等，提高代码可维护性和可测试性。

然而，对于初学者而言，面对一个功能如此强大的框架，如何快速有效地将其应用于实际项目，往往是一个挑战。这时，GitHub上的项目示例就成了最佳的桥梁。它们不仅仅是代码片段，更是：

  • 实战蓝图： 展示了如何组织项目、如何集成各种功能。
  • 最佳实践： 包含了社区推荐的代码风格、设计模式和安全策略。
  • 学习加速器： 通过可运行的代码，直观地理解各种概念，省去大量摸索时间。
  • 问题解决参考： 许多示例直接解决了特定场景下的常见问题。

接下来的内容将围绕这些GitHub资源，展开一次深度探索之旅。

一、FastAPI项目示例的宝库：官方与社区资源概览

FastAPI的GitHub生态系统是其强大生命力的体现，它提供了多层次、多维度的示例资源，满足不同学习阶段和项目需求：

A. 官方GitHub仓库 tiangolo/fastapi

这是FastAPI的核心代码仓库，其中包含了：

  1. examples/ 目录： 这是一个小而精的目录，主要用于演示一些独立的功能点，如WebSocket、文件上传、自定义响应等。虽然数量不多，但每个示例都非常具有代表性。
  2. docs/ 目录下的教程代码： FastAPI的官方文档本身就是一份极其详尽的教程。其文档中的每个代码块几乎都可以独立运行，它们是学习FastAPI核心概念（如路径操作、查询参数、请求体、依赖注入、安全等）的最佳起点。这些代码通常位于docs/src/tutorial/ 下的各个子目录中。
  3. tests/ 目录： 这是一个经常被忽视但极具价值的宝库。FastAPI项目的测试代码（位于tests/）本身就是大量高级用法的最佳示例。通过阅读测试代码，你可以了解到框架内部如何测试不同功能、如何模拟请求、如何使用TestClient进行端到端测试，以及一些边缘情况的处理方式。

B. 官方模板项目（Project Templates）

为了帮助开发者快速启动一个结构良好的FastAPI项目，官方提供了几个非常有用的模板：

  1. fastapi-project-template (tiangolo/fastapi-project-template):
    这是一个通用的小型项目模板，适用于快速原型开发或小型API服务。它包含了基础的FastAPI应用结构、依赖管理 (poetry)、测试 (pytest) 和Docker支持。它没有引入数据库或复杂的认证系统，因此非常轻量级。

  2. fastapi-mvc (fastapi-mvc/fastapi-mvc):
    虽然FastAPI本身是微服务框架，但这个模板试图引入更传统的MVC（Model-View-Controller）模式，适用于需要更严格结构划分的中大型应用。它通常集成了SQLAlchemy、Alembic（数据库迁移）、JWT认证等。

  3. fastapi-full-stack (tiangolo/full-stack-fastapi-postgresql):
    这是一个重量级的全栈项目模板，集成了FastAPI（后端）、PostgreSQL（数据库）、Vue.js/React（前端）等。它是一个功能完善的生产级应用示例，包含了用户认证、权限管理、Docker Compose部署等复杂功能。如果你想学习如何构建一个完整的、可部署的生产系统，这个模板是绝佳的选择。

  4. fastapi-crud-template (fastapi-crud-template/fastapi-crud-template):
    专注于CRUD（创建、读取、更新、删除）操作的模板，通常集成了ORM（如SQLModel或SQLAlchemy）和数据库连接。

C. 社区项目与库（Awesome FastAPI）

除了官方资源，更广阔的FastAPI社区也贡献了大量优秀的开源项目和第三方库。https://github.com/tiangolo/awesome-fastapi 是一个精心维护的列表，包含了各种FastAPI相关的工具、扩展、文章和真实世界项目。通过这个列表，你可以发现：

  • 数据库集成示例： 与SQLAlchemy、SQLModel、MongoDB、Cassandra等数据库的集成。
  • GraphQL集成： FastAPI-Graphene、strawberry 等库的用法。
  • Websocket示例： 实时通信的应用。
  • 认证与授权： OAuth2、JWT、RBAC（基于角色的访问控制）等更复杂的实现。
  • 部署示例： Docker、Kubernetes、AWS Lambda、Heroku等不同环境的部署方案。
  • 真实世界应用： 一些公司或个人开源的基于FastAPI的实际项目，从中可以学习到项目结构、模块化、错误处理等更高级的实践。

二、核心官方示例深度解析：从基础到高级

我们将重点剖析FastAPI官方文档中一些核心功能的示例，这些示例是理解FastAPI架构和设计哲学的基石。

A. 基础示例：路径操作、查询参数与请求体

这是FastAPI最基础也是最重要的功能，官方文档的“First Steps”和“Path Parameters”章节提供了详尽的例子。

关键概念：

  • 路径操作装饰器： @app.get(), @app.post(), @app.put(), @app.delete() 等，用于定义HTTP方法和URL路径。
  • 路径参数： 在路径中使用 {} 定义，FastAPI会自动从URL中提取并传递给函数。
  • 查询参数： 通过函数参数直接定义，FastAPI会自动从URL的查询字符串中提取。
  • 请求体： 使用Pydantic模型定义请求体的结构，FastAPI自动进行解析、验证和类型转换。

示例代码片段 (简化版 main.py):

“`python
from typing import Optional
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

定义一个Pydantic模型用于请求体

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

1. 根路径操作

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

2. 带路径参数的GET请求

@app.get(“/items/{item_id}”)
async def read_item(item_id: int, q: Optional[str] = None):
“””
通过 item_id 获取商品信息，并支持可选的查询参数 q。
“””
if q:
return {“item_id”: item_id, “q”: q}
return {“item_id”: item_id}

3. 带请求体的POST请求

@app.post(“/items/”)
async def create_item(item: Item):
“””
创建一个新的商品。请求体是一个JSON对象，符合Item模型。
“””
item_dict = item.dict()
if item.tax:
price_with_tax = item.price + item.tax
item_dict.update({“price_with_tax”: price_with_tax})
return item_dict

4. 路径参数与请求体的组合

@app.put(“/items/{item_id}”)
async def update_item(item_id: int, item: Item, q: Optional[str] = None):
results = {“item_id”: item_id, **item.dict()}
if q:
results.update({“q”: q})
return results

运行方式：uvicorn main:app –reload

“`

解析：
这个简单的main.py文件展示了FastAPI最核心的API定义方式。注意item_id: int的类型提示，FastAPI会自动验证其是否为整数。q: Optional[str] = None定义了一个可选的查询参数。在create_item函数中，item: Item直接将请求体映射到一个Pydantic模型实例，FastAPI会进行自动的数据校验和类型转换，极大地简化了数据处理。

B. 依赖注入（Dependencies）

依赖注入是FastAPI最强大的特性之一，它允许在路径操作函数中使用可复用的“依赖”函数。这有助于构建模块化、可测试、易于维护的代码。

关键概念：

  • Depends：用于声明一个函数或可调用对象作为依赖。
  • 可复用逻辑： 认证、数据库会话、权限检查、分页逻辑等。
  • 带有 yield 的依赖： 用于在请求处理前后执行代码，常用于管理数据库会话的生命周期。

示例代码片段 (dependencies.py 和 main.py):

“`python

dependencies.py

from typing import Generator
from fastapi import Depends, HTTPException, status, Header

def get_query_token(token: str):
“””简单依赖：验证查询参数中的token”””
if token != “jessica”:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=”No Jessica token provided”)
return token

def get_header_token(x_token: str = Header(…)):
“””更高级的依赖：从请求头获取token并验证”””
if x_token != “fake-super-secret-token”:
raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=”X-Token header invalid”)
return x_token

模拟数据库连接（这里仅为演示概念，实际生产环境会连接真实DB）

def get_db_session() -> Generator:
“””带有yield的依赖：模拟数据库会话的生命周期管理”””
print(“Opening DB session…”)
db = {“user”: “example_user”} # 模拟数据库连接对象
try:
yield db # 将db对象提供给依赖它的路径操作函数
finally:
print(“Closing DB session…”)
# 实际场景中会在这里关闭数据库连接或回滚事务
pass

main.py

from fastapi import FastAPI, Depends
from .dependencies import get_query_token, get_header_token, get_db_session

app = FastAPI()

@app.get(“/users/me”)
async def read_current_user(token: str = Depends(get_query_token)):
return {“token”: token, “user”: “current_user”}

@app.get(“/items_with_header/”)
async def read_items(header_token: str = Depends(get_header_token)):
return {“header_token”: header_token}

@app.get(“/items_db/”)
async def read_items_db(db_session: dict = Depends(get_db_session)):
# 实际场景中，这里会使用db_session进行数据库操作
return {“message”: “Items fetched from DB”, “db_user”: db_session[“user”]}
“`

解析：
get_query_token和get_header_token展示了如何验证请求参数和请求头。get_db_session是一个经典的数据库会话管理模式。yield db会在路径操作函数执行前提供db对象，并在函数执行完毕（无论成功或失败）后，自动执行finally块中的代码（关闭数据库连接），确保资源得到释放。这极大地简化了资源管理。

C. 安全与认证（Security & Authentication）

FastAPI内置了对OAuth2、JWT、API Key等多种认证方案的支持，并通过依赖注入系统进行集成。

关键概念：

  • fastapi.security 模块：提供了多种认证模式，如OAuth2PasswordBearer、APIKeyHeader等。
  • Depends：将认证逻辑作为依赖注入到路径操作中。
  • HTTPException：用于返回认证失败的错误信息。

示例代码片段 (auth.py 和 main.py):

“`python

auth.py

from fastapi.security import OAuth2PasswordBearer
from fastapi import Depends, HTTPException, status
from jose import JWTError, jwt
from datetime import datetime, timedelta

配置JWT

SECRET_KEY = “your-secret-key” # 生产环境中请使用强密钥，并从环境变量读取
ALGORITHM = “HS256”
ACCESS_TOKEN_EXPIRE_MINUTES = 30

oauth2_scheme = OAuth2PasswordBearer(tokenUrl=”token”) # tokenUrl指向生成token的路由

def create_access_token(data: dict):
to_encode = data.copy()
expire = datetime.utcnow() + timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
to_encode.update({“exp”: expire})
encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
return encoded_jwt

async def get_current_user(token: str = Depends(oauth2_scheme)):
credentials_exception = HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail=”Could not validate credentials”,
headers={“WWW-Authenticate”: “Bearer”},
)
try:
payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
username: str = payload.get(“sub”)
if username is None:
raise credentials_exception
# 实际应用中，这里会查询数据库获取用户对象
return {“username”: username}
except JWTError:
raise credentials_exception

main.py

from fastapi import FastAPI, Depends, Form
from fastapi.responses import JSONResponse
from .auth import create_access_token, get_current_user
from pydantic import BaseModel

app = FastAPI()

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

模拟数据库中的用户（仅为演示）

fake_users_db = {
“john_doe”: {
“username”: “john_doe”,
“full_name”: “John Doe”,
“email”: “[email protected]”,
“disabled”: False,
}
}

def authenticate_user(username: str, password: str):
# 真实应用中，这里会查询数据库并验证密码哈希
user = fake_users_db.get(username)
if not user or password != “password123”: # 简单的密码验证，生产环境请用加密哈希
return None
return user

@app.post(“/token”)
async def login_for_access_token(username: str = Form(), password: str = Form()):
user = authenticate_user(username, password)
if not user:
raise HTTPException(
status_code=status.HTTP_401_UNAUTHORIZED,
detail=”Incorrect username or password”,
headers={“WWW-Authenticate”: “Bearer”},
)
access_token = create_access_token(data={“sub”: user[“username”]})
return {“access_token”: access_token, “token_type”: “bearer”}

@app.get(“/users/me_secured/”)
async def read_users_me(current_user: dict = Depends(get_current_user)):
return current_user
“`

解析：
oauth2_scheme定义了OAuth2认证方式。create_access_token用于生成JWT。get_current_user是核心的认证依赖，它从请求头中获取token，解码并验证JWT，并返回当前用户。login_for_access_token路由用于用户登录并获取token。read_users_me通过Depends(get_current_user)实现了受保护的路由，只有携带有效token的请求才能访问。

D. 后台任务（Background Tasks）

FastAPI允许你定义在请求返回响应后，在后台执行的任务，这对于发送邮件、日志记录、耗时计算等非常有用。

关键概念：

  • BackgroundTasks：一个依赖注入对象，用于添加后台任务。
  • 非阻塞： 后台任务不会阻塞主请求的响应。

示例代码片段 (main.py):

“`python
from fastapi import FastAPI, BackgroundTasks, Depends
import time

app = FastAPI()

def write_log(message: str):
time.sleep(2) # 模拟耗时操作
with open(“log.txt”, mode=”a”) as log:
log.write(f”{message}\n”)
print(f”Log written: {message}”)

@app.post(“/send-notification/{email}”)
async def send_notification(email: str, background_tasks: BackgroundTasks):
message = f”notification for {email}”
background_tasks.add_task(write_log, message)
return {“message”: “Notification sent in background”}

@app.get(“/read-log”)
async def read_log():
try:
with open(“log.txt”, mode=”r”) as log:
content = log.read()
return {“log_content”: content.splitlines()}
except FileNotFoundError:
return {“log_content”: “Log file not found.”}
“`

解析：
send_notification函数接收BackgroundTasks对象，并使用add_task方法将write_log函数添加到后台任务队列。当客户端收到{"message": "Notification sent in background"}响应后，write_log函数才会在后台执行。这确保了API的响应速度，同时不影响耗时操作的执行。

E. 数据库集成（SQLAlchemy / SQLModel）

FastAPI本身不直接提供数据库ORM，但可以与任何Python数据库库无缝集成。官方推荐使用SQLModel（由FastAPI的作者构建）或SQLAlchemy。

关键概念：

  • 异步数据库驱动： 如asyncpg、aiomysql，通常通过databases库或直接使用异步ORM（如SQLModel）进行连接。
  • 会话管理： 使用依赖注入管理数据库会话的生命周期。

示例代码片段 (SQLModel集成简化版):

“`python

models.py

from typing import Optional
from sqlmodel import Field, SQLModel, create_engine, Session

class Hero(SQLModel, table=True):
id: Optional[int] = Field(default=None, primary_key=True)
name: str = Field(index=True)
secret_name: str
age: Optional[int] = Field(default=None, index=True)

database.py

sqlite_file_name = “database.db”
sqlite_url = f”sqlite:///{sqlite_file_name}”

engine = create_engine(sqlite_url, echo=True)

def create_db_and_tables():
SQLModel.metadata.create_all(engine)

def get_session():
with Session(engine) as session:
yield session

main.py

from fastapi import FastAPI, Depends, HTTPException, status
from typing import List
from .database import create_db_and_tables, get_session
from .models import Hero, Session

app = FastAPI()

@app.on_event(“startup”)
def on_startup():
create_db_and_tables()

@app.post(“/heroes/”, response_model=Hero)
def create_hero(hero: Hero, session: Session = Depends(get_session)):
session.add(hero)
session.commit()
session.refresh(hero)
return hero

@app.get(“/heroes/”, response_model=List[Hero])
def read_heroes(session: Session = Depends(get_session)):
heroes = session.query(Hero).all()
return heroes

@app.get(“/heroes/{hero_id}”, response_model=Hero)
def read_hero(hero_id: int, session: Session = Depends(get_session)):
hero = session.query(Hero).filter(Hero.id == hero_id).first()
if not hero:
raise HTTPException(status_code=404, detail=”Hero not found”)
return hero
“`

解析：
models.py定义了SQLModel模型，它同时也是Pydantic模型。database.py负责数据库连接引擎和会话的创建，get_session依赖利用yield确保会话的正确打开和关闭。main.py的on_event("startup")在应用启动时创建表。CRUD操作通过Depends(get_session)获取数据库会话，执行增删改查。这展示了FastAPI如何与ORM优雅地集成。

F. 测试示例（tests/ 目录）

FastAPI内置了对测试的良好支持，推荐使用pytest和httpx（或requests）。TestClient是进行端到端测试的关键。

关键概念：

  • fastapi.testclient.TestClient：一个模拟HTTP请求的客户端，可以直接调用FastAPI应用。
  • Fixture： pytest的fixture用于设置测试环境（如模拟数据库、认证用户）。

示例代码片段 (test_main.py):

“`python
from fastapi.testclient import TestClient
from main import app # 假设你的FastAPI应用在main.py中

client = TestClient(app)

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

def test_read_item():
response = client.get(“/items/123?q=testquery”)
assert response.status_code == 200
assert response.json() == {“item_id”: 123, “q”: “testquery”}

def test_create_item():
response = client.post(
“/items/”,
json={“name”: “Foo”, “price”: 10.5, “description”: “A nice item”},
)
assert response.status_code == 200
assert response.json() == {
“name”: “Foo”,
“price”: 10.5,
“description”: “A nice item”,
“tax”: None, # 因为模型中tax是Optional且未提供
}

def test_create_item_invalid_data():
response = client.post(
“/items/”,
json={“name”: “Foo”, “price”: “not_a_number”}, # 错误的数据类型
)
assert response.status_code == 422 # Pydantic验证失败会返回422
“`

解析：
通过创建TestClient(app)，你可以像实际发送HTTP请求一样测试你的API。client.get()、client.post()等方法可以直接模拟各种HTTP请求，并获取response对象，从而可以断言状态码、JSON响应内容等。这使得API的自动化测试变得极其简单高效。

三、从示例中学习的高效策略

仅仅阅读代码是不够的，还需要结合实践和方法论：

  1. 环境搭建与运行：

    • 克隆仓库： git clone <repo_url>
    • 安装依赖： 进入项目目录，通常有requirements.txt（pip install -r requirements.txt）或pyproject.toml（使用poetry install）。
    • 运行应用： 大多数FastAPI应用使用uvicorn main:app --reload来启动，其中main是文件名（不带.py），app是FastAPI实例的变量名。
    • 访问文档： 启动后，访问http://127.0.0.1:8000/docs（Swagger UI）或/redoc查看自动生成的API文档和测试界面。

  2. 代码阅读与理解：

    • 从入口点开始： 找到FastAPI应用的app实例定义，通常在main.py或app.py中。
    • 理解路由： 查看@app.get(), @app.post()等装饰器，理解URL路径和HTTP方法如何映射到函数。
    • 关注类型提示： FastAPI的核心是类型提示。理解函数参数和返回值的类型提示，它们直接关系到Pydantic模型的验证和响应模型的生成。
    • Pydantic模型： 仔细阅读BaseModel定义的类，理解数据结构、字段类型、默认值、可选字段等。
    • 追踪依赖： 当看到Depends()时，点击进去查看依赖函数或类的实现，理解其提供的功能（如认证、数据库会话）。
    • 阅读注释： 好的示例通常伴随着清晰的注释，解释了设计意图和实现细节。

  3. 动手实践与修改：

    • 修改参数与返回值： 尝试改变路径参数、查询参数的类型，或修改Pydantic模型，观察FastAPI如何响应（例如，验证失败时返回422）。
    • 添加新路由： 尝试添加一个全新的API端点，实现一个简单的CRUD操作。
    • 引入错误： 故意在代码中引入语法错误或逻辑错误，观察FastAPI和Uvicorn的错误报告。
    • 调试： 使用IDE（如VS Code, PyCharm）的调试器，设置断点，单步执行代码，查看变量的值，这对于理解执行流程至关重要。

  4. 结合文档与源码：

    • 当对某个概念或功能感到困惑时，先查阅FastAPI官方文档的相应章节。
    • 文档通常会提供更详细的理论解释和更多的使用场景。
    • 当文档也无法解决问题时，尝试直接阅读FastAPI框架本身的源码（通过IDE的“Go to Definition”功能），理解其内部实现。

四、进阶学习：探索社区与实战项目

一旦掌握了FastAPI的核心概念和官方示例，就可以开始探索更广阔的社区项目和真实的生产级应用：

  1. Awesome FastAPI列表： 这是发现高质量FastAPI相关资源的最佳起点。你可以根据自己的兴趣和项目需求，筛选出数据库集成、特定服务（如WebSocket、GraphQL）、部署方案或实际应用案例。

  2. 选择生产级项目进行分析：

    • 优先选择GitHub Star数量多、活跃度高、有清晰README和良好Issue管理的开源项目。
    • 关注其项目结构：如何组织模块、划分业务逻辑、处理配置、管理日志。
    • 学习其高级特性：错误处理策略、中间件使用、后台任务队列（如Celery集成）、消息队列（如Kafka/RabbitMQ）、缓存机制（如Redis）、监控与追踪。
    • 研究其部署方案：Docker Compose文件、Kubernetes配置、CI/CD流程等。

  3. 参与贡献：

    • 从阅读到提交Issue（提问或报告bug），再到提交Pull Request（修复bug或添加新功能），是深入理解一个项目和框架的最佳途径。
    • 为FastAPI或其相关库贡献代码，不仅能提升自身能力，也能为社区做出贡献。

  4. 搭建自己的项目：

    • 将所学知识应用到实际中，从一个简单的API开始，逐步添加认证、数据库、测试、容器化部署等功能。
    • 可以从官方模板项目开始修改，根据自己的需求进行定制。

总结与展望

FastAPI的GitHub项目示例是其强大生态的重要组成部分。它们不仅提供了清晰、可运行的代码，更是学习FastAPI设计哲学、最佳实践和高级用法的金矿。从基础的路由定义到复杂的依赖注入、安全认证和数据库集成，每一个示例都承载着作者对框架的深刻理解和实践经验。

通过系统地学习和实践这些示例，结合官方文档的理论支撑和社区的丰富资源，你将能够：

  • 加速学习曲线： 快速从零开始，掌握FastAPI的核心技能。
  • 提升代码质量： 学习如何编写模块化、可测试、高性能的FastAPI应用。
  • 解决实际问题： 借鉴示例中的解决方案，应对项目中的挑战。
  • 为未来项目奠基： 掌握构建现代高性能Web服务和API的坚实基础。

FastAPI仍在不断发展和完善，其社区也日益壮大。持续关注GitHub上的最新示例、积极参与社区讨论、并将所学应用于实践，你将能更好地驾驭FastAPI这一现代Python Web开发利器，构建出令人瞩目的应用。

发表评论

您的邮箱地址不会被公开。 必填项已用 * 标注

滚动至顶部