👌 好的，阿杰。我来为你写一份 《Python API 接口实战指南：从入门到精通》，包含基础概念、实战步骤、完整示例与进阶技巧，循序渐进，既适合入门，也能帮你进阶实战。

Python API 接口实战指南：从入门到精通

一、什么是 API？

  • API（Application Programming Interface）：应用程序接口，让不同系统之间可以进行通信。
  • 在 Web 开发中，API 通常指 Web API，基于 HTTP 协议 提供数据或服务。
  • Python 开发中，常用 API 的形式是 RESTful API。

👉 举例：

  • 微信支付接口
  • 天气预报接口（比如调用天气 API 获取实时天气数据）
  • 自己写的接口，供前端或移动端调用

二、常见 API 接口类型

  1. REST API
    • 基于 HTTP 协议
    • 常用方法：GET（查）、POST（增）、PUT（改）、DELETE（删）
  2. GraphQL API
    • 由 Facebook 提出，可以按需获取数据
    • 一次请求就能返回复杂数据结构
  3. gRPC API
    • 基于 HTTP/2，高性能、跨语言
    • 常用于微服务

👉 在入门阶段，我们主要学习 REST API。

三、Python 调用 API：入门

1. 使用 requests 库

import requests

url = "https://api.github.com/repos/psf/requests"
response = requests.get(url)

if response.status_code == 200:
    data = response.json()
    print("项目名称：", data["name"])
    print("Star 数：", data["stargazers_count"])

2. 常见用法

  • GET 请求（查询数据）
requests.get("https://api.example.com/users", params={"page": 1})
  • POST 请求（提交数据）
requests.post("https://api.example.com/login", json={"username": "admin", "password": "123456"})
  • 携带请求头
headers = {"Authorization": "Bearer your_token"}
requests.get("https://api.example.com/me", headers=headers)

四、Python 开发 API：入门

常见的 Python API 框架有：

  • Flask（轻量级）
  • FastAPI（高性能，推荐）
  • Django REST Framework（功能最全，适合大项目）

这里以 FastAPI 为例：

from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

# 定义数据模型
class User(BaseModel):
    name: str
    age: int

# GET 请求
@app.get("/hello")
def hello():
    return {"msg": "Hello, API"}

# POST 请求
@app.post("/user")
def create_user(user: User):
    return {"name": user.name, "age": user.age}

运行：

uvicorn main:app --reload

👉 打开浏览器访问 http://127.0.0.1:8000/docs，自动生成 API 文档！

五、API 实战案例：天气查询接口

1. 调用第三方 API（示例）

import requests

api_key = "your_api_key"
city = "Beijing"
url = f"http://api.weatherapi.com/v1/current.json?key={api_key}&q={city}"

response = requests.get(url)
data = response.json()

print("城市：", data["location"]["name"])
print("温度：", data["current"]["temp_c"], "°C")

2. 自己封装一个天气 API（FastAPI）

from fastapi import FastAPI

app = FastAPI()

weather_data = {
    "Beijing": {"temp": 25, "condition": "Sunny"},
    "Shanghai": {"temp": 28, "condition": "Cloudy"}
}

@app.get("/weather/{city}")
def get_weather(city: str):
    return weather_data.get(city, {"msg": "城市未收录"})

调用：

GET http://127.0.0.1:8000/weather/Beijing

返回：

{"temp": 25, "condition": "Sunny"}

六、进阶技巧

  1. API 鉴权
    • Token 认证（JWT）
    • OAuth2（第三方登录）
  2. 错误处理
from fastapi import HTTPException

@app.get("/user/{user_id}")
def get_user(user_id: int):
    if user_id != 1:
        raise HTTPException(status_code=404, detail="用户不存在")
    return {"id": 1, "name": "Alice"}
  1. 限流与缓存
    • 限流：防止接口被刷爆
    • 缓存：减少数据库压力（Redis 常用）
  2. 测试 API
    • pytest + requests
    • Postman、Apifox

七、API 项目实战架构

  • 接口层：FastAPI / Flask
  • 业务逻辑层：服务函数（service）
  • 数据层：数据库（MySQL、MongoDB）
  • 缓存层：Redis
  • 鉴权层：JWT / OAuth2

八、学习路线

  1. 学会用 requests 调用 API
  2. 掌握 FastAPI/Flask 编写 API
  3. 学习数据库、缓存（MySQL + Redis）
  4. 掌握 API 鉴权、限流、日志
  5. 进阶：微服务架构、gRPC、API 网关

✅ 一句话总结：
学会了 API，就能用 Python 调用世界上的数据，也能把自己的服务 分享给全世界。

好，阿杰 👍
那我就给你整理一个完整的 Python API 项目实战模板，采用 FastAPI + MySQL + Redis + JWT 鉴权，你可以直接用来做真实项目。

Python API 项目实战模板

一、项目架构

api_project/
│── main.py          # 项目入口
│── config.py        # 配置文件
│── database.py      # 数据库连接
│── models.py        # 数据表模型
│── schemas.py       # 数据验证模型
│── crud.py          # 数据库操作
│── auth.py          # JWT 鉴权
│── cache.py         # Redis 缓存
│── routers/         # API 路由模块
│    ├── user.py     # 用户相关接口
│    └── item.py     # 业务相关接口

二、依赖安装

pip install fastapi uvicorn sqlalchemy pymysql pydantic[dotenv] python-jose[cryptography] passlib[bcrypt] redis

三、配置文件（config.py）

from pydantic import BaseSettings

class Settings(BaseSettings):
    DB_URL: str = "mysql+pymysql://root:123456@localhost:3306/mydb"
    REDIS_URL: str = "redis://localhost:6379/0"
    SECRET_KEY: str = "supersecretkey"
    ALGORITHM: str = "HS256"
    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30

settings = Settings()

四、数据库（database.py & models.py）

1. database.py

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker, declarative_base
from config import settings

engine = create_engine(settings.DB_URL, echo=True, future=True)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
Base = declarative_base()

2. models.py

from sqlalchemy import Column, Integer, String
from database import Base

class User(Base):
    __tablename__ = "users"

    id = Column(Integer, primary_key=True, index=True)
    username = Column(String(50), unique=True, index=True)
    hashed_password = Column(String(255))

五、数据验证模型（schemas.py）

from pydantic import BaseModel

class UserCreate(BaseModel):
    username: str
    password: str

class UserOut(BaseModel):
    id: int
    username: str

    class Config:
        orm_mode = True

六、鉴权（auth.py）

from datetime import datetime, timedelta
from jose import jwt
from passlib.context import CryptContext
from config import settings

pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")

def hash_password(password: str):
    return pwd_context.hash(password)

def verify_password(plain_password, hashed_password):
    return pwd_context.verify(plain_password, hashed_password)

def create_access_token(data: dict):
    expire = datetime.utcnow() + timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
    data.update({"exp": expire})
    return jwt.encode(data, settings.SECRET_KEY, algorithm=settings.ALGORITHM)

七、Redis 缓存（cache.py）

import redis
from config import settings

r = redis.Redis.from_url(settings.REDIS_URL)

def cache_set(key, value, expire=60):
    r.set(key, value, ex=expire)

def cache_get(key):
    return r.get(key)

八、数据库操作（crud.py）

from sqlalchemy.orm import Session
from models import User
from auth import hash_password

def create_user(db: Session, username: str, password: str):
    user = User(username=username, hashed_password=hash_password(password))
    db.add(user)
    db.commit()
    db.refresh(user)
    return user

def get_user_by_username(db: Session, username: str):
    return db.query(User).filter(User.username == username).first()

九、用户接口（routers/user.py）

from fastapi import APIRouter, Depends, HTTPException
from sqlalchemy.orm import Session
from database import SessionLocal
from schemas import UserCreate, UserOut
from crud import create_user, get_user_by_username
from auth import verify_password, create_access_token

router = APIRouter(prefix="/user", tags=["User"])

def get_db():
    db = SessionLocal()
    try:
        yield db
    finally:
        db.close()

@router.post("/register", response_model=UserOut)
def register(user: UserCreate, db: Session = Depends(get_db)):
    db_user = get_user_by_username(db, user.username)
    if db_user:
        raise HTTPException(status_code=400, detail="用户名已存在")
    return create_user(db, user.username, user.password)

@router.post("/login")
def login(user: UserCreate, db: Session = Depends(get_db)):
    db_user = get_user_by_username(db, user.username)
    if not db_user or not verify_password(user.password, db_user.hashed_password):
        raise HTTPException(status_code=400, detail="用户名或密码错误")
    token = create_access_token({"sub": db_user.username})
    return {"access_token": token, "token_type": "bearer"}

十、项目入口（main.py）

from fastapi import FastAPI
from routers import user

app = FastAPI(title="Python API 实战项目")

app.include_router(user.router)

@app.get("/")
def root():
    return {"msg": "Hello, API Project"}

运行项目：

uvicorn main:app --reload

访问接口文档：
👉 http://127.0.0.1:8000/docs

功能一览

✅ 用户注册 & 登录
✅ 密码加密（bcrypt）
✅ JWT 鉴权
✅ MySQL 存储用户
✅ Redis 缓存
✅ 自动生成 Swagger API 文档