简体中文 繁體中文 English Deutsch 한국 사람 بالعربية TÜRKÇE português คนไทย Français Japanese

开启辅助访问 切换到宽版

站内搜索

搜索

活动公告

通知：为庆祝网站一周年，将在5.1日与5.2日开放注册，具体信息请见后续详细公告
04-22 00:04
通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，资源失效请在帖子内回复要求补档，会尽快处理！
10-23 09:31
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

FastAPI Python开发实战教程快速构建现代Web应用的完整指南包含项目案例和最佳实践助你提升开发技能和就业竞争力

威震华夏关云长
SunJu_FaceMall

3万

主题

1116

科技点

3万

积分

白金月票

碾压王

积分
32766

立华奏
发表于 2025-8-23 00:50:47 | 显示全部楼层 |阅读模式

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要 登录 才可以下载或查看，没有账号？立即注册

x
引言

FastAPI是近年来Python生态系统中备受关注的一个现代、快速（高性能）的Web框架，用于构建API。它基于Starlette和Pydantic，具有出色的性能、易用性和直观的API设计。本教程将带你从零开始，逐步掌握FastAPI的核心概念和实际应用，通过项目案例和最佳实践，帮助你提升开发技能和就业竞争力。

1. FastAPI简介

1.1 什么是FastAPI

FastAPI是一个现代、快速（高性能）的Web框架，用于构建API，具有Python 3.6+类型提示。它的主要特点包括：

• 高性能：与NodeJS和Go相当的性能，是最快的Python框架之一
• 快速编码：将开发速度提高约200％至300％
• 更少的bug：减少约40％的人为（开发者）错误
• 直观：强大的编辑器支持，自动补全处处可见
• 简单：易于使用和学习，减少阅读文档的时间
• 简短：最小化代码重复，每个参数声明的多个功能
• 健壮：获取可用于生产的代码，具有自动交互式文档
• 基于标准：基于并完全兼容API的开放标准：OpenAPI（以前称为Swagger）和JSON Schema

1.2 FastAPI与其他框架的比较

与Flask和Django等传统Python Web框架相比，FastAPI具有以下优势：

• 性能：FastAPI的性能远超Flask和Django，接近Go和NodeJS的性能水平
• 异步支持：原生支持异步编程，适合高并发场景
• 自动文档：自动生成交互式API文档（Swagger UI）
• 类型提示：利用Python类型提示进行数据验证和序列化
• 现代Python特性：充分利用Python 3.6+的新特性

2. 环境搭建与基础使用

2.1 安装FastAPI

首先，我们需要安装FastAPI和ASGI服务器（如uvicorn）：
  2. pip install fastapi
  3. pip install "uvicorn[standard]"
复制代码

2.2 创建第一个FastAPI应用

让我们创建一个简单的FastAPI应用：
  2. # main.py
  3. from fastapi import FastAPI
  5. app = FastAPI()
  7. @app.get("/")
  8. def read_root():
  9.     return {"Hello": "World"}
  11. @app.get("/items/{item_id}")
  12. def read_item(item_id: int, q: str | None = None):
  13.     return {"item_id": item_id, "q": q}
复制代码

运行应用：
  2. uvicorn main:app --reload
复制代码

访问http://127.0.0.1:8000你将看到{"Hello": "World"}。

访问http://127.0.0.1:8000/items/5?q=somequery，你将看到{"item_id": 5, "q": "somequery"}。

访问http://127.0.0.1:8000/docs，你将看到自动生成的交互式API文档（SwaggerUI）。

2.3 路由参数和查询参数

FastAPI支持路径参数和查询参数的声明：
  2. from fastapi import FastAPI
  4. app = FastAPI()
  6. @app.get("/users/{user_id}/items/{item_id}")
  7. def read_user_item(
  8.     user_id: int,
  9.     item_id: str,
  10.     q: str | None = None,
  11.     short: bool = False
  12. ):
  13.     item = {"item_id": item_id, "owner_id": user_id}
  14.     if q:
  15.         item.update({"q": q})
  16.     if not short:
  17.         item.update(
  18.             {"description": "This is an amazing item that has a long description"}
  19.         )
  20.     return item
复制代码

在这个例子中：

• user_id和item_id是路径参数
• q是可选的查询参数
• short是带有默认值的查询参数

3. 请求体和响应模型

3.1 使用Pydantic模型定义请求体

FastAPI使用Pydantic模型来定义请求体的结构：
  2. from fastapi import FastAPI
  3. from pydantic import BaseModel
  5. app = FastAPI()
  7. class Item(BaseModel):
  8.     name: str
  9.     description: str | None = None
  10.     price: float
  11.     tax: float | None = None
  13. @app.post("/items/")
  14. def create_item(item: Item):
  15.     return item
复制代码

3.2 响应模型

你可以使用相同的Pydantic模型来定义响应：
  2. from fastapi import FastAPI
  3. from pydantic import BaseModel
  5. app = FastAPI()
  7. class Item(BaseModel):
  8.     name: str
  9.     description: str | None = None
  10.     price: float
  11.     tax: float | None = None
  12.     tags: list[str] = []
  14. @app.post("/items/", response_model=Item)
  15. def create_item(item: Item):
  16.     return item
复制代码

3.3 响应状态码

FastAPI允许你直接在路径操作中声明响应状态码：
  2. from fastapi import FastAPI, status
  4. app = FastAPI()
  6. @app.post("/items/", status_code=status.HTTP_201_CREATED)
  7. def create_item(name: str):
  8.     return {"name": name}
复制代码

4. 数据验证与序列化

4.1 数据验证

FastAPI使用Pydantic进行数据验证：
  2. from fastapi import FastAPI
  3. from pydantic import BaseModel, Field
  5. app = FastAPI()
  7. class Item(BaseModel):
  8.     name: str = Field(..., min_length=1, max_length=50)
  9.     description: str | None = Field(
  10.         None,
  11.         title="The description of the item",
  12.         max_length=300
  13.     )
  14.     price: float = Field(..., gt=0, description="The price must be greater than zero")
  15.     tax: float | None = None
  17. @app.put("/items/{item_id}")
  18. def update_item(item_id: int, item: Item):
  19.     return {"item_id": item_id, **item.dict()}
复制代码

4.2 数据序列化

FastAPI自动处理数据的序列化和反序列化：
  2. from datetime import datetime
  3. from typing import List
  4. from fastapi import FastAPI
  5. from pydantic import BaseModel
  7. app = FastAPI()
  9. class User(BaseModel):
  10.     id: int
  11.     name: str = "John Doe"
  12.     signup_ts: datetime | None = None
  13.     friends: List[int] = []
  15. @app.put("/users/{user_id}")
  16. def update_user(user_id: int, user: User):
  17.     results = {"user_id": user_id, "user": user}
  18.     return results
复制代码

5. 依赖注入系统

FastAPI有一个强大的依赖注入系统，使你能够轻松地集成组件：
  2. from fastapi import FastAPI, Depends
  3. from typing import Annotated
  5. app = FastAPI()
  7. async def common_parameters(q: str | None = None, skip: int = 0, limit: int = 100):
  8.     return {"q": q, "skip": skip, "limit": limit}
  10. @app.get("/users/")
  11. def read_users(commons: Annotated[dict, Depends(common_parameters)]):
  12.     return commons
  14. @app.get("/items/")
  15. def read_items(commons: Annotated[dict, Depends(common_parameters)]):
  16.     return commons
复制代码

5.1 类作为依赖

你也可以使用类作为依赖：
  2. from fastapi import FastAPI, Depends
  3. from typing import Annotated
  5. app = FastAPI()
  7. class CommonQueryParams:
  8.     def __init__(self, q: str | None = None, skip: int = 0, limit: int = 100):
  9.         self.q = q
  10.         self.skip = skip
  11.         self.limit = limit
  13. @app.get("/users/")
  14. def read_users(commons: Annotated[CommonQueryParams, Depends()]):
  15.     response = {}
  16.     if commons.q:
  17.         response.update({"q": commons.q})
  18.     items = [{"item_id": "Foo"}, {"item_id": "Bar"}]
  19.     response.update({"items": items[commons.skip : commons.skip + commons.limit]})
  20.     return response
复制代码

6. 安全性与认证

6.1 OAuth2密码流

FastAPI内置了OAuth2密码流的支持：
  2. from fastapi import FastAPI, Depends, HTTPException, status
  3. from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
  4. from pydantic import BaseModel
  6. app = FastAPI()
  8. oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
  10. class User(BaseModel):
  11.     username: str
  12.     email: str | None = None
  13.     full_name: str | None = None
  14.     disabled: bool | None = None
  16. class UserInDB(User):
  17.     hashed_password: str
  19. def fake_hash_password(password: str):
  20.     return "fakehashed" + password
  22. users_db = {
  23.     "johndoe": {
  24.         "username": "johndoe",
  25.         "full_name": "John Doe",
  26.         "email": "johndoe@example.com",
  27.         "hashed_password": fake_hash_password("secret"),
  28.         "disabled": False,
  29.     }
  30. }
  32. def get_user(db, username: str):
  33.     if username in db:
  34.         user_dict = db[username]
  35.         return UserInDB(**user_dict)
  37. def fake_decode_token(token):
  38.     user = get_user(users_db, token)
  39.     return user
  41. async def get_current_user(token: Annotated[str, Depends(oauth2_scheme)]):
  42.     user = fake_decode_token(token)
  43.     if not user:
  44.         raise HTTPException(
  45.             status_code=status.HTTP_401_UNAUTHORIZED,
  46.             detail="Invalid authentication credentials",
  47.             headers={"WWW-Authenticate": "Bearer"},
  48.         )
  49.     return user
  51. @app.post("/token")
  52. async def login(form_data: Annotated[OAuth2PasswordRequestForm, Depends()]):
  53.     user_dict = users_db.get(form_data.username)
  54.     if not user_dict:
  55.         raise HTTPException(status_code=400, detail="Incorrect username or password")
  56.     user = UserInDB(**user_dict)
  57.     hashed_password = fake_hash_password(form_data.password)
  58.     if not hashed_password == user.hashed_password:
  59.         raise HTTPException(status_code=400, detail="Incorrect username or password")
  60.     return {"access_token": user.username, "token_type": "bearer"}
  62. @app.get("/users/me")
  63. async def read_users_me(current_user: Annotated[User, Depends(get_current_user)]):
  64.     return current_user
复制代码

6.2 JWT令牌认证

使用JWT进行认证：
  2. from datetime import datetime, timedelta
  3. from typing import Annotated
  5. from fastapi import FastAPI, Depends, HTTPException, status
  6. from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm
  7. from jose import JWTError, jwt
  8. from passlib.context import CryptContext
  9. from pydantic import BaseModel
  11. app = FastAPI()
  13. # to get a string like this run:
  14. # openssl rand -hex 32
  15. SECRET_KEY = "09d25e094faa6ca2556c818166b7a9563b93f7099f6f0f4caa6cf63b88e8d3e7"
  16. ALGORITHM = "HS256"
  17. ACCESS_TOKEN_EXPIRE_MINUTES = 30
  19. fake_users_db = {
  20.     "johndoe": {
  21.         "username": "johndoe",
  22.         "full_name": "John Doe",
  23.         "email": "johndoe@example.com",
  24.         "hashed_password": "$2b$12$EixZaYVK1fsbw1ZfbX3OXePaWxn96p36WQoeG6Lruj3vjPGga31lW",
  25.         "disabled": False,
  26.     }
  27. }
  29. class Token(BaseModel):
  30.     access_token: str
  31.     token_type: str
  33. class TokenData(BaseModel):
  34.     username: str | None = None
  36. class User(BaseModel):
  37.     username: str
  38.     email: str | None = None
  39.     full_name: str | None = None
  40.     disabled: bool | None = None
  42. class UserInDB(User):
  43.     hashed_password: str
  45. pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
  46. oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token")
  48. def verify_password(plain_password, hashed_password):
  49.     return pwd_context.verify(plain_password, hashed_password)
  51. def get_password_hash(password):
  52.     return pwd_context.hash(password)
  54. def get_user(db, username: str):
  55.     if username in db:
  56.         user_dict = db[username]
  57.         return UserInDB(**user_dict)
  59. def authenticate_user(fake_db, username: str, password: str):
  60.     user = get_user(fake_db, username)
  61.     if not user:
  62.         return False
  63.     if not verify_password(password, user.hashed_password):
  64.         return False
  65.     return user
  67. def create_access_token(data: dict, expires_delta: timedelta | None = None):
  68.     to_encode = data.copy()
  69.     if expires_delta:
  70.         expire = datetime.utcnow() + expires_delta
  71.     else:
  72.         expire = datetime.utcnow() + timedelta(minutes=15)
  73.     to_encode.update({"exp": expire})
  74.     encoded_jwt = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
  75.     return encoded_jwt
  77. async def get_current_user(token: Annotated[str, Depends(oauth2_scheme)]):
  78.     credentials_exception = HTTPException(
  79.         status_code=status.HTTP_401_UNAUTHORIZED,
  80.         detail="Could not validate credentials",
  81.         headers={"WWW-Authenticate": "Bearer"},
  82.     )
  83.     try:
  84.         payload = jwt.decode(token, SECRET_KEY, algorithms=[ALGORITHM])
  85.         username: str = payload.get("sub")
  86.         if username is None:
  87.             raise credentials_exception
  88.         token_data = TokenData(username=username)
  89.     except JWTError:
  90.         raise credentials_exception
  91.     user = get_user(fake_users_db, username=token_data.username)
  92.     if user is None:
  93.         raise credentials_exception
  94.     return user
  96. async def get_current_active_user(
  97.     current_user: Annotated[User, Depends(get_current_user)]
  98. ):
  99.     if current_user.disabled:
  100.         raise HTTPException(status_code=400, detail="Inactive user")
  101.     return current_user
  103. @app.post("/token", response_model=Token)
  104. async def login_for_access_token(
  105.     form_data: Annotated[OAuth2PasswordRequestForm, Depends()]
  106. ):
  107.     user = authenticate_user(fake_users_db, form_data.username, form_data.password)
  108.     if not user:
  109.         raise HTTPException(
  110.             status_code=status.HTTP_401_UNAUTHORIZED,
  111.             detail="Incorrect username or password",
  112.             headers={"WWW-Authenticate": "Bearer"},
  113.         )
  114.     access_token_expires = timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES)
  115.     access_token = create_access_token(
  116.         data={"sub": user.username}, expires_delta=access_token_expires
  117.     )
  118.     return {"access_token": access_token, "token_type": "bearer"}
  120. @app.get("/users/me/", response_model=User)
  121. async def read_users_me(
  122.     current_user: Annotated[User, Depends(get_current_active_user)]
  123. ):
  124.     return current_user
  126. @app.get("/users/me/items/")
  127. async def read_own_items(
  128.     current_user: Annotated[User, Depends(get_current_active_user)]
  129. ):
  130.     return [{"item_id": "Foo", "owner": current_user.username}]
复制代码

7. 中间件和CORS

7.1 中间件

FastAPI支持中间件，可以在请求处理前后执行代码：
  2. from fastapi import FastAPI, Request
  3. import time
  5. app = FastAPI()
  7. @app.middleware("http")
  8. async def add_process_time_header(request: Request, call_next):
  9.     start_time = time.time()
  10.     response = await call_next(request)
  11.     process_time = time.time() - start_time
  12.     response.headers["X-Process-Time"] = str(process_time)
  13.     return response
  15. @app.get("/")
  16. async def main():
  17.     return {"message": "Hello World"}
复制代码

7.2 CORS（跨域资源共享）

处理跨域请求：
  2. from fastapi import FastAPI
  3. from fastapi.middleware.cors import CORSMiddleware
  5. app = FastAPI()
  7. origins = [
  8.     "http://localhost.tiangolo.com",
  9.     "https://localhost.tiangolo.com",
  10.     "http://localhost",
  11.     "http://localhost:8080",
  12. ]
  14. app.add_middleware(
  15.     CORSMiddleware,
  16.     allow_origins=origins,
  17.     allow_credentials=True,
  18.     allow_methods=["*"],
  19.     allow_headers=["*"],
  20. )
  22. @app.get("/")
  23. async def main():
  24.     return {"message": "Hello World"}
复制代码

8. 数据库集成

8.1 SQLAlchemy集成

使用SQLAlchemy与数据库交互：
  2. from fastapi import FastAPI, Depends, HTTPException
  3. from sqlalchemy import create_engine
  4. from sqlalchemy.ext.declarative import declarative_base
  5. from sqlalchemy.orm import sessionmaker, Session
  6. from pydantic import BaseModel
  8. SQLALCHEMY_DATABASE_URL = "sqlite:///./test.db"
  10. engine = create_engine(
  11.     SQLALCHEMY_DATABASE_URL, connect_args={"check_same_thread": False}
  12. )
  13. SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
  15. Base = declarative_base()
  17. app = FastAPI()
  19. # Dependency
  20. def get_db():
  21.     db = SessionLocal()
  22.     try:
  23.         yield db
  24.     finally:
  25.         db.close()
  27. # Pydantic models
  28. class ItemBase(BaseModel):
  29.     title: str
  30.     description: str | None = None
  32. class ItemCreate(ItemBase):
  33.     pass
  35. class Item(ItemBase):
  36.     id: int
  37.     owner_id: int
  39.     class Config:
  40.         orm_mode = True
  42. # SQLAlchemy models
  43. class ItemModel(Base):
  44.     __tablename__ = "items"
  46.     id = Column(Integer, primary_key=True, index=True)
  47.     title = Column(String, index=True)
  48.     description = Column(String, index=True)
  49.     owner_id = Column(Integer, ForeignKey("users.id"))
  51. # Create tables
  52. Base.metadata.create_all(bind=engine)
  54. @app.post("/items/", response_model=Item)
  55. def create_item(item: ItemCreate, db: Session = Depends(get_db)):
  56.     db_item = ItemModel(**item.dict())
  57.     db.add(db_item)
  58.     db.commit()
  59.     db.refresh(db_item)
  60.     return db_item
  62. @app.get("/items/{item_id}", response_model=Item)
  63. def read_item(item_id: int, db: Session = Depends(get_db)):
  64.     db_item = db.query(ItemModel).filter(ItemModel.id == item_id).first()
  65.     if db_item is None:
  66.         raise HTTPException(status_code=404, detail="Item not found")
  67.     return db_item
复制代码

8.2 异步数据库操作

使用asyncpg和SQLAlchemy Core进行异步数据库操作：
  2. from fastapi import FastAPI
  3. from databases import Database
  4. import sqlalchemy
  6. app = FastAPI()
  8. DATABASE_URL = "postgresql://user:password@postgresserver/db"
  10. database = Database(DATABASE_URL)
  11. metadata = sqlalchemy.MetaData()
  13. notes = sqlalchemy.Table(
  14.     "notes",
  15.     metadata,
  16.     sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True),
  17.     sqlalchemy.Column("text", sqlalchemy.String),
  18.     sqlalchemy.Column("completed", sqlalchemy.Boolean),
  19. )
  21. engine = sqlalchemy.create_engine(DATABASE_URL)
  22. metadata.create_all(engine)
  24. @app.on_event("startup")
  25. async def startup():
  26.     await database.connect()
  28. @app.on_event("shutdown")
  29. async def shutdown():
  30.     await database.disconnect()
  32. @app.get("/notes/")
  33. async def read_notes():
  34.     query = notes.select()
  35.     return await database.fetch_all(query)
  37. @app.post("/notes/")
  38. async def create_note(note: dict):
  39.     query = notes.insert().values(text=note["text"], completed=note["completed"])
  40.     last_record_id = await database.execute(query)
  41.     return {**note, "id": last_record_id}
复制代码

9. 测试FastAPI应用

9.1 使用TestClient进行测试

FastAPI提供了TestClient用于测试：
  2. from fastapi import FastAPI
  3. from fastapi.testclient import TestClient
  5. app = FastAPI()
  7. @app.get("/")
  8. async def read_main():
  9.     return {"msg": "Hello World"}
  11. client = TestClient(app)
  13. def test_read_main():
  14.     response = client.get("/")
  15.     assert response.status_code == 200
  16.     assert response.json() == {"msg": "Hello World"}
复制代码

9.2 测试带依赖的应用

测试带有依赖的应用：
  2. from fastapi import FastAPI, Depends
  3. from fastapi.testclient import TestClient
  5. app = FastAPI()
  7. async def common_parameters(q: str | None = None, skip: int = 0, limit: int = 100):
  8.     return {"q": q, "skip": skip, "limit": limit}
  10. @app.get("/users/")
  11. def read_users(commons: dict = Depends(common_parameters)):
  12.     return commons
  14. client = TestClient(app)
  16. def test_read_users():
  17.     response = client.get("/users/")
  18.     assert response.status_code == 200
  19.     assert response.json() == {"q": None, "skip": 0, "limit": 100}
  21. def test_read_users_with_params():
  22.     response = client.get("/users/?q=foo&skip=5&limit=10")
  23.     assert response.status_code == 200
  24.     assert response.json() == {"q": "foo", "skip": 5, "limit": 10}
复制代码

10. 项目案例：构建一个完整的博客API

让我们通过一个完整的博客API项目来应用我们学到的知识。

10.1 项目结构
  2. blog_api/
  3. ├── app/
  4. │   ├── __init__.py
  5. │   ├── main.py
  6. │   ├── database.py
  7. │   ├── models.py
  8. │   ├── schemas.py
  9. │   ├── crud.py
  10. │   └── api/
  11. │       ├── __init__.py
  12. │       ├── deps.py
  13. │       └── endpoints/
  14. │           ├── __init__.py
  15. │           ├── users.py
  16. │           ├── posts.py
  17. │           └── comments.py
  18. ├── alembic.ini
  19. ├── requirements.txt
  20. └── tests/
  21.     ├── __init__.py
  22.     ├── conftest.py
  23.     └── test_api.py
复制代码

10.2 数据库模型
  2. # app/models.py
  3. from sqlalchemy import Boolean, Column, ForeignKey, Integer, String, Text, DateTime
  4. from sqlalchemy.orm import relationship
  5. from sqlalchemy.sql import func
  6. from .database import Base
  8. class User(Base):
  9.     __tablename__ = "users"
  11.     id = Column(Integer, primary_key=True, index=True)
  12.     email = Column(String, unique=True, index=True)
  13.     username = Column(String, unique=True, index=True)
  14.     hashed_password = Column(String)
  15.     is_active = Column(Boolean, default=True)
  16.     created_at = Column(DateTime(timezone=True), server_default=func.now())
  18.     posts = relationship("Post", back_populates="author")
  19.     comments = relationship("Comment", back_populates="author")
  21. class Post(Base):
  22.     __tablename__ = "posts"
  24.     id = Column(Integer, primary_key=True, index=True)
  25.     title = Column(String, index=True)
  26.     content = Column(Text)
  27.     author_id = Column(Integer, ForeignKey("users.id"))
  28.     created_at = Column(DateTime(timezone=True), server_default=func.now())
  29.     updated_at = Column(DateTime(timezone=True), onupdate=func.now())
  31.     author = relationship("User", back_populates="posts")
  32.     comments = relationship("Comment", back_populates="post")
  34. class Comment(Base):
  35.     __tablename__ = "comments"
  37.     id = Column(Integer, primary_key=True, index=True)
  38.     content = Column(Text)
  39.     post_id = Column(Integer, ForeignKey("posts.id"))
  40.     author_id = Column(Integer, ForeignKey("users.id"))
  41.     created_at = Column(DateTime(timezone=True), server_default=func.now())
  43.     post = relationship("Post", back_populates="comments")
  44.     author = relationship("User", back_populates="comments")
复制代码

10.3 Pydantic模型
  2. # app/schemas.py
  3. from pydantic import BaseModel, EmailStr
  4. from typing import List, Optional
  5. from datetime import datetime
  7. # User schemas
  8. class UserBase(BaseModel):
  9.     email: EmailStr
  10.     username: str
  12. class UserCreate(UserBase):
  13.     password: str
  15. class UserUpdate(UserBase):
  16.     password: Optional[str] = None
  18. class User(UserBase):
  19.     id: int
  20.     is_active: bool
  21.     created_at: datetime
  23.     class Config:
  24.         orm_mode = True
  26. # Post schemas
  27. class PostBase(BaseModel):
  28.     title: str
  29.     content: str
  31. class PostCreate(PostBase):
  32.     pass
  34. class PostUpdate(PostBase):
  35.     pass
  37. class Post(PostBase):
  38.     id: int
  39.     author_id: int
  40.     created_at: datetime
  41.     updated_at: Optional[datetime] = None
  42.     author: User
  44.     class Config:
  45.         orm_mode = True
  47. # Comment schemas
  48. class CommentBase(BaseModel):
  49.     content: str
  51. class CommentCreate(CommentBase):
  52.     post_id: int
  54. class CommentUpdate(CommentBase):
  55.     pass
  57. class Comment(CommentBase):
  58.     id: int
  59.     post_id: int
  60.     author_id: int
  61.     created_at: datetime
  62.     author: User
  64.     class Config:
  65.         orm_mode = True
复制代码

10.4 CRUD操作
  2. # app/crud.py
  3. from sqlalchemy.orm import Session
  4. from . import models, schemas
  5. from passlib.context import CryptContext
  7. pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
  9. def get_password_hash(password: str):
  10.     return pwd_context.hash(password)
  12. def verify_password(plain_password, hashed_password):
  13.     return pwd_context.verify(plain_password, hashed_password)
  15. # User CRUD
  16. def get_user(db: Session, user_id: int):
  17.     return db.query(models.User).filter(models.User.id == user_id).first()
  19. def get_user_by_email(db: Session, email: str):
  20.     return db.query(models.User).filter(models.User.email == email).first()
  22. def get_user_by_username(db: Session, username: str):
  23.     return db.query(models.User).filter(models.User.username == username).first()
  25. def get_users(db: Session, skip: int = 0, limit: int = 100):
  26.     return db.query(models.User).offset(skip).limit(limit).all()
  28. def create_user(db: Session, user: schemas.UserCreate):
  29.     hashed_password = get_password_hash(user.password)
  30.     db_user = models.User(
  31.         email=user.email,
  32.         username=user.username,
  33.         hashed_password=hashed_password
  34.     )
  35.     db.add(db_user)
  36.     db.commit()
  37.     db.refresh(db_user)
  38.     return db_user
  40. def update_user(db: Session, user_id: int, user: schemas.UserUpdate):
  41.     db_user = get_user(db, user_id)
  42.     if not db_user:
  43.         return None
  44.    
  45.     update_data = user.dict(exclude_unset=True)
  46.     if "password" in update_data:
  47.         update_data["hashed_password"] = get_password_hash(update_data.pop("password"))
  48.    
  49.     for field, value in update_data.items():
  50.         setattr(db_user, field, value)
  51.    
  52.     db.commit()
  53.     db.refresh(db_user)
  54.     return db_user
  56. def delete_user(db: Session, user_id: int):
  57.     db_user = get_user(db, user_id)
  58.     if not db_user:
  59.         return None
  60.    
  61.     db.delete(db_user)
  62.     db.commit()
  63.     return db_user
  65. # Post CRUD
  66. def get_post(db: Session, post_id: int):
  67.     return db.query(models.Post).filter(models.Post.id == post_id).first()
  69. def get_posts(db: Session, skip: int = 0, limit: int = 100):
  70.     return db.query(models.Post).offset(skip).limit(limit).all()
  72. def get_posts_by_author(db: Session, author_id: int, skip: int = 0, limit: int = 100):
  73.     return db.query(models.Post).filter(models.Post.author_id == author_id).offset(skip).limit(limit).all()
  75. def create_post(db: Session, post: schemas.PostCreate, author_id: int):
  76.     db_post = models.Post(**post.dict(), author_id=author_id)
  77.     db.add(db_post)
  78.     db.commit()
  79.     db.refresh(db_post)
  80.     return db_post
  82. def update_post(db: Session, post_id: int, post: schemas.PostUpdate):
  83.     db_post = get_post(db, post_id)
  84.     if not db_post:
  85.         return None
  86.    
  87.     update_data = post.dict(exclude_unset=True)
  88.     for field, value in update_data.items():
  89.         setattr(db_post, field, value)
  90.    
  91.     db.commit()
  92.     db.refresh(db_post)
  93.     return db_post
  95. def delete_post(db: Session, post_id: int):
  96.     db_post = get_post(db, post_id)
  97.     if not db_post:
  98.         return None
  99.    
  100.     db.delete(db_post)
  101.     db.commit()
  102.     return db_post
  104. # Comment CRUD
  105. def get_comment(db: Session, comment_id: int):
  106.     return db.query(models.Comment).filter(models.Comment.id == comment_id).first()
  108. def get_comments(db: Session, skip: int = 0, limit: int = 100):
  109.     return db.query(models.Comment).offset(skip).limit(limit).all()
  111. def get_comments_by_post(db: Session, post_id: int, skip: int = 0, limit: int = 100):
  112.     return db.query(models.Comment).filter(models.Comment.post_id == post_id).offset(skip).limit(limit).all()
  114. def get_comments_by_author(db: Session, author_id: int, skip: int = 0, limit: int = 100):
  115.     return db.query(models.Comment).filter(models.Comment.author_id == author_id).offset(skip).limit(limit).all()
  117. def create_comment(db: Session, comment: schemas.CommentCreate, author_id: int):
  118.     db_comment = models.Comment(**comment.dict(), author_id=author_id)
  119.     db.add(db_comment)
  120.     db.commit()
  121.     db.refresh(db_comment)
  122.     return db_comment
  124. def update_comment(db: Session, comment_id: int, comment: schemas.CommentUpdate):
  125.     db_comment = get_comment(db, comment_id)
  126.     if not db_comment:
  127.         return None
  128.    
  129.     update_data = comment.dict(exclude_unset=True)
  130.     for field, value in update_data.items():
  131.         setattr(db_comment, field, value)
  132.    
  133.     db.commit()
  134.     db.refresh(db_comment)
  135.     return db_comment
  137. def delete_comment(db: Session, comment_id: int):
  138.     db_comment = get_comment(db, comment_id)
  139.     if not db_comment:
  140.         return None
  141.    
  142.     db.delete(db_comment)
  143.     db.commit()
  144.     return db_comment
复制代码

10.5 API端点
  2. # app/api/endpoints/users.py
  3. from fastapi import APIRouter, Depends, HTTPException, status
  4. from sqlalchemy.orm import Session
  5. from typing import List
  6. from .. import crud, schemas, models
  7. from ..database import get_db
  8. from .deps import get_current_user
  10. router = APIRouter()
  12. @router.post("/", response_model=schemas.User)
  13. def create_user(user: schemas.UserCreate, db: Session = Depends(get_db)):
  14.     db_user = crud.get_user_by_email(db, email=user.email)
  15.     if db_user:
  16.         raise HTTPException(
  17.             status_code=400,
  18.             detail="Email already registered"
  19.         )
  20.     db_user = crud.get_user_by_username(db, username=user.username)
  21.     if db_user:
  22.         raise HTTPException(
  23.             status_code=400,
  24.             detail="Username already taken"
  25.         )
  26.     return crud.create_user(db=db, user=user)
  28. @router.get("/", response_model=List[schemas.User])
  29. def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
  30.     users = crud.get_users(db, skip=skip, limit=limit)
  31.     return users
  33. @router.get("/me", response_model=schemas.User)
  34. def read_users_me(current_user: models.User = Depends(get_current_user)):
  35.     return current_user
  37. @router.get("/{user_id}", response_model=schemas.User)
  38. def read_user(user_id: int, db: Session = Depends(get_db)):
  39.     db_user = crud.get_user(db, user_id=user_id)
  40.     if db_user is None:
  41.         raise HTTPException(status_code=404, detail="User not found")
  42.     return db_user
  44. @router.put("/me", response_model=schemas.User)
  45. def update_user_me(
  46.     user: schemas.UserUpdate,
  47.     db: Session = Depends(get_db),
  48.     current_user: models.User = Depends(get_current_user)
  49. ):
  50.     updated_user = crud.update_user(db, user_id=current_user.id, user=user)
  51.     if not updated_user:
  52.         raise HTTPException(status_code=404, detail="User not found")
  53.     return updated_user
  55. @router.delete("/me", response_model=schemas.User)
  56. def delete_user_me(
  57.     db: Session = Depends(get_db),
  58.     current_user: models.User = Depends(get_current_user)
  59. ):
  60.     deleted_user = crud.delete_user(db, user_id=current_user.id)
  61.     if not deleted_user:
  62.         raise HTTPException(status_code=404, detail="User not found")
  63.     return deleted_user
复制代码
  2. # app/api/endpoints/posts.py
  3. from fastapi import APIRouter, Depends, HTTPException, status
  4. from sqlalchemy.orm import Session
  5. from typing import List
  6. from .. import crud, schemas, models
  7. from ..database import get_db
  8. from .deps import get_current_user
  10. router = APIRouter()
  12. @router.post("/", response_model=schemas.Post)
  13. def create_post(
  14.     post: schemas.PostCreate,
  15.     db: Session = Depends(get_db),
  16.     current_user: models.User = Depends(get_current_user)
  17. ):
  18.     return crud.create_post(db=db, post=post, author_id=current_user.id)
  20. @router.get("/", response_model=List[schemas.Post])
  21. def read_posts(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
  22.     posts = crud.get_posts(db, skip=skip, limit=limit)
  23.     return posts
  25. @router.get("/{post_id}", response_model=schemas.Post)
  26. def read_post(post_id: int, db: Session = Depends(get_db)):
  27.     db_post = crud.get_post(db, post_id=post_id)
  28.     if db_post is None:
  29.         raise HTTPException(status_code=404, detail="Post not found")
  30.     return db_post
  32. @router.put("/{post_id}", response_model=schemas.Post)
  33. def update_post(
  34.     post_id: int,
  35.     post: schemas.PostUpdate,
  36.     db: Session = Depends(get_db),
  37.     current_user: models.User = Depends(get_current_user)
  38. ):
  39.     db_post = crud.get_post(db, post_id=post_id)
  40.     if db_post is None:
  41.         raise HTTPException(status_code=404, detail="Post not found")
  42.     if db_post.author_id != current_user.id:
  43.         raise HTTPException(
  44.             status_code=status.HTTP_403_FORBIDDEN,
  45.             detail="Not authorized to update this post"
  46.         )
  47.     updated_post = crud.update_post(db, post_id=post_id, post=post)
  48.     if not updated_post:
  49.         raise HTTPException(status_code=404, detail="Post not found")
  50.     return updated_post
  52. @router.delete("/{post_id}", response_model=schemas.Post)
  53. def delete_post(
  54.     post_id: int,
  55.     db: Session = Depends(get_db),
  56.     current_user: models.User = Depends(get_current_user)
  57. ):
  58.     db_post = crud.get_post(db, post_id=post_id)
  59.     if db_post is None:
  60.         raise HTTPException(status_code=404, detail="Post not found")
  61.     if db_post.author_id != current_user.id:
  62.         raise HTTPException(
  63.             status_code=status.HTTP_403_FORBIDDEN,
  64.             detail="Not authorized to delete this post"
  65.         )
  66.     deleted_post = crud.delete_post(db, post_id=post_id)
  67.     if not deleted_post:
  68.         raise HTTPException(status_code=404, detail="Post not found")
  69.     return deleted_post
复制代码
  2. # app/api/endpoints/comments.py
  3. from fastapi import APIRouter, Depends, HTTPException, status
  4. from sqlalchemy.orm import Session
  5. from typing import List
  6. from .. import crud, schemas, models
  7. from ..database import get_db
  8. from .deps import get_current_user
  10. router = APIRouter()
  12. @router.post("/", response_model=schemas.Comment)
  13. def create_comment(
  14.     comment: schemas.CommentCreate,
  15.     db: Session = Depends(get_db),
  16.     current_user: models.User = Depends(get_current_user)
  17. ):
  18.     # Check if post exists
  19.     db_post = crud.get_post(db, post_id=comment.post_id)
  20.     if db_post is None:
  21.         raise HTTPException(status_code=404, detail="Post not found")
  22.    
  23.     return crud.create_comment(db=db, comment=comment, author_id=current_user.id)
  25. @router.get("/", response_model=List[schemas.Comment])
  26. def read_comments(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)):
  27.     comments = crud.get_comments(db, skip=skip, limit=limit)
  28.     return comments
  30. @router.get("/post/{post_id}", response_model=List[schemas.Comment])
  31. def read_comments_by_post(
  32.     post_id: int,
  33.     skip: int = 0,
  34.     limit: int = 100,
  35.     db: Session = Depends(get_db)
  36. ):
  37.     # Check if post exists
  38.     db_post = crud.get_post(db, post_id=post_id)
  39.     if db_post is None:
  40.         raise HTTPException(status_code=404, detail="Post not found")
  41.    
  42.     comments = crud.get_comments_by_post(db, post_id=post_id, skip=skip, limit=limit)
  43.     return comments
  45. @router.get("/{comment_id}", response_model=schemas.Comment)
  46. def read_comment(comment_id: int, db: Session = Depends(get_db)):
  47.     db_comment = crud.get_comment(db, comment_id=comment_id)
  48.     if db_comment is None:
  49.         raise HTTPException(status_code=404, detail="Comment not found")
  50.     return db_comment
  52. @router.put("/{comment_id}", response_model=schemas.Comment)
  53. def update_comment(
  54.     comment_id: int,
  55.     comment: schemas.CommentUpdate,
  56.     db: Session = Depends(get_db),
  57.     current_user: models.User = Depends(get_current_user)
  58. ):
  59.     db_comment = crud.get_comment(db, comment_id=comment_id)
  60.     if db_comment is None:
  61.         raise HTTPException(status_code=404, detail="Comment not found")
  62.     if db_comment.author_id != current_user.id:
  63.         raise HTTPException(
  64.             status_code=status.HTTP_403_FORBIDDEN,
  65.             detail="Not authorized to update this comment"
  66.         )
  67.     updated_comment = crud.update_comment(db, comment_id=comment_id, comment=comment)
  68.     if not updated_comment:
  69.         raise HTTPException(status_code=404, detail="Comment not found")
  70.     return updated_comment
  72. @router.delete("/{comment_id}", response_model=schemas.Comment)
  73. def delete_comment(
  74.     comment_id: int,
  75.     db: Session = Depends(get_db),
  76.     current_user: models.User = Depends(get_current_user)
  77. ):
  78.     db_comment = crud.get_comment(db, comment_id=comment_id)
  79.     if db_comment is None:
  80.         raise HTTPException(status_code=404, detail="Comment not found")
  81.     if db_comment.author_id != current_user.id:
  82.         raise HTTPException(
  83.             status_code=status.HTTP_403_FORBIDDEN,
  84.             detail="Not authorized to delete this comment"
  85.         )
  86.     deleted_comment = crud.delete_comment(db, comment_id=comment_id)
  87.     if not deleted_comment:
  88.         raise HTTPException(status_code=404, detail="Comment not found")
  89.     return deleted_comment
复制代码

10.6 主应用
  2. # app/main.py
  3. from fastapi import FastAPI
  4. from fastapi.middleware.cors import CORSMiddleware
  5. from . import models
  6. from .database import engine
  7. from .api.api_v1.api import api_router
  9. # Create tables
  10. models.Base.metadata.create_all(bind=engine)
  12. app = FastAPI(title="Blog API", openapi_url="/api/v1/openapi.json")
  14. # Set up CORS middleware
  15. app.add_middleware(
  16.     CORSMiddleware,
  17.     allow_origins=["*"],
  18.     allow_credentials=True,
  19.     allow_methods=["*"],
  20.     allow_headers=["*"],
  21. )
  23. # Include API router
  24. app.include_router(api_router, prefix="/api/v1")
  26. @app.get("/")
  27. async def root():
  28.     return {"message": "Welcome to Blog API. See /api/v1/docs for API documentation."}
复制代码

10.7 依赖项
  2. # app/api/deps.py
  3. from fastapi import Depends, HTTPException, status
  4. from fastapi.security import OAuth2PasswordBearer
  5. from sqlalchemy.orm import Session
  6. from jose import JWTError, jwt
  7. from ..database import get_db
  8. from .. import crud, models, schemas
  9. from ..config import settings
  11. oauth2_scheme = OAuth2PasswordBearer(tokenUrl=f"{settings.API_V1_STR}/login/access-token")
  13. def get_current_user(
  14.     db: Session = Depends(get_db), token: str = Depends(oauth2_scheme)
  15. ) -> models.User:
  16.     credentials_exception = HTTPException(
  17.         status_code=status.HTTP_401_UNAUTHORIZED,
  18.         detail="Could not validate credentials",
  19.         headers={"WWW-Authenticate": "Bearer"},
  20.     )
  21.     try:
  22.         payload = jwt.decode(
  23.             token, settings.SECRET_KEY, algorithms=[settings.ALGORITHM]
  24.         )
  25.         user_id: int = payload.get("sub")
  26.         if user_id is None:
  27.             raise credentials_exception
  28.         token_data = schemas.TokenPayload(sub=user_id)
  29.     except JWTError:
  30.         raise credentials_exception
  31.     user = crud.get_user(db, user_id=token_data.sub)
  32.     if user is None:
  33.         raise credentials_exception
  34.     return user
  36. def get_current_active_user(
  37.     current_user: models.User = Depends(get_current_user),
  38. ) -> models.User:
  39.     if not crud.is_active(current_user):
  40.         raise HTTPException(status_code=400, detail="Inactive user")
  41.     return current_user
复制代码

11. 最佳实践

11.1 项目结构组织

• 使用分层架构，将应用分为不同的层（API、业务逻辑、数据访问）
• 使用模块化设计，将相关功能组织在一起
• 使用依赖注入来管理组件之间的依赖关系

11.2 错误处理
  2. from fastapi import FastAPI, Request, HTTPException
  3. from fastapi.responses import JSONResponse
  4. from fastapi.exceptions import RequestValidationError
  5. from starlette.exceptions import HTTPException as StarletteHTTPException
  7. app = FastAPI()
  9. @app.exception_handler(StarletteHTTPException)
  10. async def http_exception_handler(request: Request, exc: StarletteHTTPException):
  11.     return JSONResponse(
  12.         status_code=exc.status_code,
  13.         content={"message": exc.detail},
  14.     )
  16. @app.exception_handler(RequestValidationError)
  17. async def validation_exception_handler(request: Request, exc: RequestValidationError):
  18.     return JSONResponse(
  19.         status_code=422,
  20.         content={"message": "Validation error", "details": exc.errors()},
  21.     )
  23. @app.exception_handler(Exception)
  24. async def general_exception_handler(request: Request, exc: Exception):
  25.     return JSONResponse(
  26.         status_code=500,
  27.         content={"message": "Internal server error"},
  28.     )
复制代码

11.3 配置管理
  2. # app/config.py
  3. from pydantic import BaseSettings, AnyHttpUrl, EmailStr, validator
  4. from typing import List, Optional
  6. class Settings(BaseSettings):
  7.     API_V1_STR: str = "/api/v1"
  8.     PROJECT_NAME: str = "Blog API"
  9.    
  10.     # CORS
  11.     BACKEND_CORS_ORIGINS: List[AnyHttpUrl] = [
  12.         "http://localhost:8000",
  13.         "http://localhost:3000",
  14.     ]
  16.     @validator("BACKEND_CORS_ORIGINS", pre=True)
  17.     def assemble_cors_origins(cls, v):
  18.         if isinstance(v, str) and not v.startswith("["):
  19.             return [i.strip() for i in v.split(",")]
  20.         elif isinstance(v, (list, str)):
  21.             return v
  22.         raise ValueError(v)
  24.     # JWT
  25.     SECRET_KEY: str = "your-secret-key-here"
  26.     ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 8  # 8 days
  27.     ALGORITHM: str = "HS256"
  28.    
  29.     # Database
  30.     DATABASE_URL: str = "sqlite:///./blog.db"
  31.    
  32.     # Email
  33.     SMTP_TLS: bool = True
  34.     SMTP_PORT: Optional[int] = None
  35.     SMTP_HOST: Optional[str] = None
  36.     SMTP_USER: Optional[str] = None
  37.     SMTP_PASSWORD: Optional[str] = None
  38.     EMAILS_FROM_EMAIL: Optional[EmailStr] = None
  39.     EMAILS_FROM_NAME: Optional[str] = None
  40.    
  41.     @validator("EMAILS_FROM_NAME")
  42.     def get_project_name(cls, v):
  43.         if not v:
  44.             return settings.PROJECT_NAME
  45.         return v
  47.     EMAIL_RESET_TOKEN_EXPIRE_HOURS: int = 48
  48.     EMAIL_TEMPLATES_DIR: str = "/app/app/email-templates/build"
  49.     EMAILS_ENABLED: bool = False
  51.     @validator("EMAILS_ENABLED")
  52.     def get_emails_enabled(cls, v, values):
  53.         return bool(
  54.             values.get("SMTP_HOST")
  55.             and values.get("SMTP_PORT")
  56.             and values.get("EMAILS_FROM_EMAIL")
  57.         )
  59.     # Test user
  60.     FIRST_SUPERUSER: EmailStr = "admin@example.com"
  61.     FIRST_SUPERUSER_PASSWORD: str = "changethis"
  63.     class Config:
  64.         case_sensitive = True
  66. settings = Settings()
复制代码

11.4 日志记录
  2. import logging
  3. from fastapi import FastAPI
  4. from fastapi.logger import logger
  6. app = FastAPI()
  8. # Configure logging
  9. gunicorn_logger = logging.getLogger('gunicorn.error')
  10. logger.handlers = gunicorn_logger.handlers
  11. if __name__ != "main__":
  12.     logger.setLevel(gunicorn_logger.level)
  13. else:
  14.     logger.setLevel(logging.DEBUG)
  16. @app.get("/")
  17. async def root():
  18.     logger.info("Processing request to root endpoint")
  19.     return {"message": "Hello World"}
复制代码

11.5 性能优化

• 使用异步数据库驱动（如asyncpg、aiomysql）
• 使用缓存（如Redis）
• 使用CDN加速静态资源
• 使用连接池管理数据库连接
• 使用异步任务队列（如Celery）处理耗时操作

12. 部署FastAPI应用

12.1 使用Docker部署
  2. # Dockerfile
  3. FROM python:3.9
  5. WORKDIR /app
  7. COPY requirements.txt .
  8. RUN pip install --no-cache-dir -r requirements.txt
  10. COPY . .
  12. CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8000"]
复制代码
  2. # docker-compose.yml
  3. version: '3.8'
  5. services:
  6.   web:
  7.     build: .
  8.     ports:
  9.       - "8000:8000"
  10.     depends_on:
  11.       - db
  12.     environment:
  13.       - DATABASE_URL=postgresql://fastapi:fastapi@db:5432/blog_db
  15.   db:
  16.     image: postgres:13
  17.     environment:
  18.       - POSTGRES_USER=fastapi
  19.       - POSTGRES_PASSWORD=fastapi
  20.       - POSTGRES_DB=blog_db
  21.     volumes:
  22.       - postgres_data:/var/lib/postgresql/data/
  24. volumes:
  25.   postgres_data:
复制代码

12.2 使用Gunicorn部署
  2. pip install gunicorn uvicorn
  3. gunicorn app.main:app -w 4 -k uvicorn.workers.UvicornWorker
复制代码

12.3 使用Nginx作为反向代理
  2. # nginx.conf
  3. server {
  4.     listen 80;
  5.     server_name your_domain.com;
  7.     location / {
  8.         proxy_pass http://127.0.0.1:8000;
  9.         proxy_set_header Host $host;
  10.         proxy_set_header X-Real-IP $remote_addr;
  11.         proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
  12.     }
  13. }
复制代码

13. 提升开发技能和就业竞争力

13.1 深入学习FastAPI

• 阅读FastAPI官方文档
• 参与FastAPI开源项目
• 关注FastAPI的更新和新特性
• 尝试实现FastAPI的扩展和插件

13.2 构建项目组合

• 使用FastAPI构建不同类型的项目（博客API、电商API、社交网络API等）
• 将项目部署到云平台（如AWS、Google Cloud、Azure）
• 为项目编写完整的文档和测试
• 将项目开源并分享到GitHub

13.3 学习相关技术

• 深入学习Python异步编程
• 学习数据库设计和优化
• 学习容器化技术（Docker、Kubernetes）
• 学习CI/CD流程和工具
• 学习云原生应用开发

13.4 参与社区和交流

• 加入FastAPI社区（Discord、Reddit、Stack Overflow）
• 参加技术会议和meetup
• 写博客分享你的学习经验
• 在GitHub上贡献代码

结论

FastAPI是一个强大、现代且高性能的Web框架，特别适合构建API。通过本教程，你学习了FastAPI的核心概念、特性和最佳实践，并通过一个完整的博客API项目案例，了解了如何使用FastAPI构建实际应用。

FastAPI的优秀性能、自动文档生成、类型提示和依赖注入系统等特性，使其成为Python开发者的理想选择。通过深入学习和实践FastAPI，你将能够构建高效、可维护的Web应用，并提升你的开发技能和就业竞争力。

继续探索FastAPI的更多可能性，构建出色的应用，并在社区中分享你的经验。祝你在FastAPI的学习之路上取得成功！
高性能, 竞争力, 编辑器
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则

关闭

站长推荐上一条 /1 下一条

友情链接

keba
磕巴白菜
别管 别听 就是玩
二次元论坛
二次元论坛
按下F逃离世界！
友链交换
友链交换
友链为随机排序，不代表本论坛观点
Telegram

Telegram

Discord

Discord

Tencent QQ

Tencent QQ

手机版|联系我们|小黑屋|TG频道|RSS |网站地图

Powered by Pixtech

© 2025-2026 Pixtech Team.

>