可能会有问题，欢迎评论区留言

目录

1. SQLAlchemy 精通教程

   之前写了一个sqlalchemy的简单实践，这次从入门到精通，自我总结，可能有缺，持续更新。。。

   ---

   目录

   1. SQLAlchemy 简介
   2. 核心概念一图流
   3. 快速开始
   4. 声明式模型
   5. 核心概念详解
   6. CRUD 操作
   7. 关系映射
   8. 查询高级用法
   9. 会话管理
   10. 事务与锁
   11. 异步支持 (2.0+)
   12. 性能优化
   13. 迁移管理 (Alembic)
   14. 最佳实践

   ---

   1. SQLAlchemy 简介

   什么是 SQLAlchemy？

   SQLAlchemy 是 Python 中最著名的 SQL 工具包和 ORM（对象关系映射）框架。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   ┌─────────────────────────────────────────────────────────┐ │ SQLAlchemy 架构 │ ├─────────────────────────────────────────────────────────┤ │ │ │ 应用层：你的 Python 代码 │ │ ↓ │ │ ORM 层：将 Python 类映射到数据库表 │ │ ↓ │ │ Core 层：SQL 表达式语言 │ │ ↓ │ │ 方言层：适配不同数据库 (MySQL, PostgreSQL, SQLite...) │ │ ↓ │ │ DBAPI：数据库驱动 (pymysql, psycopg2, aiomysql...) │ │ │ └─────────────────────────────────────────────────────────┘

   SQLAlchemy 1.x vs 2.0

   特性	1.x	2.0
   异步支持	实验性	完整支持
   类型提示	有限	完整支持
   API 风格	混合	更清晰分离
   推荐用法	session.query()	select()

   安装

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   # 基础安装 pip install sqlalchemy # MySQL 支持 pip install pymysql pip install sqlalchemy[mysql] # PostgreSQL 支持 pip install psycopg2-binary pip install sqlalchemy[postgresql] # 异步支持 pip install aiomysql # MySQL 异步 pip install asyncpg # PostgreSQL 异步

   ---

   2. 核心概念一图流

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

   ┌────────────────────────────────────────────────────────────────┐ │ SQLAlchemy 核心概念 │ ├────────────────────────────────────────────────────────────────┤ │ │ │ Engine（引擎） │ │ └── 数据库连接的工厂，管理连接池 │ │ └── URL: "dialect+driver://user:pass@host/db" │ │ │ │ Metadata（元数据） │ │ └── 存储表结构信息，用于创建/删除表 │ │ │ │ Table（表） - Core 层 │ │ └── 定义数据库表结构（列、约束等） │ │ │ │ Model（模型） - ORM 层 │ │ └── Python 类，映射到数据库表 │ │ └── 属性 → 列，实例 → 行 │ │ │ │ Session（会话） │ │ └── 与数据库的"对话"，负责 CRUD 操作 │ │ └── 类似"暂存区"，commit 后才写入数据库 │ │ │ │ Query / select() │ │ └── 构建 SQL 查询 │ │ │ └────────────────────────────────────────────────────────────────┘

   典型工作流程

   1 2 3

   1. 创建 Engine → 2. 创建 Session → 3. 定义模型 ↓ 4. 使用 Session 执行查询/操作 → 5. 提交事务 → 6. 关闭 Session

   ---

   3. 快速开始

   最小可运行示例

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

   from sqlalchemy import create_engine, Column, Integer, String from sqlalchemy.orm import declarative_base, sessionmaker # 1. 创建引擎（数据库连接） engine = create_engine("sqlite:///example.db", echo=True) # 2. 创建基类 Base = declarative_base() # 3. 定义模型 class User(Base): __tablename__ = "users" id = Column(Integer, primary_key=True) name = Column(String(50)) email = Column(String(100)) # 4. 创建表 Base.metadata.create_all(engine) # 5. 创建会话 Session = sessionmaker(bind=engine) session = Session() # 6. 添加数据 user = User(name="张三", email="zhangsan@example.com") session.add(user) session.commit() # 7. 查询数据 users = session.query(User).all() for u in users: print(f"{u.id}: {u.name} - {u.email}") # 8. 关闭会话 session.close()

   连接字符串详解

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

   from sqlalchemy import create_engine # SQLite（文件） engine = create_engine("sqlite:///example.db") # SQLite（内存） engine = create_engine("sqlite:///:memory:") # MySQL engine = create_engine( "mysql+pymysql://user:password@localhost:3306/dbname?charset=utf8mb4" ) # PostgreSQL engine = create_engine( "postgresql+psycopg2://user:password@localhost:5432/dbname" ) # PostgreSQL（异步） engine = create_async_engine( "postgresql+asyncpg://user:password@localhost:5432/dbname" ) # 带连接池配置 engine = create_engine( "sqlite:///example.db", pool_size=10, # 连接池大小 max_overflow=20, # 超出 pool_size 后允许的最大连接数 pool_pre_ping=True, # 使用前检查连接是否有效 pool_recycle=3600, # 连接回收时间（秒） )

   ---

   4. 声明式模型

   基础模型定义

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

   from sqlalchemy import Column, Integer, String, Float, DateTime, Boolean, Text from sqlalchemy.orm import declarative_base from datetime import datetime Base = declarative_base() class User(Base): __tablename__ = "users" # 表名 # 主键 id = Column(Integer, primary_key=True, autoincrement=True) # 普通字段 username = Column(String(50), nullable=False, unique=True) email = Column(String(100), nullable=False) password_hash = Column(String(255), nullable=False) # 带默认值 is_active = Column(Boolean, default=True) created_at = Column(DateTime, default=datetime.utcnow) # 大文本 bio = Column(Text) # 数值类型 age = Column(Integer) balance = Column(Float, default=0.0) def __repr__(self): return f"<User(id={self.id}, username={self.username})>"

   常用字段类型

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60

   from sqlalchemy import ( # 字符串类型 String, Text, Unicode, # 整数类型 Integer, SmallInteger, BigInteger, # 浮点类型 Float, Numeric, Decimal, # 日期时间 Date, Time, DateTime, # 布尔 Boolean, # 二进制 LargeBinary, PickleType, # JSON (PostgreSQL/MySQL 5.7+) JSON, # UUID UUID, # 其他 Enum, Interval, ) class AllTypes(Base): __tablename__ = "all_types" id = Column(Integer, primary_key=True) # 字符串 short_text = Column(String(50)) # VARCHAR(50) long_text = Column(Text) # TEXT # 整数 small_num = Column(SmallInteger) # SMALLINT normal_num = Column(Integer) # INTEGER big_num = Column(BigInteger) # BIGINT # 浮点 float_num = Column(Float) # FLOAT precise_num = Column(Numeric(10, 2)) # DECIMAL(10, 2) # 日期时间 date_only = Column(Date) # DATE time_only = Column(Time) # TIME datetime_full = Column(DateTime) # DATETIME # 布尔 is_true = Column(Boolean) # BOOLEAN # JSON data = Column(JSON) # JSON # 带枚举 status = Column(Enum("active", "inactive", "banned"))

   字段选项详解

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

   from sqlalchemy import Column, Integer, String, ForeignKey, Index, UniqueConstraint class DetailedModel(Base): __tablename__ = "detailed" id = Column( Integer, primary_key=True, # 主键 autoincrement=True, # 自增 nullable=False, # 不允许 NULL index=True, # 创建索引 unique=True, # 唯一约束 ) name = Column( String(50), nullable=False, # 不允许 NULL default="Unnamed", # 默认值（Python 层） server_default="Unnamed", # 默认值（数据库层） ) email = Column( String(100), unique=True, # 唯一约束 index=True, # 索引 ) category_id = Column( Integer, ForeignKey("categories.id", ondelete="CASCADE"), # 外键 + 级联删除 nullable=True, ) # 复合唯一约束 __table_args__ = ( UniqueConstraint("name", "category_id", name="uq_name_category"), Index("ix_email_status", "email", "status"), # 复合索引 {"mysql_engine": "InnoDB", "mysql_charset": "utf8mb4"}, # MySQL 特定选项 )

   ---

   5. 核心概念详解

   Engine（引擎）

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

   from sqlalchemy import create_engine, text # 创建引擎 engine = create_engine( "sqlite:///example.db", echo=True, # 打印 SQL 语句（调试用） pool_pre_ping=True, # 自动重连 ) # 直接执行原生 SQL with engine.connect() as conn: result = conn.execute(text("SELECT version()")) print(result.fetchone()) # 事务执行 with engine.begin() as conn: conn.execute(text("INSERT INTO users (name) VALUES ('test')")) # 自动 commit，如果异常则 rollback

   Metadata（元数据）

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

   from sqlalchemy import MetaData, Table, create_engine engine = create_engine("sqlite:///example.db") metadata = MetaData() # 从现有数据库反射表结构 users_table = Table("users", metadata, autoload_with=engine) # 查看所有表 print(metadata.tables.keys()) # 创建所有表 metadata.create_all(engine) # 删除所有表 metadata.drop_all(engine) # 反射整个数据库 metadata.reflect(engine)

   核心层 Table（不使用 ORM）

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

   from sqlalchemy import Table, Column, Integer, String, MetaData, insert, select metadata = MetaData() # 定义表（Core 方式） users = Table( "users", metadata, Column("id", Integer, primary_key=True), Column("name", String(50)), Column("email", String(100)), ) # 插入数据 stmt = insert(users).values(name="张三", email="zhang@example.com") with engine.begin() as conn: result = conn.execute(stmt) print(f"插入的 ID: {result.inserted_primary_key[0]}") # 查询 stmt = select(users).where(users.c.name == "张三") with engine.connect() as conn: result = conn.execute(stmt) for row in result: print(row.id, row.name, row.email)

   ---

   6. CRUD 操作

   创建 (Create)

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

   from sqlalchemy.orm import Session # 创建单个对象 user = User(name="李四", email="lisi@example.com") session.add(user) session.commit() session.refresh(user) # 刷新获取自增 ID print(f"ID: {user.id}") # 批量添加 users = [ User(name="用户 1", email="u1@example.com"), User(name="用户 2", email="u2@example.com"), User(name="用户 3", email="u3@example.com"), ] session.add_all(users) session.commit() # 使用字典批量创建 data = [ {"name": "张三", "email": "zhang@example.com"}, {"name": "李四", "email": "li@example.com"}, ] session.bulk_insert_mappings(User, data) session.commit()

   查询 (Read)

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64

   from sqlalchemy import select # 方法 1：传统 query API（1.x 风格，但仍可用） user = session.query(User).first() # 第一条 user = session.query(User).get(1) # 按 ID 获取 users = session.query(User).all() # 全部 users = session.query(User).limit(10).all() # 限制 10 条 users = session.query(User).offset(10).all() # 跳过 10 条 # 方法 2：2.0 推荐 select() API stmt = select(User) user = session.execute(stmt).first() stmt = select(User).limit(10) users = session.execute(stmt).scalars().all() # 条件查询 user = session.query(User).filter(User.id == 1).first() users = session.query(User).filter(User.name == "张三").all() # 多个条件 users = session.query(User).filter( User.is_active == True, User.age >= 18 ).all() # OR 条件 from sqlalchemy import or_ users = session.query(User).filter( or_(User.name == "张三", User.name == "李四") ).all() # LIKE 查询 users = session.query(User).filter( User.email.like("%@gmail.com") ).all() # IN 查询 users = session.query(User).filter( User.id.in_([1, 2, 3]) ).all() # 排序 users = session.query(User).order_by(User.created_at.desc()).all() users = session.query(User).order_by(User.name.asc(), User.id.desc()).all() # 只查询特定字段 results = session.query(User.id, User.name).all() for id, name in results: print(id, name) # 计数 count = session.query(User).count() # 聚合 from sqlalchemy import func max_id = session.query(func.max(User.id)).scalar() avg_age = session.query(func.avg(User.age)).scalar() # 分组 results = session.query( User.status, func.count(User.id) ).group_by(User.status).all()

   更新 (Update)

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

   # 方法 1：获取对象后修改 user = session.query(User).get(1) if user: user.name = "新名字" user.email = "new@example.com" session.commit() # 方法 2：bulk_update（批量更新） session.bulk_update_mappings( User, [{"id": 1, "name": "更新 1"}, {"id": 2, "name": "更新 2"}] ) session.commit() # 方法 3：SQL 更新（高效，不加载对象） from sqlalchemy import update stmt = update(User).where(User.id == 1).values(name="新名字") session.execute(stmt) session.commit() # 批量条件更新 stmt = update(User).where(User.is_active == False).values(is_active=True) session.execute(stmt) session.commit()

   删除 (Delete)

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

   # 方法 1：获取对象后删除 user = session.query(User).get(1) if user: session.delete(user) session.commit() # 方法 2：SQL 删除 from sqlalchemy import delete stmt = delete(User).where(User.id == 1) session.execute(stmt) session.commit() # 批量删除 stmt = delete(User).where(User.is_active == False) result = session.execute(stmt) print(f"删除了 {result.rowcount} 条记录") session.commit()

   ---

   7. 关系映射

   一对一关系

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

   from sqlalchemy import ForeignKey from sqlalchemy.orm import relationship class User(Base): __tablename__ = "users" id = Column(Integer, primary_key=True) name = Column(String(50)) # 关系定义 profile = relationship("Profile", back_populates="user", uselist=False) class Profile(Base): __tablename__ = "profiles" id = Column(Integer, primary_key=True) bio = Column(Text) user_id = Column(Integer, ForeignKey("users.id"), unique=True) # 反向关系 user = relationship("User", back_populates="profile") # 使用示例 user = User(name="张三") user.profile = Profile(bio="这是我的简介") session.add(user) session.commit() # 访问关联对象 print(user.profile.bio) print(user.profile.user.name) # 反向访问

   一对多关系

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36

   class Parent(Base): __tablename__ = "parents" id = Column(Integer, primary_key=True) name = Column(String(50)) # 一方：可以有多个孩子 children = relationship("Child", back_populates="parent") class Child(Base): __tablename__ = "children" id = Column(Integer, primary_key=True) name = Column(String(50)) parent_id = Column(Integer, ForeignKey("parents.id")) # 多方：每个孩子有一个父亲 parent = relationship("Parent", back_populates="children") # 使用示例 parent = Parent(name="父亲") parent.children = [ Child(name="孩子 1"), Child(name="孩子 2"), Child(name="孩子 3"), ] session.add(parent) session.commit() # 访问 for child in parent.children: print(f"{child.name} 的父亲是 {child.parent.name}") # 查询某个父亲的所有孩子 children = session.query(Child).filter(Child.parent_id == 1).all()

   多对多关系

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51

   from sqlalchemy import Table # 关联表 user_roles = Table( "user_roles", Base.metadata, Column("user_id", Integer, ForeignKey("users.id")), Column("role_id", Integer, ForeignKey("roles.id")), PrimaryKeyConstraint("user_id", "role_id"), # 复合主键 ) class User(Base): __tablename__ = "users" id = Column(Integer, primary_key=True) name = Column(String(50)) # 多对多关系 roles = relationship( "Role", secondary=user_roles, back_populates="users" ) class Role(Base): __tablename__ = "roles" id = Column(Integer, primary_key=True) name = Column(String(50)) users = relationship("User", secondary=user_roles, back_populates="roles") # 使用示例 admin_role = Role(name="管理员") editor_role = Role(name="编辑") user = User(name="张三") user.roles = [admin_role, editor_role] session.add_all([user, admin_role, editor_role]) session.commit() # 查询用户的所有角色 user = session.query(User).filter(User.name == "张三").first() for role in user.roles: print(f"角色：{role.name}") # 查询有管理员角色的所有用户 admins = session.query(User).filter( User.roles.any(Role.name == "管理员") ).all()

   级联操作

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

   class Parent(Base): __tablename__ = "parents" id = Column(Integer, primary_key=True) name = Column(String(50)) # 级联配置 children = relationship( "Child", back_populates="parent", cascade="all, delete-orphan", # 删除父亲时删除所有孩子 ) class Child(Base): __tablename__ = "children" id = Column(Integer, primary_key=True) name = Column(String(50)) parent_id = Column(Integer, ForeignKey("parents.id")) parent = relationship("Parent", back_populates="children") # cascade 选项说明： # "save-update" - 保存/更新时级联 # "merge" - merge 操作时级联 # "refresh-expire" - refresh/expire 时级联 # "expunge" - expunge 时级联 # "delete" - 删除时级联 # "delete-orphan" - 删除孤儿记录 # "all" - 以上所有 # "all, delete-orphan" - 常用组合

   自引用关系

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

   class Employee(Base): __tablename__ = "employees" id = Column(Integer, primary_key=True) name = Column(String(50)) # 外键指向自己 manager_id = Column(Integer, ForeignKey("employees.id")) # 下属（一对多） subordinates = relationship( "Employee", back_populates="manager", foreign_keys=[manager_id] ) # 上级（多对一） manager = relationship( "Employee", back_populates="subordinates", remote_side=[id] ) # 使用示例 ceo = Employee(name="CEO") manager = Employee(name="经理", manager=ceo) employee = Employee(name="员工", manager=manager) session.add_all([ceo, manager, employee]) session.commit() # 访问 print(ceo.subordinates[0].name) # 经理 print(employee.manager.name) # 经理 print(employee.manager.manager.name) # CEO

   ---

   8. 查询高级用法

   Join 查询

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

   from sqlalchemy.orm import joinedload, selectinload # 内连接 results = session.query(User, Profile).join(Profile).all() # 左外连接 results = session.query(User).outerjoin(Profile).all() # 多个 join results = session.query(User).join(Profile).join(Post).all() # 使用关系自动推断连接条件 users_with_posts = session.query(User).join(User.posts).all() # 明确指定连接条件 results = session.query(User).join( Profile, User.id == Profile.user_id ).all()

   预加载（解决 N+1 问题）

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

   # 问题：N+1 查询 # 执行 1 次查询获取用户，然后每个用户执行 1 次查询获取帖子 users = session.query(User).all() for user in users: print(user.posts) # 每次都触发新查询！ # 解决 1：joinedload（适合一对一、一对少） users = session.query(User).options( joinedload(User.profile) ).all() # 解决 2：selectinload（适合一对多） users = session.query(User).options( selectinload(User.posts) ).all() # 解决 3：selectinload_all（多层嵌套） users = session.query(User).options( selectinload_all(User.posts, User.profile) ).all() # 多层预加载 users = session.query(User).options( joinedload(User.posts).joinedload(Post.comments) ).all()

   子查询

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   from sqlalchemy import func # 标量子查询 subquery = session.query(func.count(Post.id)).filter( Post.user_id == User.id ).correlate(User).as_scalar() users = session.query(User, subquery.label("post_count")).all() # IN 子查询 active_user_ids = session.query(User.id).filter(User.is_active == True) posts = session.query(Post).filter( Post.user_id.in_(active_user_ids) ).all() # EXISTS 子查询 from sqlalchemy import exists exists_query = exists().where(Post.user_id == User.id) users_with_posts = session.query(User).filter(exists_query).all()

   窗口函数

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   from sqlalchemy import func, over # ROW_NUMBER query = session.query( User.name, User.salary, func.row_number().over( partition_by=User.department, order_by=User.salary.desc() ).label("rank") ) # 聚合窗口函数 query = session.query( User.name, User.salary, func.avg(User.salary).over( partition_by=User.department ).label("dept_avg") )

   原生 SQL 查询

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

   from sqlalchemy import text # 参数化查询（防止 SQL 注入） stmt = text("SELECT * FROM users WHERE id = :id") result = session.execute(stmt, {"id": 1}) # 返回 ORM 对象 stmt = text("SELECT * FROM users WHERE id = :id") result = session.execute(stmt, {"id": 1}) user = result.scalars().first() # 混合使用 ORM 和原生 SQL from sqlalchemy.orm import Session with Session(engine) as session: # 原生 SQL session.execute(text("UPDATE users SET active = 1 WHERE id = :id"), {"id": 1}) session.commit()

   ---

   9. 会话管理

   Session 生命周期

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

   from sqlalchemy.orm import sessionmaker, Session, scoped_session # 创建 Session 工厂 SessionLocal = sessionmaker(bind=engine, autocommit=False, autoflush=False) # 方法 1：手动管理 session = SessionLocal() try: # 操作... session.commit() except: session.rollback() raise finally: session.close() # 方法 2：上下文管理器（推荐） with SessionLocal() as session: try: # 操作... session.commit() except: session.rollback() raise # 方法 3：scoped_session（线程安全，适合 Web 应用） db_session = scoped_session(SessionLocal) # 在请求结束时清理 @app.teardown_appcontext def shutdown_session(exception=None): db_session.remove()

   会话状态详解

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

   # 对象状态转换： # # transient → [add()] → pending → [commit()] → persistent # ↓ # [rollback()] # ↓ # detached ← [close()/expire()] from sqlalchemy.orm import Session session = Session() user = User(name="test") print(session.contains(user)) # False - transient（瞬态） session.add(user) print(session.contains(user)) # True - pending（待处理） session.commit() print(session.contains(user)) # True - persistent（持久化） session.close() print(session.contains(user)) # False - detached（游离） # 重新附加 session.add(user) # 或 session.merge(user)

   会话技巧

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   # 批量保存（每 N 条提交一次） def batch_insert(session, items, batch_size=1000): for i, item in enumerate(items): session.add(item) if (i + 1) % batch_size == 0: session.commit() session.expunge_all() # 清空会话，释放内存 session.commit() # 刷新特定对象 session.refresh(user) # 从数据库重新加载数据 # 使对象过期（下次访问时重新加载） session.expire(user) # 清空整个会话 session.expunge_all() # 部分刷新（只刷新特定属性） session.refresh(user, attribute_names=["name", "email"])

   ---

   10. 事务与锁

   事务管理

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

   from sqlalchemy import create_engine engine = create_engine("sqlite:///example.db") # 方法 1：自动事务（推荐） with engine.begin() as conn: conn.execute(text("INSERT INTO users (name) VALUES ('Alice')")) conn.execute(text("INSERT INTO users (name) VALUES ('Bob')")) # 如果都成功则 commit，否则自动 rollback # 方法 2：显式事务 with engine.connect() as conn: trans = conn.begin() try: conn.execute(text("INSERT INTO users VALUES (1, 'Alice')")) conn.execute(text("INSERT INTO users VALUES (2, 'Bob')")) trans.commit() except: trans.rollback() raise # 方法 3：嵌套事务（保存点） with engine.begin() as conn: conn.execute(text("INSERT INTO users VALUES (1, 'Alice')")) with conn.begin_nested(): # 保存点 conn.execute(text("INSERT INTO users VALUES (2, 'Bob')")) # 如果这里失败，只回滚到这个保存点 # Alice 的插入仍然有效

   锁机制

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

   from sqlalchemy import select from sqlalchemy.orm import Session session = Session() # 行级锁 - for_update（排他锁） user = session.query(User).with_for_update().filter(User.id == 1).first() # 其他事务无法修改或锁定此行 # for_update 的参数 user = session.query(User).with_for_update( nowait=True, # 无法获取锁时立即抛出异常 skip_locked=True, # 跳过已锁定的行 read=False, # False=排他锁，True=共享锁 ).filter(User.id == 1).first() # 共享锁（允许其他事务读，但不允许写） user = session.query(User).with_for_update(read=True).filter(User.id == 1).first() # 表级锁（MySQL 示例） session.execute(text("LOCK TABLES users WRITE")) try: # 操作... pass finally: session.execute(text("UNLOCK TABLES"))

   乐观锁

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30

   from sqlalchemy import Column, Integer from sqlalchemy.orm import relationship, Session class Product(Base): __tablename__ = "products" id = Column(Integer, primary_key=True) name = Column(String(50)) stock = Column(Integer) version = Column(Integer, default=0, nullable=False) # 版本号 def update_stock_optimistic(session, product_id, new_stock): product = session.query(Product).filter(Product.id == product_id).first() if not product: return False # 检查版本号是否变化 current_version = product.version # 更新 product.stock = new_stock product.version = current_version + 1 try: session.commit() return True except: session.rollback() return False # 版本号冲突，更新失败

   ---

   11. 异步支持 (2.0+)

   异步基础

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

   from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession from sqlalchemy.orm import sessionmaker, declarative_base from sqlalchemy import select # 异步引擎 engine = create_async_engine( "sqlite+aiosqlite:///example.db", echo=True ) # 异步 Session AsyncSessionLocal = sessionmaker( bind=engine, class_=AsyncSession, expire_on_commit=False ) Base = declarative_base() # 异步 CRUD async def main(): async with AsyncSessionLocal() as session: # 创建表 async with engine.begin() as conn: await conn.run_sync(Base.metadata.create_all) # 添加数据 user = User(name="异步用户", email="async@example.com") session.add(user) await session.commit() # 查询 result = await session.execute(select(User)) users = result.scalars().all() # 获取单个 result = await session.execute(select(User).where(User.id == 1)) user = result.scalars().first()

   异步关系预加载

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

   from sqlalchemy.ext.asyncio import AsyncSession from sqlalchemy import select from sqlalchemy.orm import selectinload async def get_user_with_posts(session: AsyncSession, user_id: int): result = await session.execute( select(User) .options(selectinload(User.posts)) .where(User.id == user_id) ) return result.scalars().first() async def get_all_users_with_data(session: AsyncSession): result = await session.execute( select(User) .options( selectinload(User.profile), selectinload(User.posts).selectinload(Post.comments) ) ) return result.scalars().all()

   FastAPI + 异步 SQLAlchemy

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

   from fastapi import FastAPI, Depends from sqlalchemy.ext.asyncio import AsyncSession, create_async_engine from sqlalchemy.orm import sessionmaker, declarative_base app = FastAPI() engine = create_async_engine("sqlite+aiosqlite:///example.db") AsyncSessionLocal = sessionmaker(engine, class_=AsyncSession) Base = declarative_base() async def get_db(): async with AsyncSessionLocal() as session: yield session @app.get("/users") async def get_users(db: AsyncSession = Depends(get_db)): result = await db.execute(select(User)) users = result.scalars().all() return [{"id": u.id, "name": u.name} for u in users]

   ---

   12. 性能优化

   批量操作

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

   # 批量插入（高效） def bulk_insert_users(users_data): # users_data = [{"name": ..., "email": ...}, ...] session.bulk_insert_mappings(User, users_data) session.commit() # 批量更新 def bulk_update_users(updates): # updates = [{"id": 1, "name": "新名字"}, ...] session.bulk_update_mappings(User, updates) session.commit() # 批量插入（使用 execute_values - PostgreSQL） from sqlalchemy.dialects.postgresql import insert stmt = insert(User).values(users_data) session.execute(stmt) session.commit()

   查询优化

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

   # 1. 只查询需要的字段 results = session.query(User.id, User.name).all() # 2. 使用 EXISTS 代替 IN（大数据集） from sqlalchemy import exists users_with_posts = session.query(User).filter( exists().where(Post.user_id == User.id) ).all() # 3. 使用延迟加载（适合大对象） class Article(Base): content = Column(Text, lazy="dynamic") # 访问时才查询 # 4. 禁用自动刷新 session = Session() session.autoflush = False # 5. 使用 yield_per 分批处理大数据集 query = session.query(User).yield_per(100) for user in query: process(user) # 每次只加载 100 条到内存

   连接池优化

   1 2 3 4 5 6 7 8 9 10 11 12 13

   engine = create_engine( "mysql+pymysql://user:pass@localhost/db", # 连接池配置 pool_size=20, # 正常连接数 max_overflow=40, # 超出后可创建的最大连接 pool_timeout=30, # 等待连接的超时时间 pool_recycle=1800, # 连接回收时间（秒） pool_pre_ping=True, # 使用前检查连接 # 其他优化 echo=False, # 生产环境关闭 SQL 日志 )

   ---

   13. 迁移管理 (Alembic)

   Alembic 基础

   1 2 3 4 5 6 7 8

   # 安装 pip install alembic # 初始化 alembic init alembic # 配置 alembic.ini # sqlalchemy.url = mysql+pymysql://user:pass@localhost/db

   目录结构

   1 2 3 4 5 6

   alembic/ ├── versions/ # 迁移脚本 │ ├── 001_initial.py │ └── 002_add_user_table.py ├── env.py # 环境配置 └── script.py.mako # 模板

   常用命令

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

   # 生成新迁移 alembic revision --autogenerate -m "创建用户表" # 应用迁移 alembic upgrade head # 回退一个版本 alembic downgrade -1 # 查看当前版本 alembic current # 查看历史 alembic history # 生成空迁移（手动写 SQL） alembic revision -m "添加索引"

   迁移脚本示例

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

   """创建用户表 Revision ID: abc123 Revises: Create Date: 2024-01-01 """ from alembic import op import sqlalchemy as sa revision = "abc123" down_revision = None def upgrade(): op.create_table( "users", sa.Column("id", sa.Integer(), nullable=False), sa.Column("username", sa.String(length=50), nullable=False), sa.Column("email", sa.String(length=100), nullable=False), sa.Column("created_at", sa.DateTime(), nullable=True), sa.PrimaryKeyConstraint("id"), sa.UniqueConstraint("email"), sa.UniqueConstraint("username"), ) op.create_index("ix_users_email", "users", ["email"], unique=False) def downgrade(): op.drop_index("ix_users_email", table_name="users") op.drop_table("users")

   ---

   14. 最佳实践

   项目结构

   1 2 3 4 5 6 7 8 9 10 11 12 13

   project/ ├── app/ │ ├── __init__.py │ ├── database.py # 引擎、Session 配置 │ ├── models/ # 模型 │ │ ├── __init__.py │ │ ├── user.py │ │ └── post.py │ └── schemas/ # Pydantic 模型 │ └── user.py ├── alembic/ # 迁移 ├── tests/ └── requirements.txt

   database.py 示例

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

   from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import sessionmaker SQLALCHEMY_DATABASE_URL = "sqlite:///./app.db" engine = create_engine( SQLALCHEMY_DATABASE_URL, pool_pre_ping=True, echo=False ) SessionLocal = sessionmaker( autocommit=False, autoflush=False, bind=engine ) Base = declarative_base() # 依赖注入用的函数 def get_db(): db = SessionLocal() try: yield db finally: db.close()

   模型定义最佳实践

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

   from sqlalchemy import Column, Integer, String, DateTime, func from sqlalchemy.orm import declarative_base, Mapped, mapped_column from datetime import datetime from typing import Optional Base = declarative_base() class User(Base): __tablename__ = "users" # SQLAlchemy 2.0 风格 id: Mapped[int] = mapped_column(primary_key=True) username: Mapped[str] = mapped_column(String(50), unique=True, nullable=False) email: Mapped[str] = mapped_column(String(100), unique=True, nullable=False) created_at: Mapped[datetime] = mapped_column( DateTime, default=datetime.utcnow, server_default=func.now() ) def to_dict(self) -> dict: return { "id": self.id, "username": self.username, "email": self.email, } def __repr__(self) -> str: return f"<User(id={self.id}, username={self.username})>"

   常见陷阱与避免

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

   # ❌ 错误：忘记 commit session.add(user) # 应该：session.commit() # ❌ 错误：在循环中查询 for user_id in user_ids: user = session.query(User).get(user_id) # N+1 问题 # ✅ 正确：使用 IN users = session.query(User).filter(User.id.in_(user_ids)).all() # ❌ 错误：会话泄漏 def get_user(user_id): session = SessionLocal() return session.query(User).get(user_id) # 应该：用上下文管理器 # ✅ 正确： def get_user(user_id): with SessionLocal() as session: return session.query(User).get(user_id) # ❌ 错误：在事务中进行耗时操作 with session.begin(): user = session.query(User).get(1) send_email(user.email) # 耗时的邮件发送 # 事务一直保持打开 # ✅ 正确：先提交，再发送 with session.begin(): user = session.query(User).get(1) send_email(user.email)

   ---

   附录：快速参考

   常用类型速查

   1 2 3 4 5 6 7 8 9 10 11 12

   String(n) - VARCHAR(n) Text - TEXT Integer - INTEGER Float - FLOAT Numeric(p, s) - DECIMAL(p, s) Boolean - BOOLEAN Date - DATE DateTime - DATETIME Time - TIME JSON - JSON LargeBinary - BLOB Enum(...) - ENUM

   约束速查

   1 2 3 4 5 6 7

   primary_key=True # 主键 nullable=False # NOT NULL unique=True # UNIQUE index=True # INDEX default=value # Python 默认值 server_default=text # SQL 默认值 ForeignKey("table.col") # 外键

   关系速查

   1 2 3 4 5 6 7 8 9 10 11 12

   # 一对一 child = relationship("Child", uselist=False) # 一对多 children = relationship("Child") # 多对多 roles = relationship("Role", secondary=association_table) # 预加载 joinedload(Model.relation) # JOIN selectinload(Model.relation) # IN 查询

   ---

   学习资源

   • 官方文档：https://docs.sqlalchemy.org/
   • ORM 教程：https://docs.sqlalchemy.org/en/20/orm/quickstart.html
   • Alembic 文档：https://alembic.sqlalchemy.org/
   • SQLAlchemy 2.0 迁移指南：https://docs.sqlalchemy.org/en/20/changelog/migration_20.html

   ---

   ]]> https://www.furinaluna.top/posts/40cc3c1.html 2026-04-04T15:27:39.000Z
   SQLAlchemy 精通教程

   之前写了一个sqlalchemy的简单实践，这次从入门到精通，自我总结，可能有缺，持续更新。。。

   ---

   FastAPI 精通教程

   从入门到精通，自我总结，可能有缺，持续更新。。。

   ---

   目录

   1. FastAPI 简介
   2. 快速开始
   3. 路径参数
   4. 查询参数
   5. 请求体与 Pydantic
   6. 响应模型
   7. 错误处理
   8. 依赖注入系统
   9. 中间件
   10. WebSocket 支持
   11. 后台任务
   12. 数据库集成
   13. 认证与授权
   14. 测试
   15. 项目结构最佳实践
   16. 性能优化

   ---

   1. FastAPI 简介

   什么是 FastAPI？

   FastAPI 是一个现代、高性能的 Python Web 框架，用于构建 API。它的核心特点：

   特性	说明
   🚀 高性能	基于 Starlette 和 Pydantic，性能接近 Node.js 和 Go
   📝 自动文档	自动生成 OpenAPI 和 ReDoc 文档
   ✅ 数据验证	基于 Python 类型提示的自动验证
   🎯 开发速度快	代码量减少约 40%，bug 减少
   🔧 生产就绪	支持异步、WebSocket、GraphQL 等

   为什么选择 FastAPI？

   1 2 3 4 5

   传统框架 (Flask/Django) FastAPI ├── 手动验证输入 ├── 自动类型验证 ├── 手动写 API 文档 ├── 自动生成文档 ├── 同步处理为主 ├── 原生异步支持 └── 返回值无类型检查 └── 响应模型验证

   核心概念一图流

   1 2 3 4

   请求 → 路由 (Router) → 依赖注入 → 端点函数 → 响应模型 → JSON ↓ ↓ ↓ 路径参数 数据库连接 数据验证 查询参数 认证检查 序列化

   ---

   2. 快速开始

   安装

   1	pip install fastapi uvicorn[standard]

   Hello World

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

   from fastapi import FastAPI app = FastAPI( title="我的 API", description="这是一个示例 API", version="1.0.0" ) @app.get("/") async def root(): """ 根路径端点 这是你的第一个 FastAPI 端点！ async def 表示这是一个异步函数 """ return {"message": "Hello World"} @app.get("/items/{item_id}") async def read_item(item_id: int): """ 带路径参数的端点 item_id: 会自动转换为整数，如果传入了非整数会返回验证错误 """ return {"item_id": item_id}

   运行服务器

   1 2 3 4 5 6 7 8

   # 开发模式（自动重载） uvicorn main:app --reload # 生产模式 uvicorn main:app --host 0.0.0.0 --port 8000 --workers 4 # 指定端口 uvicorn main:app --port 8080

   访问自动文档

   • Swagger UI: http://localhost:8000/docs
   • ReDoc: http://localhost:8000/redoc
   • OpenAPI JSON: http://localhost:8000/openapi.json

   ---

   3. 路径参数

   路径参数是 URL 路径的一部分，用于标识特定资源。

   基础用法

   1 2 3 4 5 6 7 8 9 10 11 12 13

   from fastapi import FastAPI app = FastAPI() @app.get("/users/{user_id}") async def get_user(user_id: int): """ 获取用户信息 user_id 会从 URL 中提取并验证为整数 例如：/users/123 → user_id = 123 """ return {"user_id": user_id}

   类型转换详解

   FastAPI 会自动将路径参数转换为指定的类型：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

   from datetime import datetime from uuid import UUID @app.get("/items/{item_id}") async def read_item(item_id: int): # item_id 被转换为 int # /items/42 ✓ → {"item_id": 42} # /items/abc ✗ → 422 验证错误 return {"item_id": item_id} @app.get("/users/{user_id}") async def read_user(user_id: UUID): # UUID 类型验证 # /users/123e4567-e89b-12d3-a456-426614174000 ✓ return {"user_id": user_id} @app.get("/logs/{date}") async def read_logs(date: datetime): # 日期时间验证 # /logs/2024-01-15T10:30:00 ✓ return {"date": date}

   预定义值（Enum）

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   from enum import Enum from fastapi import FastAPI app = FastAPI() class ModelName(str, Enum): """定义允许的值""" alexnet = "alexnet" resnet = "resnet" squeezenet = "squeezenet" @app.get("/models/{model_name}") async def get_model(model_name: ModelName): """ model_name 只能是 ModelName 中定义的值 /models/alexnet ✓ /models/vgg ✗ → 422 错误 """ return {"model_name": model_name, "message": f"Using {model_name.value}"}

   文件路径参数

   1 2 3 4 5 6 7 8 9 10 11 12 13

   from fastapi import FastAPI app = FastAPI() # 捕获剩余路径 @app.get("/files/{file_path:path}") async def read_file(file_path: str): """ file_path:path 会捕获剩余的所有路径 /files/users/john/doc.txt → file_path = "users/john/doc.txt" """ return {"file_path": file_path}

   ---

   4. 查询参数

   查询参数是 URL ? 后面的键值对。

   基础用法

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

   from fastapi import FastAPI from typing import Optional app = FastAPI() @app.get("/items") async def read_items( skip: int = 0, # 默认值为 0 limit: int = 10, # 默认值为 10 q: Optional[str] = None # 可选参数 ): """ 查询参数示例 /items?skip=0&limit=10&q=search /items → skip=0, limit=10, q=None """ return {"skip": skip, "limit": limit, "q": q}

   必需参数 vs 可选参数

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

   from fastapi import FastAPI app = FastAPI() # 必需参数（没有默认值） @app.get("/users") async def get_users(region: str): """ /users?region=beijing ✓ /users ✗ → 缺少必需参数 """ return {"region": region} # 可选参数（有默认值） @app.get("/products") async def get_products( category: str = "all", # 有默认值=可选 page: int = 1, sort: str = "default" ): """ /products ✓ → category="all", page=1, sort="default" /products?category=electronics&page=2 ✓ """ return {"category": category, "page": page, "sort": sort}

   类型验证和约束

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29

   from fastapi import FastAPI, Query from typing import Optional, List app = FastAPI() @app.get("/items") async def read_items( # 使用 Query 添加验证规则 q: Optional[str] = Query( None, min_length=1, # 最小长度 max_length=50, # 最大长度 pattern=r"^[a-z]+$" # 正则表达式 ), # 数值范围 price_min: float = Query(0, ge=0), # ge: greater or equal price_max: float = Query(1000, le=10000), # le: less or equal # 列表参数 tags: List[str] = Query(default=[]), # /items?tags=tag1&tags=tag2 # 描述（显示在文档中） sort_by: str = Query("created_at", description="排序字段") ): """带验证的查询参数""" return { "q": q, "price_range": [price_min, price_max], "tags": tags, "sort_by": sort_by }

   别名和废弃参数

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

   from fastapi import FastAPI, Query app = FastAPI() @app.get("/items") async def read_items( # 使用别名（URL 中用 page-num，函数中用 page_num） page_num: int = Query(1, alias="page-num"), # 标记为废弃 old_param: str = Query( None, deprecated=True, description="此参数已废弃，请使用 new_param" ), new_param: str = Query(None) ): return {"page": page_num, "old": old_param, "new": new_param}

   ---

   5. 请求体与 Pydantic

   请求体用于发送复杂数据（通常是 JSON）。

   Pydantic 模型基础

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

   from fastapi import FastAPI from pydantic import BaseModel, Field, EmailStr from typing import Optional from datetime import datetime app = FastAPI() # 定义数据模型 class Item(BaseModel): """ Pydantic 模型 = 数据验证 + 序列化 作用： 1. 验证传入的数据类型 2. 自动转换为正确的类型 3. 生成 OpenAPI 文档 """ name: str = Field(..., min_length=1, max_length=50) price: float = Field(..., gt=0, description="价格必须大于 0") description: Optional[str] = None quantity: int = Field(1, ge=1) # 默认值 1，必须 >= 1 tags: list[str] = [] @app.post("/items") async def create_item(item: Item): """ FastAPI 会： 1. 读取 JSON 请求体 2. 验证数据类型 3. 转换为 Item 对象 4. 验证失败时返回 422 """ # item 已经是验证过的 Item 对象 return { "name": item.name, "price": item.price, "total": item.price * item.quantity }

   嵌套模型

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

   from pydantic import BaseModel from typing import Optional class Address(BaseModel): street: str city: str country: str zipcode: str class User(BaseModel): name: str email: str age: int address: Optional[Address] = None # 嵌套模型 @app.post("/users") async def create_user(user: User): """ 发送 JSON: { "name": "John", "email": "john@example.com", "age": 30, "address": { "street": "123 Main St", "city": "NYC", "country": "USA", "zipcode": "10001" } } """ return user

   验证器（Validators）

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34

   from pydantic import BaseModel, field_validator, model_validator from datetime import datetime class Product(BaseModel): name: str price: float discount: float = 0 final_price: float = None # 字段验证器 @field_validator('name') @classmethod def name_must_not_be_empty(cls, v): if not v.strip(): raise ValueError('name 不能为空') return v.strip() @field_validator('price') @classmethod def price_must_be_positive(cls, v): if v <= 0: raise ValueError('价格必须大于 0') return v # 模型验证器（跨字段验证） @model_validator(mode='after') def calculate_final_price(self): if self.final_price is None: self.final_price = self.price * (1 - self.discount / 100) return self @app.post("/products") async def create_product(product: Product): return product

   请求体 + 路径 + 查询参数

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

   from fastapi import FastAPI, Path, Query from pydantic import BaseModel app = FastAPI() class ItemUpdate(BaseModel): name: str | None = None price: float | None = None @app.put("/items/{item_id}") async def update_item( item_id: int = Path(..., description="要更新的物品 ID"), q: str | None = Query(None, description="查询参数"), item: ItemUpdate = None # 请求体 ): """ PUT /items/123?q=test Body: {"name": "新名字", "price": 99.9} 参数顺序：Path → Query → Body """ return {"item_id": item_id, "q": q, "update": item}

   ---

   6. 响应模型

   响应模型用于控制返回给客户端的数据。

   基础响应模型

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

   from fastapi import FastAPI from pydantic import BaseModel, EmailStr from typing import Optional app = FastAPI() class UserIn(BaseModel): """输入模型""" username: str password: str email: EmailStr class UserOut(BaseModel): """输出模型 - 不包含密码""" username: str email: EmailStr class Config: from_attributes = True # 允许从 ORM 对象读取 @app.post("/users", response_model=UserOut) async def create_user(user: UserIn): """ 即使返回完整的 user 对象 响应模型会过滤掉 password 字段 """ return user # 实际返回只有 username 和 email # 或者使用装饰器方式 @app.post("/users2") async def create_user2(user: UserIn): return UserOut(**user.model_dump())

   响应模型参数详解

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

   from fastapi import FastAPI from pydantic import BaseModel, SecretStr from typing import Optional, List app = FastAPI() class Item(BaseModel): name: str description: Optional[str] = None price: float tax: float = 10.0 tags: List[str] = [] # exclude: 排除特定字段 # exclude_none: 排除值为 None 的字段 # exclude_unset: 只返回设置的字段 @app.post("/items", response_model=Item, response_model_exclude_none=True) async def create_item(item: Item): """排除 None 值的字段""" return item @app.get("/items/{item_id}", response_model=Item, response_model_exclude={"tax"}) async def get_item(item_id: int): """排除 tax 字段""" return Item(name=f"Item {item_id}", price=10.0)

   返回状态码和自定义响应

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

   from fastapi import FastAPI, status, HTTPException app = FastAPI() @app.post("/items", status_code=status.HTTP_201_CREATED) async def create_item(name: str): """返回 201 Created 状态码""" return {"name": name} @app.delete("/items/{item_id}", status_code=204) async def delete_item(item_id: int): """返回 204 No Content""" return None @app.post("/login") async def login(username: str, password: str): if username != "admin" or password != "secret": raise HTTPException( status_code=401, detail="用户名或密码错误", headers={"WWW-Authenticate": "Bearer"} ) return {"token": "fake-token"}

   ---

   7. 错误处理

   HTTPException

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   from fastapi import FastAPI, HTTPException, status app = FastAPI() items = {"foo": "Item Foo", "bar": "Item Bar"} @app.get("/items/{item_id}") async def read_item(item_id: str): if item_id not in items: raise HTTPException( status_code=status.HTTP_404_NOT_FOUND, detail=f"Item {item_id} not found", headers={"X-Error": "NotFound"} # 自定义头 ) return {"item": items[item_id]}

   自定义异常处理器

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

   from fastapi import FastAPI, Request, status from fastapi.responses import JSONResponse from fastapi.exceptions import RequestValidationError app = FastAPI() class CustomException(Exception): def __init__(self, message: str, code: str): self.message = message self.code = code # 注册异常处理器 @app.exception_handler(CustomException) async def custom_exception_handler(request: Request, exc: CustomException): return JSONResponse( status_code=400, content={ "error": "custom_error", "message": exc.message, "code": exc.code } ) # 重写默认验证错误处理 @app.exception_handler(RequestValidationError) async def validation_exception_handler(request: Request, exc: RequestValidationError): return JSONResponse( status_code=status.HTTP_422_UNPROCESSABLE_ENTITY, content={ "error": "validation_error", "details": exc.errors() } ) @app.get("/trigger-error") async def trigger_error(): raise CustomException("这是一个自定义错误", "CUSTOM_001")

   业务异常封装

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

   from fastapi import FastAPI, HTTPException, status from typing import Generic, TypeVar, Optional from pydantic import BaseModel app = FastAPI() T = TypeVar('T') # 统一响应格式 class APIResponse(BaseModel, Generic[T]): success: bool data: Optional[T] = None error: Optional[str] = None message: str = "操作成功" class BusinessException(HTTPException): """业务异常基类""" def __init__(self, message: str, status_code: int = 400, code: str = "BIZ_ERROR"): super().__init__( status_code=status_code, detail={"message": message, "code": code} ) class NotFoundError(BusinessException): def __init__(self, resource: str): super().__init__( message=f"{resource} 未找到", status_code=404, code="NOT_FOUND" ) class ValidationError(BusinessException): def __init__(self, field: str, message: str): super().__init__( message=f"{field}: {message}", status_code=422, code="VALIDATION_ERROR" ) @app.get("/users/{user_id}") async def get_user(user_id: int): if user_id <= 0: raise ValidationError("user_id", "必须是正整数") # 模拟数据库查询 if user_id == 999: raise NotFoundError("用户") return {"user_id": user_id}

   ---

   8. 依赖注入系统

   依赖注入是 FastAPI 最强大的特性之一。

   基础依赖

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

   from fastapi import FastAPI, Depends, HTTPException from typing import Optional app = FastAPI() # 可重用的依赖 async def common_parameters(q: Optional[str] = None, skip: int = 0, limit: int = 100): """返回通用参数""" return {"q": q, "skip": skip, "limit": limit} @app.get("/items") async def read_items(commons: dict = Depends(common_parameters)): """使用依赖注入""" return commons @app.get("/users") async def read_users(commons: dict = Depends(common_parameters)): """相同的依赖可以重复使用""" return {**commons, "type": "users"}

   类依赖

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

   from fastapi import FastAPI, Depends app = FastAPI() class Pagination: """分页依赖""" def __init__(self, page: int = 1, page_size: int = 10): self.page = page self.page_size = page_size @property def offset(self) -> int: return (self.page - 1) * self.page_size class Sorting: """排序依赖""" def __init__(self, sort_by: str = "created_at", order: str = "desc"): self.sort_by = sort_by self.order = order @app.get("/items") async def read_items( pagination: Pagination = Depends(), sorting: Sorting = Depends() ): """使用类依赖""" return { "page": pagination.page, "page_size": pagination.page_size, "offset": pagination.offset, "sort_by": sorting.sort_by, "order": sorting.order }

   数据库会话依赖

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

   from fastapi import FastAPI, Depends from typing import Generator app = FastAPI() # 模拟数据库连接 class DatabaseSession: def __init__(self, url: str = "sqlite:///:memory:"): self.url = url self.connected = False def connect(self): self.connected = True print(f"连接到数据库：{self.url}") def close(self): self.connected = False print("关闭数据库连接") def get_db() -> Generator[DatabaseSession, None, None]: """ 依赖生成器 - 管理数据库会话生命周期 yield 之前的代码：请求前执行（连接数据库） yield: 提供会话对象给端点使用 yield 之后的代码：请求后执行（关闭连接） """ db = DatabaseSession() try: db.connect() yield db finally: db.close() @app.get("/users") async def read_users(db: DatabaseSession = Depends(get_db)): """自动获取和清理数据库连接""" assert db.connected, "数据库应该已连接" return {"users": [], "db_connected": db.connected}

   依赖嵌套和覆盖

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

   from fastapi import FastAPI, Depends, HTTPException, status app = FastAPI() # 用户认证依赖 async def get_current_user(token: str = None): if token is None: raise HTTPException(status_code=401, detail="缺少 Token") if token != "valid-token": raise HTTPException(status_code=401, detail="无效 Token") return {"username": "testuser", "role": "user"} # 依赖上面的依赖 async def get_current_active_user( current_user: dict = Depends(get_current_user) ): if current_user.get("disabled"): raise HTTPException(status_code=400, detail="用户已禁用") return current_user # 进一步依赖 async def get_current_admin_user( current_user: dict = Depends(get_current_active_user) ): if current_user.get("role") != "admin": raise HTTPException(status_code=403, detail="需要管理员权限") return current_user @app.get("/me") async def read_me(current_user: dict = Depends(get_current_active_user)): """需要活跃用户""" return current_user @app.get("/admin/dashboard") async def admin_dashboard(current_user: dict = Depends(get_current_admin_user)): """需要管理员""" return {"message": f"欢迎管理员 {current_user['username']}"}

   依赖覆盖（测试用）

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

   from fastapi import FastAPI, Depends app = FastAPI() def get_dependency(): return "production_value" @app.get("/") async def read_root(value: str = Depends(get_dependency)): return {"value": value} # 测试时覆盖依赖 # from .main import app, get_dependency # async def override_dependency(): # return "test_value" # app.dependency_overrides[get_dependency] = override_dependency

   ---

   9. 中间件

   中间件在每个请求到达端点之前和响应返回之后执行。

   基础中间件

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

   from fastapi import FastAPI, Request from starlette.middleware.base import BaseHTTPMiddleware import time app = FastAPI() # 添加内置中间件 app.add_middleware( CORSMiddleware, # 跨域支持 allow_origins=["*"], # 允许的来源 allow_credentials=True, # 允许 cookies allow_methods=["*"], # 允许的方法 allow_headers=["*"], # 允许的头 ) # 自定义中间件 @app.middleware("http") async def log_requests(request: Request, call_next): """记录请求日志的中间件""" start_time = time.time() # 请求前处理 print(f"收到请求：{request.method} {request.url.path}") # 处理请求 response = await call_next(request) # 响应后处理 process_time = time.time() - start_time print(f"处理时间：{process_time:.3f}s") # 添加自定义响应头 response.headers["X-Process-Time"] = str(process_time) return response

   认证中间件

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43

   from fastapi import FastAPI, Request, HTTPException from starlette.middleware.base import BaseHTTPMiddleware from starlette.responses import JSONResponse class AuthenticationMiddleware(BaseHTTPMiddleware): """JWT 认证中间件""" async def dispatch(self, request: Request, call_next): # 跳过不需要认证的路径 if request.url.path in ["/docs", "/openapi.json", "/login"]: return await call_next(request) # 检查 Authorization 头 auth_header = request.headers.get("Authorization") if not auth_header or not auth_header.startswith("Bearer "): return JSONResponse( status_code=401, content={"detail": "缺少认证令牌"} ) token = auth_header.split(" ")[1] # 验证 token（这里简化处理） if not self.verify_token(token): return JSONResponse( status_code=401, content={"detail": "无效的认证令牌"} ) # 将用户信息添加到请求 request.state.user = self.decode_token(token) return await call_next(request) def verify_token(self, token: str) -> bool: # 实际的 token 验证逻辑 return token == "valid-token" def decode_token(self, token: str) -> dict: # 实际的 token 解码逻辑 return {"sub": "user123", "exp": 9999999999} app.add_middleware(AuthenticationMiddleware)

   速率限制中间件

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

   from fastapi import FastAPI, Request from starlette.middleware.base import BaseHTTPMiddleware from starlette.responses import JSONResponse from collections import defaultdict import time class RateLimitMiddleware(BaseHTTPMiddleware): """简单的速率限制""" def __init__(self, app, requests_per_minute: int = 60): super().__init__(app) self.requests_per_minute = requests_per_minute self.request_counts = defaultdict(list) async def dispatch(self, request: Request, call_next): client_ip = request.client.host current_time = time.time() window_start = current_time - 60 # 清理旧请求 self.request_counts[client_ip] = [ t for t in self.request_counts[client_ip] if t > window_start ] # 检查是否超出限制 if len(self.request_counts[client_ip]) >= self.requests_per_minute: return JSONResponse( status_code=429, content={"detail": "请求过于频繁，请稍后再试"} ) # 记录请求 self.request_counts[client_ip].append(current_time) return await call_next(request) app.add_middleware(RateLimitMiddleware, requests_per_minute=100)

   ---

   10. WebSocket 支持

   基础 WebSocket

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

   from fastapi import FastAPI, WebSocket from fastapi.responses import HTMLResponse app = FastAPI() @app.websocket("/ws") async def websocket_endpoint(websocket: WebSocket): """WebSocket 端点""" await websocket.accept() while True: # 接收消息 data = await websocket.receive_text() # 处理并返回 response = f"收到：{data}" await websocket.send_text(response)

   WebSocket + 依赖注入

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

   from fastapi import FastAPI, WebSocket, Depends, HTTPException from typing import Optional app = FastAPI() async def get_token(websocket: WebSocket) -> str: """从 WebSocket 连接中获取 token""" token = websocket.query_params.get("token") if not token or token != "secret-token": await websocket.close(code=4001) raise HTTPException(status_code=400, detail="无效的 Token") return token @app.websocket("/ws/auth") async def authenticated_websocket( websocket: WebSocket, token: str = Depends(get_token) ): """需要认证的 WebSocket""" await websocket.accept() await websocket.send_text(f"欢迎！Token: {token}") while True: data = await websocket.receive_text() await websocket.send_text(f"Echo: {data}")

   WebSocket 聊天室示例

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

   from fastapi import FastAPI, WebSocket, WebSocketDisconnect from typing import List import json app = FastAPI() class ConnectionManager: """管理 WebSocket 连接""" def __init__(self): self.active_connections: List[WebSocket] = [] async def connect(self, websocket: WebSocket): await websocket.accept() self.active_connections.append(websocket) def disconnect(self, websocket: WebSocket): self.active_connections.remove(websocket) async def broadcast(self, message: str): """广播消息给所有连接""" for connection in self.active_connections: await connection.send_text(message) async def send_personal(self, message: str, websocket: WebSocket): """发送个人消息""" await websocket.send_text(message) manager = ConnectionManager() @app.websocket("/ws/chat") async def chat_websocket(websocket: WebSocket): await manager.connect(websocket) try: await manager.broadcast(f"新用户加入聊天室") while True: data = await websocket.receive_text() message = json.loads(data) await manager.broadcast( json.dumps({ "user": message.get("user", "匿名"), "message": message.get("text", "") }) ) except WebSocketDisconnect: manager.disconnect(websocket) await manager.broadcast("用户离开了聊天室")

   ---

   11. 后台任务

   基础后台任务

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

   from fastapi import FastAPI, BackgroundTasks import time app = FastAPI() def send_email(email: str, message: str): """模拟发送邮件""" print(f"发送邮件到 {email}: {message}") time.sleep(2) # 模拟耗时操作 print("邮件发送完成") @app.post("/send-email") async def send_email_endpoint( email: str, background_tasks: BackgroundTasks ): """ 后台任务会在响应返回后异步执行 用户会立即收到响应，而不用等待邮件发送完成 """ background_tasks.add_task(send_email, email, "欢迎注册！") return {"message": "邮件正在发送中", "email": email} @app.post("/multiple-tasks") async def multiple_background_tasks( background_tasks: BackgroundTasks ): """添加多个后台任务""" background_tasks.add_task(send_email, "user1@example.com", "通知 1") background_tasks.add_task(send_email, "user2@example.com", "通知 2") background_tasks.add_task(send_email, "user3@example.com", "通知 3") return {"message": "3 个邮件正在发送"}

   使用 Celery 处理重型任务

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39

   # 重型任务建议使用 Celery # pip install celery[redis] from celery import Celery from fastapi import FastAPI, BackgroundTasks app = FastAPI() # Celery 配置 celery_app = Celery( 'tasks', broker='redis://localhost:6379/0', backend='redis://localhost:6379/0' ) @celery_app.task def process_large_file(file_path: str): """处理大文件的 Celery 任务""" # 耗时操作 time.sleep(10) return {"processed": file_path} @app.post("/process-file") async def process_file(file_path: str): """ 返回任务 ID，用户可以稍后查询结果 """ task = process_large_file.delay(file_path) return {"task_id": task.id, "status": "processing"} @app.get("/task-status/{task_id}") async def get_task_status(task_id: str): from celery.result import AsyncResult task_result = AsyncResult(task_id, app=celery_app) return { "task_id": task_id, "status": task_result.status, "result": task_result.result if task_result.ready() else None }

   ---

   12. 数据库集成

   SQLAlchemy 集成

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73

   from fastapi import FastAPI, Depends, HTTPException from sqlalchemy import create_engine, Column, Integer, String from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import sessionmaker, Session from pydantic import BaseModel from typing import Optional, List app = FastAPI() # 数据库配置 DATABASE_URL = "sqlite:///./test.db" engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False}) SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) Base = declarative_base() # 模型定义 class User(Base): __tablename__ = "users" id = Column(Integer, primary_key=True, index=True) username = Column(String, unique=True, index=True) email = Column(String, unique=True, index=True) hashed_password = Column(String) # 创建表 Base.metadata.create_all(bind=engine) # Pydantic 模型 class UserBase(BaseModel): username: str email: str class UserCreate(UserBase): password: str class UserResponse(UserBase): id: int class Config: from_attributes = True # 依赖项 def get_db(): db = SessionLocal() try: yield db finally: db.close() # CRUD 端点 @app.post("/users", response_model=UserResponse) async def create_user(user: UserCreate, db: Session = Depends(get_db)): db_user = User( username=user.username, email=user.email, hashed_password=user.password # 实际应使用 bcrypt 加密 ) db.add(db_user) db.commit() db.refresh(db_user) return db_user @app.get("/users", response_model=List[UserResponse]) async def read_users(skip: int = 0, limit: int = 100, db: Session = Depends(get_db)): users = db.query(User).offset(skip).limit(limit).all() return users @app.get("/users/{user_id}", response_model=UserResponse) async def read_user(user_id: int, db: Session = Depends(get_db)): user = db.query(User).filter(User.id == user_id).first() if not user: raise HTTPException(status_code=404, detail="用户不存在") return user

   Tortoise ORM（异步）

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

   from fastapi import FastAPI from tortoise import fields, models from tortoise.contrib.fastapi import register_tortoise app = FastAPI() class User(models.Model): id = fields.IntField(pk=True) username = fields.CharField(max_length=50, unique=True) email = fields.CharField(max_length=100) created_at = fields.DatetimeField(auto_now_add=True) class Meta: table = "users" @app.get("/users") async def get_users(): users = await User.all() return [{"id": u.id, "username": u.username} for u in users] @app.post("/users") async def create_user(username: str, email: str): user = await User.create(username=username, email=email) return {"id": user.id, "username": user.username} # 注册 Tortoise register_tortoise( app, db_url="sqlite://:memory:", modules={"models": ["__main__"]}, generate_schemas=True, add_exception_handlers=True )

   ---

   13. 认证与授权

   JWT 认证

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78

   from fastapi import FastAPI, Depends, HTTPException, status from fastapi.security import OAuth2PasswordBearer, OAuth2PasswordRequestForm from pydantic import BaseModel from typing import Optional from datetime import datetime, timedelta from jose import JWTError, jwt app = FastAPI() # 配置 SECRET_KEY = "your-secret-key" ALGORITHM = "HS256" ACCESS_TOKEN_EXPIRE_MINUTES = 30 # 模拟用户数据库 fake_users_db = { "admin": { "username": "admin", "password": "secret", # 实际应使用 bcrypt "disabled": False } } # OAuth2 scheme oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token") class Token(BaseModel): access_token: str token_type: str class User(BaseModel): username: str disabled: Optional[bool] = None def create_access_token(data: dict, expires_delta: Optional[timedelta] = None): to_encode = data.copy() expire = datetime.utcnow() + (expires_delta or timedelta(minutes=15)) to_encode.update({"exp": expire}) return jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM) async def get_current_user(token: str = Depends(oauth2_scheme)): credentials_exception = HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="无法验证凭据", 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 except JWTError: raise credentials_exception user = fake_users_db.get(username) if user is None: raise credentials_exception return User(**user) @app.post("/token", response_model=Token) async def login(form_data: OAuth2PasswordRequestForm = Depends()): user = fake_users_db.get(form_data.username) if not user or user["password"] != form_data.password: raise HTTPException( status_code=status.HTTP_401_UNAUTHORIZED, detail="用户名或密码错误", headers={"WWW-Authenticate": "Bearer"}, ) access_token = create_access_token( data={"sub": user["username"]}, expires_delta=timedelta(minutes=ACCESS_TOKEN_EXPIRE_MINUTES) ) return {"access_token": access_token, "token_type": "bearer"} @app.get("/users/me") async def read_users_me(current_user: User = Depends(get_current_user)): return current_user

   权限系统

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

   from fastapi import FastAPI, Depends, HTTPException from fastapi.security import OAuth2PasswordBearer from typing import List app = FastAPI() oauth2_scheme = OAuth2PasswordBearer(tokenUrl="token") class Permissions: ADMIN = "admin" USER_READ = "user:read" USER_WRITE = "user:write" def require_permissions(required_permissions: List[str]): async def permission_checker(current_user: dict = Depends(get_current_user)): user_permissions = current_user.get("permissions", []) # 检查是否有所有必需的权限 for perm in required_permissions: if perm not in user_permissions and Permissions.ADMIN not in user_permissions: raise HTTPException( status_code=403, detail=f"缺少权限：{perm}" ) return current_user return permission_checker @app.get("/admin/users") async def list_all_users( current_user: dict = Depends(require_permissions([Permissions.USER_READ])) ): return {"message": "用户列表", "user": current_user["username"]} @app.post("/admin/users") async def create_user_endpoint( current_user: dict = Depends(require_permissions([Permissions.USER_WRITE])) ): return {"message": "创建用户", "user": current_user["username"]}

   ---

   14. 测试

   使用 TestClient

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31

   from fastapi.testclient import TestClient from fastapi import FastAPI app = FastAPI() @app.get("/") async def root(): return {"message": "Hello World"} @app.post("/items") async def create_item(name: str, price: float): return {"name": name, "price": price} # 测试 client = TestClient(app) def test_root(): response = client.get("/") assert response.status_code == 200 assert response.json() == {"message": "Hello World"} def test_create_item(): response = client.post("/items?name=Apple&price=1.5") assert response.status_code == 200 data = response.json() assert data["name"] == "Apple" assert data["price"] == 1.5 def test_validation_error(): response = client.post("/items?name=Test") assert response.status_code == 422

   测试带依赖的端点

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

   from fastapi import FastAPI, Depends from fastapi.testclient import TestClient from unittest.mock import Mock app = FastAPI() def get_db(): return {"connection": "real_db"} async def get_current_user(token: str): return {"username": "testuser"} @app.get("/protected") async def protected_route(user: dict = Depends(get_current_user)): return {"user": user} # 覆盖依赖进行测试 def test_protected_route(): app.dependency_overrides[get_current_user] = lambda: {"username": "test_user"} client = TestClient(app) response = client.get("/protected") assert response.status_code == 200 assert response.json()["user"]["username"] == "test_user" # 清理覆盖 app.dependency_overrides.clear()

   Pytest 集成

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

   # test_main.py import pytest from fastapi.testclient import TestClient from main import app @pytest.fixture def client(): return TestClient(app) def test_read_main(client): response = client.get("/") assert response.status_code == 200 def test_read_item(client): response = client.get("/items/1") assert response.status_code == 200

   ---

   15. 项目结构最佳实践

   推荐的项目结构

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37

   my_project/ ├── app/ │ ├── __init__.py │ ├── main.py # FastAPI 应用实例 │ ├── config.py # 配置管理 │ ├── dependencies.py # 依赖注入 │ │ │ ├── models/ # 数据库模型 │ │ ├── __init__.py │ │ └── user.py │ │ │ ├── schemas/ # Pydantic 模型 │ │ ├── __init__.py │ │ └── user.py │ │ │ ├── routers/ # 路由模块 │ │ ├── __init__.py │ │ ├── users.py │ │ └── items.py │ │ │ ├── services/ # 业务逻辑 │ │ ├── __init__.py │ │ └── user_service.py │ │ │ ├── middleware/ # 中间件 │ │ └── auth.py │ │ │ └── utils/ # 工具函数 │ └── security.py │ ├── tests/ # 测试 │ ├── __init__.py │ └── test_users.py │ ├── .env # 环境变量 ├── requirements.txt # 依赖 └── pytest.ini # Pytest 配置

   模块化路由

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

   # app/routers/users.py from fastapi import APIRouter, Depends, HTTPException router = APIRouter(prefix="/users", tags=["用户"]) @router.get("/") async def list_users(): return [{"id": 1, "name": "Alice"}] @router.get("/{user_id}") async def get_user(user_id: int): return {"id": user_id, "name": f"User {user_id}"} # app/main.py from fastapi import FastAPI from .routers import users, items app = FastAPI(title="My API") app.include_router(users.router) app.include_router(items.router, prefix="/api/v1")

   ---

   16. 性能优化

   异步优化

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

   from fastapi import FastAPI import asyncio import aiohttp app = FastAPI() # 好的异步实践 @app.get("/fetch-data") async def fetch_data(): async with aiohttp.ClientSession() as session: # 并发请求 urls = [ "https://api.example.com/users", "https://api.example.com/posts", "https://api.example.com/comments" ] tasks = [session.get(url) for url in urls] responses = await asyncio.gather(*tasks) # 并发解析 data = await asyncio.gather(*[r.json() for r in responses]) return { "users": data[0], "posts": data[1], "comments": data[2] }

   缓存策略

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

   from fastapi import FastAPI, Response from functools import lru_cache import hashlib import json app = FastAPI() # 内存缓存 cache = {} @lru_cache(maxsize=128) def compute_expensive(value: str) -> str: """CPU 密集型计算的缓存""" return hashlib.sha256(value.encode()).hexdigest() @app.get("/compute/{value}") async def compute_endpoint(value: str): result = compute_expensive(value) return {"result": result} # HTTP 缓存头 @app.get("/static-data") async def static_data(response: Response): response.headers["Cache-Control"] = "public, max-age=3600" return {"data": "static"}

   响应压缩

   1 2 3 4 5 6 7 8 9

   from fastapi import FastAPI from fastapi.middleware.gzip import GZipMiddleware app = FastAPI() app.add_middleware(GZipMiddleware, minimum_size=1000) @app.get("/large-response") async def large_response(): return {"data": "x" * 10000} # 大于 1KB 会自动压缩

   ---

   附录：常用命令

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

   # 安装 pip install fastapi uvicorn[standard] pip install python-jose[cryptography] # JWT pip install passlib[bcrypt] # 密码加密 pip install sqlalchemy # 数据库 pip install "uvicorn[standard]" # 完整 uvicorn # 运行 uvicorn main:app --reload # 开发 uvicorn main:app --workers 4 # 生产 # 测试 pytest pytest --cov=app # 覆盖率 # 代码检查 mypy app # 类型检查 black app # 格式化 flake8 app # 代码规范

   ---

   学习资源

   • 官方文档：https://fastapi.tiangolo.com/
   • GitHub: https://github.com/tiangolo/fastapi
   • 中文社区：https://fastapi-chinese.netlify.app/

   ---

   ]]> https://www.furinaluna.top/posts/e8eb82c9.html 2026-04-04T15:23:15.000Z

   FastAPI 精通教程

   从入门到精通，自我总结，可能有缺，持续更新。。。

   ---

   目录

   2026-09-11T13:48:57.130Z Furina GEO 优化入门指南

   GEO = Generative Engine Optimization（生成式引擎优化）

   一句话解释

   SEO 是让你的网站出现在 Google 搜索结果里；GEO 是让你的内容被 ChatGPT、Gemini、Perplexity 这些 AI 引用和推荐。

   用户越来越多地直接问 AI 而不是搜索引擎，如果 AI 回答里没提到你，你就丢了客户。

   ---

   核心技巧（6 招）

   1. 结论先行，别废话

   AI 提取内容时偏爱前 100 字就给出答案的文章。

   • 别写"众所周知…随着时代发展…"这种开头
   • 直接说结论，再展开解释
   • 段落不超过 150 字，一段一个观点

   2. 结构化写作

   AI 读内容跟人不一样，它喜欢格式清晰、层级分明的内容。

   推荐格式	举例
   问答（FAQ）	“什么是 GEO？答：……”
   列表/步骤	“第一步…第二步…”
   对比表格	“A vs B 对比”
   带层级的标题	H1 > H2 > H3 有序嵌套

   技术层面：给网页加 Schema 标记（FAQ Schema、HowTo Schema），让 AI 更容易理解你的内容结构。

   3. 让别人提到你

   AI 判断该引用谁，核心看权威性——你被多少可信来源提到过。

   • 去知乎、公众号、行业媒体发优质内容
   • 争取被权威网站引用或客座发文
   • 在 Reddit、YouTube 等平台保持活跃
   • 被第三方权威提及后，AI 引用率可提升 3 倍以上

   4. 多模态内容

   AI 不只看文字，图片、视频、信息图都会被索引。

   • 图片：写好 Alt 描述文字
   • 视频：提供字幕和时间戳章节
   • 信息图：配一份纯文本版本

   5. 保持内容新鲜

   AI 偏爱有明确时间标记的新内容。

   • 标注"更新于 2026 年 X 月"
   • 每季度更新数据和案例
   • 过时内容及时修订或标记

   6. 技术基础别拉胯

   • robots.txt 允许 AI 爬虫访问（GPTBot、Google-Extended 等）
   • 有 SSL 证书（https）
   • 有 XML Sitemap
   • 页面能被正常抓取，别全靠 JS 渲染

   ---

   怎么检验效果？

   不看排名，看AI 有没有引用你：

   1. 拿你的核心业务问题去问 ChatGPT、Gemini、Perplexity
   2. 看回答里有没有提到你的品牌/网站
   3. 定期跟踪，记录变化

   ---

   一张图总结

   1 2	传统 SEO：写内容 → 优化关键词 → 争排名 GEO：写好内容 → 结构化 → 建权威 → 被 AI 引用

   最重要的一句话： 写内容的时候，想象你在给 AI 喂一份它能直接拿来回答用户问题的参考资料。清晰、准确、有结构、有来源——AI 自然会选你。

   ]]> https://www.furinaluna.top/posts/8ea135ce.html 2026-04-04T10:22:14.000Z

   GEO 优化入门指南

   GEO = Generative Engine Optimization（生成式引擎优化）

   一句话解释

   SEO 是让你的网站出]]>

   2026-09-11T13:48:57.147Z Furina SEO（Search Engine Optimization）优化是指通过一系列技术和策略，提高网站在搜索引擎中的排名，从而增加网站的曝光率和访问量。以下是一些常见的SEO优化方法：

   学习一下鱼皮大佬的SEO优化方法：

   请在做任何 SEO 优化工作前，先完整阅读本文的内容！

   一、确定产品的通用默认 TDK

   1.1 标题（Title）规范

   结构模板

   建议采用三段式结构：页面名称 - 产品名称 | 产品核心介绍

   分隔符选择

   经过 SEO 实践验证，推荐使用以下分隔符组合：

   • 短横线（-）：用于连接相关词汇，如页面名称与产品名称之间
   • 竖线（|）：用于分隔不同层级的信息，如产品名称与核心介绍之间
   • 避免使用：下划线（_）、斜杠（/）、逗号（,）等不利于 SEO 的符号

   这种组合方式有助于搜索引擎更好地识别标题的层次结构，提升关键词权重分配的准确性。

   长度控制

   • 最佳长度：50-60 个字符（包括空格）
   • 最大长度：不超过 70 个字符，避免在搜索结果中被截断
   • 百度特殊性：百度会显示约 30 个汉字，建议核心关键词前置

   内容要求

   • 必须包含页面主关键词，建议出现在标题前半部分
   • 每个页面标题必须独一无二，避免重复
   • 语句通顺自然，符合用户搜索习惯
   • 避免关键词堆砌，保持可读性

   1.2 描述（Description）规范

   功能定位

   描述是网页在搜索结果中的"广告文案"，需要在有限字数内吸引用户点击，同时覆盖核心关键词。

   长度控制

   • Google 最佳长度：150-160 个字符（包括空格）
   • 百度最佳长度：约 200 个字符
   • 建议策略：前 150 字符放置最核心信息，后续内容作为补充

   内容要求

   • 自然融入多个核心关键词及相关长尾词
   • 突出产品核心价值和差异化优势
   • 包含行动号召（如"立即使用"、"免费体验"等）
   • 每个页面描述必须独特，不可复制粘贴
   • 语句流畅，避免单纯罗列关键词

   覆盖策略

   应尽可能覆盖以下维度的关键词：

   • 产品核心功能关键词
   • 目标用户群体关键词
   • 使用场景关键词
   • 行业/领域关键词
   • 品牌词和竞品对比词

   1.3 关键词（Keywords）规范

   数量控制

   • 最大数量：不超过 10 个，避免分散权重
   • 优先级排序：按重要性从高到低排列

   长度控制

   • 单个关键词：2-8 个汉字为宜
   • 长尾关键词：不超过 15 个汉字
   • 避免使用过长的短语

   选择原则

   • 优先选择搜索量大、竞争度适中的词
   • 结合页面实际内容，确保相关性
   • 包含 1-2 个品牌词或产品名称
   • 适当加入长尾关键词，提升精准流量

   搜索引擎兼容性说明

   • Google：已基本不使用 Keywords meta 标签进行排名
   • 百度：仍会参考 Keywords 标签，建议保留
   • 其他国内搜索引擎（360、搜狗等）：仍有一定参考价值
   • 建议：虽然权重降低，但设置正确的关键词不会有负面影响，建议保留

   二、为每个页面模板提供定制的 TDK

   2.1 页面模板分类

   页面模板是指具有相同结构和功能的一类页面。常见的页面模板包括：

   • 首页：网站门户，展示核心价值
   • 列表页/分类页：内容聚合页面（如文章列表、产品分类）
   • 详情页：具体内容页面（如文章详情、产品详情）
   • 功能页：特定功能页面（如搜索页、个人中心）
   • 静态页：关于我们、帮助中心等

   2.2 TDK 定制原则

   首页 TDK

   • 标题：包含品牌词和核心业务关键词
   • 描述：全面介绍产品定位、核心功能、目标用户
   • 关键词：选择最核心的 10 个业务关键词

   列表页/分类页 TDK

   • 标题：分类名称 + 品牌词，体现内容范围
   • 描述：说明该分类下的内容特点和价值
   • 关键词：该分类相关的精准关键词

   详情页 TDK

   • 标题：内容标题 + 分类 + 品牌词
   • 描述：内容摘要或核心观点提炼（建议自动提取前 150 字并优化）
   • 关键词：从内容中提取的核心主题词（可通过算法自动提取）

   功能页 TDK

   • 标题：功能名称 + 功能价值 + 品牌词
   • 描述：功能介绍和使用场景
   • 关键词：功能相关的操作词和需求词

   2.3 TDK 优化管理表格

   建议创建一份 TDK 规范表格，包含以下字段：

   表格必需字段

   • 页面模板名称
   • 页面路径规则
   • 标题模板（含变量占位符）
   • 描述模板（含变量占位符）
   • 关键词模板（含变量占位符）
   • 动态变量说明（如文章标题、分类名称等）
   • 示例展示
   • 负责人
   • 更新时间

   使用场景

   • 新增页面类型时，开发同学可查表确定 TDK 规则
   • 产品/运营同学可定期审核和优化 TDK 模板
   • 便于批量检查和优化现有页面的 TDK 质量

   三、必需的 SEO Meta 标签清单

   3.1 基础 Meta 标签（必需）

   标题标签

   • Title 标签：网页最重要的 SEO 元素，必须独一无二

   描述和关键词标签

   • Description meta 标签：影响点击率的核心因素
   • Keywords meta 标签：虽然权重降低，但建议保留（尤其针对百度）

   3.2 字符编码与视口设置（必需）

   字符编码

   • 使用 UTF-8 编码，确保中文正确显示

   移动端适配

   • Viewport meta 标签：确保移动端正常显示，对移动搜索排名有影响

   3.3 Open Graph 标签（强烈推荐）

   用途说明

   Open Graph 标签主要用于社交媒体分享（如微信、Facebook、Twitter 等），当用户分享链接时，会展示设置的标题、描述和图片。

   必需的 OG 标签

   • og:title - 分享标题（可与页面 Title 一致或略有差异）
   • og:description - 分享描述
   • og:image - 分享图片（建议尺寸：1200x630 像素）
   • og:type - 页面类型（网站首页用 website，文章用 article）
   • og:url - 页面完整 URL（建议使用规范链接）
   • og:locale - 语言地区（如 zh_CN）
   • og:site_name - 网站名称

   图片要求

   • 格式：JPG 或 PNG
   • 尺寸：推荐 1200x630px（比例 1.91:1）
   • 大小：不超过 5MB
   • 必须使用绝对路径（完整 URL）

   3.4 Twitter Card 标签（可选，面向国际化）

   如果产品面向海外用户，建议添加：

   • twitter:card - 卡片类型（如 summary_large_image）
   • twitter:title - 标题
   • twitter:description - 描述
   • twitter:image - 图片

   3.5 Schema.org 结构化数据标签（推荐）

   用途说明

   帮助搜索引擎更好地理解页面内容，可能获得富文本摘要（Rich Snippets）展示。

   常用 itemprop 标签

   • itemprop=“name” - 内容名称
   • itemprop=“description” - 内容描述
   • itemprop=“image” - 内容图片

   更高级的结构化数据

   建议使用 JSON-LD 格式添加结构化数据（在 head 或 body 中添加），常见类型：

   • 文章类（Article）：标题、作者、发布时间、图片等
   • 组织类（Organization）：公司信息、Logo、联系方式等
   • 面包屑（BreadcrumbList）：导航路径
   • 评分类（AggregateRating）：用户评分信息
   • 问答类（FAQPage）：常见问题页面

   3.6 其他重要 Meta 标签

   搜索引擎爬虫控制

   • robots meta 标签：控制页面是否可被索引和抓取（如 index,follow）
   • canonical 标签：指定页面的规范版本，避免重复内容问题

   移动端优化

   • format-detection meta 标签：控制手机号、邮箱等的自动识别

   浏览器兼容性

   • X-UA-Compatible meta 标签：指定 IE 浏览器渲染模式

   国际化支持

   • hreflang 标签：多语言网站指定不同语言版本（link 标签）

   3.7 标签完整性检查清单

   开发完成后，使用以下清单进行检查：

   基础必需项（100%页面必须有）

   • ✓ Title 标签（唯一、符合长度要求）
   • ✓ Description meta 标签（唯一、符合长度要求）
   • ✓ Keywords meta 标签
   • ✓ UTF-8 编码声明
   • ✓ Viewport 设置

   社交分享优化（面向用户分享的页面必须有）

   • ✓ OG:title
   • ✓ OG:description
   • ✓ OG:image（使用绝对路径）
   • ✓ OG:type
   • ✓ OG:url

   结构化数据（重要页面推荐有）

   • ✓ Schema.org 标记（itemprop 或 JSON-LD）
   • ✓ 面包屑导航结构化数据
   • ✓ 文章/产品结构化数据

   爬虫控制（根据需要）

   • ✓ Robots meta 标签（需要控制的页面）
   • ✓ Canonical 标签（有重复内容风险的页面）

   3.8 推荐的标签 HTML 示例代码【重要】

   以下是一个完整的 SEO Meta 标签示例，涵盖了国内外搜索引擎优化的核心标签：

   完整的 Head 标签示例（综合版本）

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42

   <!DOCTYPE html> <html lang="zh-CN"> <head> <!-- ========== 基础必需标签 ========== --> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <meta http-equiv="X-UA-Compatible" content="IE=edge"> <!-- ========== 核心 SEO 标签 ========== --> <title>Java面试题大全 - 面试鸭 | 程序员求职面试刷题神器</title> <meta name="description" content="面试鸭提供海量Java面试题及优质题解，涵盖Java基础、集合框架、多线程、JVM、Spring等核心知识点，助你快速通关校招社招技术面试，找到理想工作。"> <meta name="keywords" content="Java面试题,Java刷题,程序员面试,技术面试,面试鸭"> <!-- ========== Open Graph 标签 ========== --> <meta property="og:title" content="Java面试题大全 - 面试鸭"> <meta property="og:description" content="面试鸭提供海量Java面试题及优质题解，助你快速通关技术面试"> <meta property="og:image" content="https://www.mianshiya.com/images/java-interview-share.jpg"> <meta property="og:type" content="article"> <meta property="og:url" content="https://www.mianshiya.com/bank/java"> <meta property="og:locale" content="zh_CN"> <meta property="og:site_name" content="面试鸭"> <!-- ========== Schema.org 标签 ========== --> <meta itemprop="name" content="Java面试题大全"> <meta itemprop="description" content="面试鸭提供海量Java面试题及优质题解"> <meta itemprop="image" content="https://www.mianshiya.com/images/java-interview.jpg"> <!-- ========== 爬虫控制 ========== --> <meta name="robots" content="index, follow"> <link rel="canonical" href="https://www.mianshiya.com/bank/java"> <!-- ========== 其他优化标签 ========== --> <meta name="format-detection" content="telephone=no"> <!-- 网站图标 --> <link rel="icon" href="/favicon.ico"> </head> <body> <!-- 页面内容 --> </body> </html>

   使用建议

   1. 基础标签：所有页面都必须包含（charset、viewport、title、description）
   2. OG 标签：面向用户分享的页面必须包含，提升社交媒体分享效果
   3. Schema.org 标签：重要页面建议使用 JSON-LD 格式，有机会获得富文本摘要
   4. Twitter Card：国际化产品建议添加
   5. JSON-LD：首页、文章页、产品页等重要页面强烈推荐使用

   动态页面处理

   对于使用框架开发的动态页面（如 React、Vue），建议：

   • 使用服务端渲染（SSR）确保这些标签在 HTML 源代码中
   • 或使用预渲染工具为搜索引擎生成静态 HTML
   • 每个路由/页面都应该有独立的 TDK 和 Meta 标签

   四、页面结构化标签优化规范

   4.1 标题标签（H1-H6）优化规范

   H1 标签规范

   • 唯一性原则：每个页面有且仅有一个 H1 标签
   • 位置要求：H1 应该是页面主标题，通常在顶部显著位置
   • 内容要求：
     • 包含页面核心关键词
     • 与 Title 标签内容相关但不完全相同
     • 长度控制在 20-50 个字符
     • 语义清晰，描述页面主题
   • 常见错误：Logo 使用 H1、一个页面多个 H1、H1 内容与页面主题无关

   H2-H6 标签规范

   • 层级结构：严格按照 H1 > H2 > H3 的层级关系使用，不可跳级
   • H2 标签：用于页面主要章节标题，一个页面可有多个
   • H3-H6 标签：用于子章节和次级内容分类
   • SEO 价值：H2-H3 对 SEO 仍有价值，H4-H6 价值较低
   • 关键词分布：H2-H3 标签中适当融入相关关键词，但避免堆砌

   最佳实践示例

   页面结构建议：

   • H1：页面主标题（1 个）
   • H2：主要内容板块标题（3-5 个）
   • H3：板块内的小节标题（若干个）
   • H4-H6：更细分的层级（按需使用）

   4.2 链接标签（A）优化规范

   锚文本优化

   • 描述性原则：锚文本应清晰描述目标页面内容
   • 避免模糊词（忽略）：禁止使用"点击这里"、“查看更多”、"详情"等无意义文本
   • 关键词融入：锚文本中自然包含目标页面的关键词
   • 长度适中：锚文本建议 2-8 个字，不宜过长

   链接属性设置

   • title 属性：为链接添加 title 属性，提供额外信息（鼠标悬停时显示）
   • rel 属性：
     • 外部链接使用 rel=“nofollow”（不传递权重的链接）
     • 广告/付费链接使用 rel=“sponsored”
     • 用户生成内容中的链接使用 rel=“ugc”
     • 同时打开新窗口时使用 rel=“noopener noreferrer”（安全性）
   • target 属性：站外链接建议使用 target=“_blank” 新窗口打开

   内链策略

   • 相关性原则：链接到相关性高的内部页面
   • 合理密度：每 300-500 字添加 1-2 个内链
   • 避免过度：同一页面不要重复链接到同一目标页面
   • 重要页面优先：多链接到希望搜索引擎重点抓取的页面

   外链策略

   • 权威性原则：优先链接到高权重、权威性强的外部网站
   • 相关性原则：链接到与内容相关的外部资源
   • nofollow 使用：对于不信任的外链、广告链接、用户生成内容中的链接，使用 nofollow
   • 定期检查：避免死链，定期检查外链的有效性

   4.3 图片优化规范

   Alt 属性（必需）

   • 功能价值：
     • 图片无法加载时显示的替代文本
     • 帮助搜索引擎理解图片内容（图片 SEO 的核心）
     • 提升网站可访问性（屏幕阅读器会读取 alt 文本）
   • 内容要求：
     • 准确描述图片内容，5-15 个字为宜
     • 自然融入相关关键词（避免堆砌）
     • 每张图片的 alt 应该独特
     • 装饰性图片可使用空 alt（alt=“”），但不要省略 alt 属性
   • 常见错误：使用图片文件名作为 alt、所有图片用相同的 alt、完全省略 alt 属性

   Title 属性（推荐）

   • 鼠标悬停时显示的提示文本
   • 可提供比 alt 更详细的描述信息
   • 不是 SEO 的核心因素，但可提升用户体验

   图片文件名优化

   • 使用描述性文件名，而非随机字符
   • 使用英文和连字符，如 seo-workflow-guide.jpg
   • 避免使用中文、空格、特殊字符

   图片格式和大小

   • 格式选择：
     • 照片：使用 JPEG（压缩后质量好）
     • 图标/Logo：使用 PNG（支持透明）或 SVG（矢量图）
     • 动画：使用 WebP 或现代格式
   • 尺寸优化：
     • 根据显示尺寸提供合适大小的图片
     • 使用响应式图片（srcset 属性）
     • 单张图片大小尽量控制在 200KB 以内
   • 懒加载：对非首屏图片使用懒加载（loading=“lazy” 属性），提升首屏加载速度

   图片结构化数据

   • 对于重要图片（如产品图、文章配图），可添加 ImageObject 结构化数据
   • 包含图片 URL、描述、作者、版权信息等

   五、搜索引擎内容可见性优化

   5.1 内容开放策略

   核心原则：免费内容对搜索引擎完全开放

   • 价值内容开放：将对用户有价值的核心内容（如免费题目、免费教程、文章全文）完全开放给搜索引擎
   • 避免登录墙：不要要求搜索引擎爬虫登录才能访问内容
   • 避免付费墙：免费内容不要设置付费限制（付费内容可设置，但需要正确标记）

   实施策略

   • 题库类产品：免费题目的题干、题解、答案完全展示给搜索引擎
   • 教程类产品：免费教程的完整内容开放给搜索引擎
   • 内容平台：文章、问答等 UGC 内容对搜索引擎可见
   • 会员内容：可在页面中标注"会员专享"，但仍在 HTML 中渲染内容（使用 CSS 遮罩），或使用结构化数据标记付费内容

   5.2 JavaScript 渲染问题

   问题说明

   虽然 Google 已支持 JavaScript 渲染，但抓取成本更高，可能影响收录速度和质量。百度等国内搜索引擎对 JS 渲染的支持仍然有限。

   解决方案

   • 服务端渲染（SSR）：使用 Next.js、Nuxt.js 等框架实现 SSR
   • 静态生成（SSG）：对于内容固定的页面，生成静态 HTML
   • 预渲染：使用 Prerender.io 等工具为搜索引擎提供预渲染的 HTML
   • 渐进增强：确保 HTML 中包含主要内容，JavaScript 仅用于增强交互

   检查方法

   • 禁用浏览器 JavaScript，查看页面内容是否正常显示
   • 使用 Google Search Console 的 URL 检查工具查看 Google 抓取的内容
   • 查看网页源代码（右键-查看源代码），检查核心内容是否在 HTML 中

   5.3 爬虫友好性设置

   Robots.txt 文件【重要】

   • 位置：网站根目录（如 https://example.com/robots.txt ）
   • 功能：告诉搜索引擎哪些页面可以抓取，哪些不可以
   • 注意事项：
     • 不要误拦截重要页面
     • 可拦截后台管理页面、用户隐私页面、重复内容页面
     • 允许抓取 CSS 和 JS 文件（不要拦截）
   • 定期检查：确保 robots.txt 设置正确，未误拦截

   Sitemap 网站地图【重要】

   • XML Sitemap：
     • 列出网站所有重要页面的 URL
     • 包含最后更新时间、更新频率、优先级
     • 建议按内容类型分多个 sitemap（文章、产品、分类等）
     • 提交到 Google Search Console、百度站长平台等
   • HTML Sitemap：
     • 为用户提供的网站结构导航页面
     • 有助于用户和搜索引擎了解网站结构

   爬虫抓取速度

   • 确保服务器稳定，响应速度快（建议 < 200ms）
   • 合理设置 CDN 加速
   • 避免对爬虫 IP 进行限流（可在日志中识别爬虫 User-Agent）

   5.4 移动端优化

   响应式设计 vs 独立移动站

   • 响应式设计（推荐）：一套代码适配所有设备，URL 统一，利于 SEO
   • 独立移动站：需要设置 canonical 和 alternate 标签，指明 PC 和移动版本的对应关系

   移动友好性要求

   • 文字大小适中，无需缩放即可阅读
   • 点击元素间距足够（至少 48x48 像素）
   • 避免使用 Flash 等移动端不支持的技术
   • 页面加载速度快（建议 < 3 秒）

   AMP（加速移动页面）

   • Google 推出的移动端加速技术
   • 国内使用较少，国际化产品可考虑
   • 可在移动搜索结果中获得闪电标识

   六、内容质量和用户体验优化

   6.1 内容原创性和质量

   原创内容的重要性

   • 搜索引擎优先展示原创、高质量内容
   • 避免大量采集或复制其他网站内容
   • 对于必须引用的内容，注明出处并添加 canonical 标签

   内容质量标准

   • 深度：内容详实，提供真实价值，不是浅尝辄止
   • 专业性：展示专业知识和权威性（E-A-T 原则）
   • 时效性：及时更新过时内容，保持信息准确
   • 可读性：排版清晰、逻辑清楚、配图合理
   • 长度：根据主题深度决定，一般不少于 500 字

   6.2 避免 TDK 重复

   重复问题的危害

   • 搜索引擎无法判断哪个页面更重要
   • 可能被判定为低质量内容
   • 降低整站的 SEO 表现

   检查和解决方法

   • 定期检查：使用 Screaming Frog、Sitebulb 等工具检查全站 TDK 重复情况
   • URL 参数处理：对于筛选、排序等 URL 参数生成的页面，使用 canonical 标签指向标准版本
   • 分页处理：列表页的分页使用 rel=“prev” 和 rel=“next” 标签（或设置 canonical 到第一页）
   • 动态生成：详情页的 TDK 应从内容中动态提取，确保每页唯一

   6.3 用户体验信号

   影响 SEO 的用户行为指标

   • 点击率（CTR）：搜索结果的点击率高，说明标题描述吸引人
   • 停留时间：用户在页面停留时间长，说明内容有价值
   • 跳出率：跳出率低，说明用户找到了所需内容
   • 回访率：用户多次访问，说明网站有价值

   优化策略

   • 优化 TDK，提升搜索结果点击率
   • 提供高质量内容，延长用户停留时间
   • 改善页面加载速度，降低跳出率
   • 增加内链，引导用户浏览更多页面
   • 提供订阅、收藏等功能，提升回访率

   七、技术实施检查清单

   7.1 开发阶段检查项

   页面开发时必须完成

   • [ ] 每个页面都有唯一的 Title 标签
   • [ ] 每个页面都有唯一的 Description meta 标签
   • [ ] 每个页面都有合适的 Keywords meta 标签
   • [ ] 每个页面都有唯一的 H1 标签
   • [ ] H2-H6 标签使用符合层级结构
   • [ ] 所有图片都有 alt 属性
   • [ ] 图片文件名使用描述性命名
   • [ ] 链接使用描述性锚文本，避免"点击这里"
   • [ ] 外部链接添加适当的 rel 属性
   • [ ] 添加 OG 标签（至少包含 title、description、image）
   • [ ] 移动端适配正确（响应式或独立移动站）
   • [ ] 页面加载速度优化（Core Web Vitals 达标）

   技术配置必须完成

   • [ ] 设置正确的 robots.txt 文件
   • [ ] 生成并提交 XML Sitemap
   • [ ] 设置 canonical 标签（有重复内容风险的页面）
   • [ ] 配置 404 错误页面
   • [ ] 启用 HTTPS（SSL 证书）
   • [ ] 配置 301 重定向（旧页面迁移）
   • [ ] 设置合理的 URL 结构（简短、描述性、包含关键词）

   7.2 上线前检查项

   SEO 基础检查

   • [ ] 使用 Google Search Console URL 检查工具测试抓取效果
   • [ ] 使用 Screaming Frog 等工具检查全站 TDK 重复情况
   • [ ] 检查是否有死链（404 页面）
   • [ ] 检查 robots.txt 是否误拦截重要页面
   • [ ] 检查 sitemap.xml 是否正确生成

   技术检查

   • [ ] 移动端友好性测试（Google Mobile-Friendly Test）
   • [ ] 页面速度测试（PageSpeed Insights）
   • [ ] 结构化数据测试（Google Rich Results Test）
   • [ ] OG 标签测试（Facebook Sharing Debugger、微信开发者工具）

   7.3 上线后持续优化

   提交到搜索引擎

   • [ ] 提交 sitemap 到 Google Search Console
   • [ ] 提交 sitemap 到百度站长平台
   • [ ] 提交 sitemap 到其他搜索引擎（360、搜狗、必应等）

   监控和分析

   • [ ] 设置 Google Analytics 或百度统计
   • [ ] 定期查看 Search Console 收录情况
   • [ ] 监控关键词排名变化
   • [ ] 分析用户搜索词，优化内容策略
   • [ ] 定期检查和修复爬虫错误

   内容优化

   • [ ] 定期更新高价值内容
   • [ ] 根据搜索数据优化现有页面的 TDK
   • [ ] 创建更多高质量原创内容
   • [ ] 建立内链体系，提升重要页面权重

   八、常见问题和注意事项

   8.1 TDK 常见错误

   错误示例和解决方案

   1. 标题太短或太长
      • 错误：标题只有品牌名"编程导航"
      • 正确：编程导航 - 程序员的成长社区 | 优质编程学习资源大全
   2. 描述中堆砌关键词
      • 错误：Java、Java 教程、Java 面试、Java 学习、Java 资源、Java 刷题…
      • 正确：自然地将关键词融入通顺的句子中
   3. 关键词设置过多
      • 错误：20 个关键词罗列
      • 正确：3-5 个核心关键词
   4. TDK 与页面内容不符
      • 错误：标题是"Java 教程"，页面内容是 Python 教程
      • 正确：确保 TDK 与页面实际内容高度相关

   8.2 结构化标签常见错误

   1. 多个 H1 标签
      • 一个页面只能有一个 H1
   2. 标题层级跳跃
      • 不要从 H1 直接跳到 H3
   3. 图片缺少 alt
      • 所有图片都应该有 alt 属性
   4. 锚文本不明确
      • 避免使用"点击这里"、"更多"等模糊词汇

   8.3 技术实施注意事项

   单页应用（SPA）的 SEO

   • 使用服务端渲染（SSR）或预渲染
   • 确保搜索引擎能抓取到完整内容
   • 每个路由都有独立的 TDK

   多语言网站 SEO

   • 使用 hreflang 标签指定语言版本
   • 每个语言版本都有独立的 TDK
   • URL 结构清晰（如 /en/, /zh/）

   国际化 SEO

   • 根据目标国家/地区选择合适的域名（.com, .cn 等）
   • 设置 Google Search Console 的目标国家
   • 考虑服务器地理位置（使用 CDN）

   九、附录：推荐工具和资源

   9.1 SEO 检测工具

   综合检测

   • Google Search Console（必备）
   • 百度站长平台（必备）
   • Screaming Frog SEO Spider（全站扫描）
   • Sitebulb（可视化 SEO 审计）

   页面速度

   • Google PageSpeed Insights
   • GTmetrix
   • WebPageTest

   移动端

   • Google Mobile-Friendly Test
   • 百度移动友好度检测

   结构化数据

   • Google Rich Results Test
   • Schema.org Validator

   社交分享

   • Facebook Sharing Debugger
   • Twitter Card Validator
   • 微信开发者工具

   9.2 关键词研究工具

   • Google Keyword Planner
   • 百度关键词规划师
   • Ahrefs Keyword Explorer
   • SEMrush
   • 5118（国内关键词工具）

   9.3 学习资源

   官方文档

   • Google 搜索中心文档
   • 百度搜索资源平台
   • Schema.org 官网

   行业博客

   • Search Engine Journal
   • Moz Blog
   • 百度搜索资源平台博客

   十、总结

   本 SEO 工作流指南涵盖了从 TDK 设置、Meta 标签配置、页面结构优化到技术实施的完整流程。开发团队在实施时应遵循以下核心原则：

   三大核心原则

   1. 用户第一：优先考虑用户体验，SEO 优化应服务于用户需求
   2. 内容为王：高质量、原创、有价值的内容是 SEO 的基础
   3. 技术支撑：正确的技术实施确保搜索引擎能够发现、抓取和理解网站内容

   实施优先级

   • 第一优先级：TDK 设置、H1 标签、图片 alt、移动端适配
   • 第二优先级：OG 标签、结构化数据、页面速度优化
   • 第三优先级：高级优化（AMP、国际化、多语言等）

   持续优化

   SEO 不是一次性工作，需要持续监控、分析和优化。建议每月进行一次 SEO 审计，根据数据反馈调整策略。

   通过遵循本指南，开发团队能够系统化地完成网站 SEO 优化，提升网站在搜索引擎中的可见性和排名，最终带来更多高质量的自然流量。

   ]]> https://www.furinaluna.top/posts/7f8d26b3.html 2026-04-04T10:17:02.000Z

   SEO（Search Engine Optimization）优化是指通过一系列技术和策略，提高网站在搜索引擎中的排名，从而增加网站的曝光率和访问量。以下是一些常见的SEO优化方法：

   学习一下鱼皮大佬的SEO优化方法：

   2026-09-11T13:48:57.151Z Furina FastAPI框架

   fastapi，一个用于构建 API 的现代、快速（高性能）的web框架。

   fastapi是建立在Starlette和Pydantic基础上的，Pydantic是一个基于Python类型提示来定义数据验证、序列化和文档的库。Starlette是一种轻量级的ASGI框架/工具包，是构建高性能Asyncio服务的理性选择。

   • 快速：可与 NodeJS 和 Go 比肩的极高性能（归功于 Starlette 和 Pydantic），是最快的 Python web 框架之一。
   • 高效编码：提高功能开发速度约 200％ 至 300％。
   • 更少bug：减少约 40％ 的人为（开发者）导致错误。
   • 智能：极佳的编辑器支持。处处皆可自动补全，减少调试时间。
   • 简单：设计的易于使用和学习，阅读文档的时间更短。
   • 简短：使代码重复最小化。通过不同的参数声明实现丰富功能。
   • 健壮：生产可用级别的代码。还有自动生成的交互式文档。

   依赖：Python 3.6 及更高版本，FastAPI 站在以下巨人的肩膀之上

   

   Starlette 负责 web 部分(Asyncio)

   Pydantic 负责数据部分(类型提示)

   FastApi是站在前人肩膀上，集成了多种框架的优点的新秀框架。它出现的比较晚，2018年底才发布在github上。广泛应用于当前各种前后端分离的项目开发，测试运维自动化以及微服务的场景中。

   一、预备知识点

   1.1、http协议

   1 2 3 4

   1. 什么是请求头请求体，响应头响应体 2. URL地址包括什么 3. get请求和post请求到底是什么 4. Content-Type是什么

   一、简介

   HTTP协议是Hyper Text Transfer Protocol（超文本传输协议）的缩写,是用于万维网（WWW:World Wide Web ）服务器与本地浏览器之间传输超文本的传送协议。HTTP是一个属于应用层的面向对象的协议，由于其简捷、快速的方式，适用于分布式超媒体信息系统。它于1990年提出，经过几年的使用与发展，得到不断地完善和扩展。HTTP协议工作于客户端-服务端架构为上。浏览器作为HTTP客户端通过URL向HTTP服务端即WEB服务器发送所有请求。Web服务器根据接收到的请求后，向客户端发送响应信息。

   二、 http协议特性

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

   (1) 基于TCP/IP协议 http协议是基于TCP/IP协议之上的应用层协议。 (2) 基于请求－响应模式 HTTP协议规定,请求从客户端发出,最后服务器端响应该请求并 返回。换句话说,肯定是先从客户端开始建立通信的,服务器端在没有 接收到请求之前不会发送响应 (3) 无状态保存 HTTP是一种不保存状态,即无状态(stateless)协议。HTTP协议 自身不对请求和响应之间的通信状态进行保存。也就是说在HTTP这个 级别,协议对于发送过的请求或响应都不做持久化处理。 使用HTTP协议,每当有新的请求发送时,就会有对应的新响应产 生。协议本身并不保留之前一切的请求或响应报文的信息。这是为了更快地处理大量事务,确保协议的可伸缩性,而特意把HTTP协议设计成 如此简单的。 (4) 短连接 HTTP1.0默认使用的是短连接。浏览器和服务器每进行一次HTTP操作，就建立一次连接，任务结束就中断连接。 HTTP/1.1起，默认使用长连接。要使用长连接，客户端和服务器的HTTP首部的Connection都要设置为keep-alive，才能支持长连接。 HTTP长连接，指的是复用TCP连接。多个HTTP请求可以复用同一个TCP连接，这就节省了TCP连接建立和断开的消耗。

   三、http请求协议与响应协议

   

   http协议包含由浏览器发送数据到服务器需要遵循的请求协议与服务器发送数据到浏览器需要遵循的请求协议。用于HTTP协议交互的信被为HTTP报文。请求端(客户端)的HTTP报文 做请求报文,响应端(服务器端)的 做响应报文。HTTP报文本身是由多行数据构成的字文本。

   

   一个完整的URL包括：协议、ip、端口、路径、参数

   例如： https://www.baidu.com/s?wd=yuan 其中https是协议，www.baidu.com 是IP，端口默认80，/s是路径，参数是wd=yuan

   请求方式: get与post请求

   • GET提交的数据会放在URL之后，以?分割URL和传输数据，参数之间以&相连，如EditBook?name=test1&id=123456. POST方法是把提交的数据放在HTTP包的请求体中.
   • GET提交的数据大小有限制（因为浏览器对URL的长度有限制），而POST方法提交的数据没有限制

   响应状态码：状态码的职 是当客户端向服务器端发送请求时, 返回的请求 结果。借助状态码,用户可以知道服务器端是正常 理了请求,还是出 现了 。状态码如200 OK,以3位数字和原因 组成。

   1.2、api接口

   在开发Web应用中，有两种应用模式：

   1. 前后端不分离[客户端看到的内容和所有界面效果都是由服务端提供出来的。]

   

   2. 前后端分离【把前端的界面效果(html，css，js分离到另一个服务端，python服务端只需要返回数据即可)】

   前端形成一个独立的网站，服务端构成一个独立的网站

   

   应用程序编程接口（Application Programming Interface，API接口），就是应用程序对外提供了一个操作数据的入口，这个入口可以是一个函数或类方法，也可以是一个url地址或者一个网络地址。当客户端调用这个入口，应用程序则会执行对应代码操作，给客户端完成相对应的功能。

   当然，api接口在工作中是比较常见的开发内容，有时候，我们会调用其他人编写的api接口，有时候，我们也需要提供api接口给其他人操作。由此就会带来一个问题，api接口往往都是一个函数、类方法、或者url或其他网络地址，不断是哪一种，当api接口编写过程中，我们都要考虑一个问题就是这个接口应该怎么编写？接口怎么写的更加容易维护和清晰，这就需要大家在调用或者编写api接口的时候要有一个明确的编写规范！！！

   为了在团队内部形成共识、防止个人习惯差异引起的混乱，我们都需要找到一种大家都觉得很好的接口实现规范，而且这种规范能够让后端写的接口，用途一目了然，减少客户端和服务端双方之间的合作成本。

   目前市面上大部分公司开发人员使用的接口实现规范主要有：restful、RPC。

   REST全称是Representational State Transfer，中文意思是表述（编者注：通常译为表征）性状态转移。 它首次出现在2000年Roy Fielding的博士论文中。

   RESTful是一种专门为Web 开发而定义API接口的设计风格，尤其适用于前后端分离的应用模式中。

   关键：面向资源开发

   这种风格的理念认为后端开发任务就是提供数据的，对外提供的是数据资源的访问接口，所以在定义接口时，客户端访问的URL路径就表示这种要操作的数据资源。

   而对于数据资源分别使用POST、DELETE、GET、UPDATE等请求动作来表达对数据的增删查改。

   请求方法	请求地址	后端操作
   POST	/student/	增加学生
   GET	/student/	获取所有学生
   GET	/student/1	获取id为1的学生
   PUT	/student/1	修改id为1的学生
   DELETE	/student/1	删除id为1的学生

   restful规范是一种通用的规范，不限制语言和开发框架的使用。事实上，我们可以使用任何一门语言，任何一个框架都可以实现符合restful规范的API接口。

   二、quick start

   简单案例

   安装

   1	pip install fastapi

   你还会需要一个 ASGI 服务器，生产环境可以使用 Uvicorn

   1	pip install uvicorn

   代码

   1 2 3 4 5 6 7

   from fastapi import FastAPI # FastAPI 是一个为你的 API 提供了所有功能的 Python 类。 app = FastAPI() # 这个实例将是创建你所有 API 的主要交互对象。这个 app 同样在如下命令中被 uvicorn 所引用 @app.get("/") async def root(): return {"message": "Hello yuan"}

   通过以下命令运行服务器：

   1	uvicorn main:app --reload

   1 2 3 4 5

   INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit) INFO: Started reloader process [73408] INFO: Started server process [73408] INFO: Waiting for application startup INFO: Application startup complete

   也可以直接运行：

   1 2 3 4 5

   if __name__ == '__main__': import uvicorn uvicorn.run("main:app", host="127.0.0.1", port=8080, debug=True, reload=True)

   （1）导入 FastAPI。
   （2）创建一个 app 实例。
   （3）编写一个路径操作装饰器（如 @app.get(“/”)）。
   （4）编写一个路径操作函数（如上面的 def root(): …）
   （5）定义返回值
   （6）运行开发服务器（如 uvicorn main:app --reload）

   此外，fastapi有着非常棒的交互式 API 文档，这一点很吸引人。

   跳转到 http://127.0.0.1:8000/docs。你将会看到自动生成的交互式 API 文档。

   

   三、路径操作

   路径操作装饰器

   fastapi支持各种请求方式：

   1 2 3 4 5 6 7 8

   @app.get() @app.post() @app.put() @app.patch() @app.delete() @app.options() @app.head() @app.trace()

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

   from typing import Union from fastapi import FastAPI app = FastAPI() @app.get("/get") def get_test(): return {"method": "get方法"} @app.post("/post") def post_test(): return {"method": "post方法"} @app.put("/put") def put_test(): return {"method": "put方法"} @app.delete("/delete") def delete_test(): return {"method": "delete方法"}

   

   路径操作装饰器参数：

   1 2 3 4 5 6 7 8 9 10

   @app.post( "/items/{item_id}", response_model=Item, status_code=status.HTTP_200_OK, tags=["AAA"], summary="this is summary", description="this is description", response_description= "this is response_description", deprecated=False, )

   include_router

   main.py

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   from typing import Union from fastapi import FastAPI import uvicorn from apps import app01, app02 app = FastAPI() app.include_router(app01, prefix="/app01", tags=["第一章节：商城接口", ]) app.include_router(app02, prefix="/app02", tags=["第二章节：用户中心接口", ]) if __name__ == '__main__': uvicorn.run("main:app", host="127.0.0.1", port=8080, debug=True, reload=True)

   与main.py同级目录apps：

   1 2 3

   # __init__.py from .app01 import app01 from .app02 import app02

   1 2 3 4 5 6 7 8 9 10 11 12 13

   from fastapi import APIRouter app01 = APIRouter() @app01.get("/shop/food") def shop_food(): return {"shop": "food"} @app01.get("/shop/bed") def shop_food(): return {"shop": "bed"}

   1 2 3 4 5 6 7 8 9 10 11 12 13 14

   from fastapi import APIRouter app02 = APIRouter() @app02.post("/user/login") def user_login(): return {"user": "login"} @app02.post("/user/reg") def user_reg(): return {"user": "reg"}

   

   四、请求与响应

   4.1、路径参数

   （1）基本用法

   以使用与 Python 格式化字符串相同的语法来声明路径"参数"或"变量"：

   1 2 3 4

   @app.get("/user/{user_id}") def get_user(user_id): print(user_id, type(user_id)) return {"user_id": user_id}

   路径参数 user_id 的值将作为参数 user_id 传递给你的函数。

   （2）有类型的路径参数

   你可以使用标准的 Python 类型标注为函数中的路径参数声明类型。

   1 2 3 4

   @app.get("/user/{user_id}") def get_user(user_id: int): print(user_id, type(user_id)) return {"user_id": user_id}

   在这个例子中，user_id 被声明为 int 类型。

   这将为你的函数提供编辑器支持，包括错误检查、代码补全等等。

   （3）注意顺序

   在创建路径操作时，你会发现有些情况下路径是固定的。

   比如 /users/me，我们假设它用来获取关于当前用户的数据.

   然后，你还可以使用路径 /user/{username} 来通过用户名 获取关于特定用户的数据。

   由于路径操作是按顺序依次运行的，你需要确保路径 /user/me 声明在路径 /user/{username}之前：

   1 2 3 4 5 6 7

   @app.get("/user/me") async def read_user_me(): return {"username": "the current user"} @app.get("/user/{username}") async def read_user(username: str): return {"username": username}

   否则，/user/{username} 的路径还将与 /user/me 相匹配，"认为"自己正在接收一个值为 "me" 的 username 参数。

   4.2、查询参数（请求参数）

   路径函数中声明不属于路径参数的其他函数参数时，它们将被自动解释为"查询字符串"参数，就是 url? 之后用&分割的 key-value 键值对。

   1 2 3 4 5

   @app.get("/jobs/{kd}") async def search_jobs(kd: str, city: Union[str, None] = None, xl: Union[str, None] = None): # 有默认值即可选，否则必选 if city or xl: return {"kd": kd, "city": city, "xl": xl} return {"kd": kd}

   

   在这个例子中，函数参数 city和xl 是可选的，并且默认值为 None。

   自python3.5开始，PEP484为python引入了类型注解(type hints)，typing的主要作用有：

   1. 类型检查，防止运行时出现参数、返回值类型不符。
   2. 作为开发文档附加说明，方便使用者调用时传入和返回参数类型。
   3. 模块加入不会影响程序的运行不会报正式的错误，pycharm支持typing检查错误时会出现黄色警告。

   type hints主要是要指示函数的输入和输出的数据类型，数据类型在typing 包中，基本类型有str list dict等等，

   Union 是当有多种可能的数据类型时使用，比如函数有可能根据不同情况有时返回str或返回list，那么就可以写成Union[list, str]
   Optional 是Union的一个简化， 当 数据类型中有可能是None时，比如有可能是str也有可能是None，则Optional[str], 相当于Union[str, None]

   4.3、请求体数据

   当你需要将数据从客户端（例如浏览器）发送给 API 时，你将其作为「请求体」发送。请求体是客户端发送给 API 的数据。响应体是 API 发送给客户端的数据。

   FastAPI 基于 Pydantic ，Pydantic 主要用来做类型强制检查（校验数据）。不符合类型要求就会抛出异常。

   对于 API 服务，支持类型检查非常有用，会让服务更加健壮，也会加快开发速度，因为开发者再也不用自己写一行一行的做类型检查。

   安装上手pip install pydantic

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48

   from typing import Union, List, Optional from fastapi import FastAPI from pydantic import BaseModel, Field, ValidationError, validator import uvicorn from datetime import date class Addr(BaseModel): province: str city: str class User(BaseModel): name = 'root' age: int = Field(default=0, lt=100, gt=0) birth: Optional[date] = None friends: List[int] = [] description: Union[str, None] = None # addr: Union[Addr, None] = None # 类型嵌套 @validator('name') def name_must_alpha(cls, v): assert v.isalpha(), 'name must be alpha' return v class Data(BaseModel): # 类型嵌套 users: List[User] app = FastAPI() @app.post("/data/") async def create_data(data: Data): # 添加数据库 return data if __name__ == '__main__': try: User(name="",...) except ValidationError as e: print(e.json())

   测试：

   1 2 3 4 5 6 7

   { "name": "rain", "age": 32, "birth": "2022-09-29", "friends": [], "description": "最帅的讲fastapi的老师" }

   和声明查询参数时一样，当一个模型属性具有默认值时，它不是必需的。否则它是一个必需属性。将默认值设为 None 可使其成为可选属性。

   FastAPI 会自动将定义的模型类转化为JSON Schema，Schema 成为 OpenAPI 生成模式的一部分，并显示在 API 交互文档中，查看 API 交互文档如下，该接口将接收application/json类型的参数。

   FastAPI 支持同时定义 Path 参数、Query 参数和请求体参数，FastAPI 将会正确识别并获取数据。

   参数在 url 中也声明了，它将被解释为 path 参数

   参数是单一类型（例如int、float、str、bool等），它将被解释为 query 参数

   参数类型为继承 Pydantic 模块的BaseModel类的数据模型类，则它将被解释为请求体参数

   4.4、form表单数据

   在 OAuth2 规范的一种使用方式（密码流）中，需要将用户名、密码作为表单字段发送，而不是 JSON。

   FastAPI 可以使用Form组件来接收表单数据，需要先使用pip install python-multipart命令进行安装。

   pip install python-multipart

   1 2 3 4 5 6 7 8 9 10

   from fastapi import FastAPI, Form app = FastAPI() @app.post("/regin") def regin(username: str = Form(..., max_length=16, min_length=8, regex='[a-zA-Z]'), password: str = Form(..., max_length=16, min_length=8, regex='[0-9]')): print(f"username:{username},password:{password}") return {"username": username}

   

   4.5、文件上传

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32

   from fastapi import FastAPI, File, UploadFile from typing import List app = FastAPI() # file: bytes = File()：适合小文件上传 @app.post("/files/") async def create_file(file: bytes = File()): print("file:", file) return {"file_size": len(file)} @app.post("/multiFiles/") async def create_files(files: List[bytes] = File()): return {"file_sizes": [len(file) for file in files]} # file: UploadFile：适合大文件上传 @app.post("/uploadFile/") async def create_upload_file(file: UploadFile): with open(f"{file.filename}", 'wb') as f: for chunk in iter(lambda: file.file.read(1024), b''): f.write(chunk) return {"filename": file.filename} @app.post("/multiUploadFiles/") async def create_upload_files(files: List[UploadFile]): return {"filenames": [file.filename for file in files]}

   4.6、Reqeust对象

   有些情况下我们希望能直接访问Request对象。例如我们在路径操作函数中想获取客户端的IP地址，需要在函数中声明Request类型的参数，FastAPI 就会自动传递 Request 对象给这个参数，我们就可以获取到 Request 对象及其属性信息，例如 header、url、cookie、session 等。

   1 2 3 4 5 6 7 8 9 10 11 12 13

   from fastapi import Request @app.get("/items") async def items(request: Request): return { "请求URL：": request.url, "请求ip：": request.client.host, "请求宿主：": request.headers.get("user-agent"), "cookies": request.cookies, }

   4.7、请求静态文件

   在 Web 开发中，需要请求很多静态资源文件（不是由服务器生成的文件），如 css/js 和图片文件等。

   1 2 3 4 5

   from fastapi.staticfiles import StaticFiles app = FastAPI() app.mount("/static",StaticFiles(directory="static"))

   4.8、响应模型相关参数

   （1）response_model

   前面写的这么多路径函数最终 return 的都是自定义结构的字典，FastAPI 提供了 response_model 参数，声明 return 响应体的模型

   1 2 3 4 5

   # 路径操作 @app.post("/items/", response_model=Item) # 路径函数 async def create_item(item: Item): ...

   response_model 是路径操作的参数，并不是路径函数的参数哦

   FastAPI将使用response_model进行以下操作：

   • 将输出数据转换为response_model中声明的数据类型。
   • 验证数据结构和类型
   • 将输出数据限制为该model定义的
   • 添加到OpenAPI中
   • 在自动文档系统中使用。

   你可以在任意的路径操作中使用 response_model 参数来声明用于响应的模型

   案例：

   • 注册功能
   • 输入账号、密码、昵称、邮箱，注册成功后返回个人信息

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

   from typing import Union from fastapi import FastAPI from pydantic import BaseModel, EmailStr app = FastAPI() class UserIn(BaseModel): username: str password: str email: EmailStr full_name: Union[str, None] = None class UserOut(BaseModel): username: str email: EmailStr full_name: Union[str, None] = None @app.post("/user/", response_model=UserOut) async def create_user(user: UserIn): return user

   

   （2）response_model_exclude_unset

   通过上面的例子，我们学到了如何用response_model控制响应体结构，但是如果它们实际上没有存储，则可能要从结果中忽略它们。例如，如果model在NoSQL数据库中具有很多可选属性，但是不想发送很长的JSON响应，其中包含默认值。

   案例：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

   from typing import List, Union from fastapi import FastAPI from pydantic import BaseModel app = FastAPI() class Item(BaseModel): name: str description: Union[str, None] = None price: float tax: float = 10.5 tags: List[str] = [] items = { "foo": {"name": "Foo", "price": 50.2}, "bar": {"name": "Bar", "description": "The bartenders", "price": 62, "tax": 20.2}, "baz": {"name": "Baz", "description": None, "price": 50.2, "tax": 10.5, "tags": []}, } @app.get("/items/{item_id}", response_model=Item, response_model_exclude_unset=True) async def read_item(item_id: str): return items[item_id]

   请求：http://127.0.0.1:8080/items/foo

   不设置unset参数：

   1 2 3 4 5 6 7

   { "name": "Foo", "description": null, "price": 50.2, "tax": 10.5, "tags": [] }

   设置unset参数：

   1 2 3 4

   { "name": "Foo", "price": 50.2 }

   使用路径操作装饰器的 response_model 参数来定义响应模型，特别是确保私有数据被过滤掉。使用 response_model_exclude_unset 来仅返回显式设定的值。
   除了response_model_exclude_unset以外，还有response_model_exclude_defaults和response_model_exclude_none，我们可以很直观的了解到他们的意思，不返回是默认值的字段和不返回是None的字段。

   （3）INCLUDE和EXCLUDE

   1 2 3 4 5 6 7 8 9

   # response_model_exclude @app.get("/items/{item_id}", response_model=Item, response_model_exclude={"description"}, ) async def read_item(item_id: str): return items[item_id] # response_model_include @app.get("/items/{item_id}", response_model=Item, response_model_include={"name", "price"}, ) async def read_item(item_id: str): return items[item_id]

   五、api接口与restful规范

   5.1api接口

   应用程序编程接口（Application Programming Interface，API接口），就是应用程序对外提供了一个操作数据的入口，这个入口可以是一个函数或类方法，也可以是一个url地址或者一个网络地址。当客户端调用这个入口，应用程序则会执行对应代码操作，给客户端完成相对应的功能。

   

   当然，api接口在工作中是比较常见的开发内容，有时候，我们会调用其他人编写的api接口，有时候，我们也需要提供api接口给其他人操作。由此就会带来一个问题，api接口往往都是一个函数、类方法、或者url或其他网络地址，不断是哪一种，当api接口编写过程中，我们都要考虑一个问题就是这个接口应该怎么编写？接口怎么写的更加容易维护和清晰，这就需要大家在调用或者编写api接口的时候要有一个明确的编写规范！！！

   5.2 restful规范

   为了在团队内部形成共识、防止个人习惯差异引起的混乱，我们都需要找到一种大家都觉得很好的接口实现规范，而且这种规范能够让后端写的接口，用途一目了然，减少客户端和服务端双方之间的合作成本。

   目前市面上大部分公司开发人员使用的接口实现规范主要有：restful、RPC。

   REST与技术无关，代表的是一种软件架构风格，REST是Representational State Transfer的简称，中文翻译为“表征状态转移”或“表现层状态转化”。

   简单来说，REST的含义就是客户端与Web服务器之间进行交互的时候，使用HTTP协议中的4个请求方法代表不同的动作。

   GET用来获取资源

   POST用来新建资源

   PUT用来更新资源

   DELETE用来删除资源。

   只要API程序遵循了REST风格，那就可以称其为RESTful API。目前在前后端分离的架构中，前后端基本都是通过RESTful API来进行交互。

   例如，我们现在要编写一个选课系统的接口，我们可以查询对一个学生进行查询、创建、更新和删除等操作，我们在编写程序的时候就要设计客户端浏览器与我们Web服务端交互的方式和路径。

   而对于数据资源分别使用POST、DELETE、GET、UPDATE等请求动作来表达对数据的增删查改。

   请求方法	请求地址	后端操作
   GET	/students	获取所有学生
   POST	/students	增加学生
   GET	/students/1	获取编号为1的学生
   PUT	/students/1	修改编号为1的学生
   DELETE	/students/1	删除编号为1的学生

   5.3、选课系统接口开发

   api/student.py

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75

   from fastapi.exceptions import HTTPException from models import * from pydantic import BaseModel from typing import List, Union from fastapi import APIRouter api_student = APIRouter() @api_student.get("/student") async def getAllStudent(): students = await Student.all().values("name", "clas__name") # students = await Student.filter(name__icontains='a').values("name", "clas__name") # print("students", students) # for i in students: # print(i) # # rain = await Student.get(name='rain') # print(rain, type(rain)) # print(rain.sno) return students class StudentModel(BaseModel): name: str pwd: str sno: int clas_id: Union[int, None] = None courses: List[int] = [] @api_student.post("/student") async def addStudent(stu: StudentModel): # 添加数据库操作 # 方式1 # student = Student(name=stu.name, pwd=stu.pwd, sno=stu.sno, clas_id=stu.clas) # await student.save() # 方式2 student = await Student.create(name=stu.name, pwd=stu.pwd, sno=stu.sno, clas_id=stu.clas_id) print(student, dir(student)) # 添加多对多关系记录 courses = await Course.filter(id__in=stu.courses) print("courses", courses) await student.courses.add(*courses) print("student", student.courses) return student @api_student.put("/student/{student_id}") async def update_student(student_id: int, student: StudentModel): data = student.dict(exclude_unset=True) courses = data.pop("courses") print(data, courses) await Student.filter(id=student_id).update(**data) courses = await Course.filter(id__in=student.courses) edit_student = await Student.get(id=student_id) await edit_student.courses.clear() await edit_student.courses.add(*courses) return student @api_student.delete("/student/{student_id}") async def delete_student(student_id: int): deleted_count = await Student.filter(id=student_id).delete() # 条件删除 if not deleted_count: raise HTTPException(status_code=404, detail=f"Student {student_id} not found") return {}

   六、中间件与CORS

   6.1、中间件

   你可以向 FastAPI 应用添加中间件.

   "中间件"是一个函数,它在每个请求被特定的路径操作处理之前,以及在每个响应之后工作.

   如果你使用了 yield 关键字依赖, 依赖中的退出代码将在执行中间件后执行.

   如果有任何后台任务(稍后记录), 它们将在执行中间件后运行.

   要创建中间件你可以在函数的顶部使用装饰器 @app.middleware("http").

   中间件参数接收如下参数：

   • request.
   • 一个函数call_next，它将接收request，作为参数.
     • 这个函数将 request 传递给相应的 路径操作.
     • 然后它将返回由相应的路径操作生成的 response.
   • 然后你可以在返回 response 前进一步修改它.

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63

   import uvicorn from fastapi import FastAPI from fastapi import Request from fastapi.responses import Response import time app = FastAPI() @app.middleware("http") async def m2(request: Request, call_next): # 请求代码块 print("m2 request") response = await call_next(request) # 响应代码块 response.headers["author"] = "yuan" print("m2 response") return response @app.middleware("http") async def m1(request: Request, call_next): # 请求代码块 print("m1 request") # if request.client.host in ["127.0.0.1", ]: # 黑名单 # return Response(content="visit forbidden") # if request.url.path in ["/user"]: # return Response(content="visit forbidden") start = time.time() response = await call_next(request) # 响应代码块 print("m1 response") end = time.time() response.headers["ProcessTimer"] = str(end - start) return response @app.get("/user") def get_user(): time.sleep(3) print("get_user函数执行") return { "user": "current user" } @app.get("/item/{item_id}") def get_item(item_id: int): time.sleep(2) print("get_item函数执行") return { "item_id": item_id } if __name__ == '__main__': uvicorn.run('main:app', host='127.0.0.1', port=8030, reload=True, debug=True, workers=1)

   6.2、CORS

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

   <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.6.0/jquery.js"></script> </head> <body> <p>click</p> <script> $("p").click(function () { $.ajax({ url: "http://127.0.0.1:8080/", success: function (res) { $("p").html(res.message) }, }) }) </script> </body> </html>

   1 2 3 4 5

   @app.middleware("http") async def CORSMiddleware(request: Request, call_next): response = await call_next(request) print(response.headers) return response

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

   from fastapi import FastAPI from fastapi.middleware.cors import CORSMiddleware app = FastAPI() origins = [ "http://localhost:63342" ] app.add_middleware( CORSMiddleware, allow_origins=origins, # *：代表所有客户端 allow_credentials=True, allow_methods=["GET"], allow_headers=["*"], ) @app.get("/") def main(): return {"message": "Hello World"} if __name__ == '__main__': import uvicorn uvicorn.run("main:app", host="127.0.0.1", port=8080, debug=True, reload=True)

   ]]> https://www.furinaluna.top/posts/fastapi-framework.html 2026-03-31T08:30:00.000Z

   FastAPI框架

   fastapi，一个用于构建 API 的现代、快速（高性能）的web框架。

   fastapi是建立在Starl]]>

   2026-09-11T13:48:57.131Z Furina 数据库表是一个二维表，包含多行多列。把一个表的内容用Python的数据结构表示出来的话，可以用一个list表示多行，list的每一个元素是tuple，表示一行记录，比如，包含id和name的user表：

   1 2 3 4 5

   [ ('1', 'Michael'), ('2', 'Bob'), ('3', 'Adam') ]

   Python的DB-API返回的数据结构就是像上面这样表示的。

   但是用tuple表示一行很难看出表的结构。如果把一个tuple用class实例来表示，就可以更容易地看出表的结构来：

   1 2 3 4 5 6 7 8 9 10

   class User(object): def __init__(self, id, name): self.id = id self.name = name [ User('1', 'Michael'), User('2', 'Bob'), User('3', 'Adam') ]

   这就是传说中的ORM技术：Object-Relational Mapping，把关系数据库的表结构映射到对象上。是不是很简单？

   但是由谁来做这个转换呢？所以就有了ORM框架。

   在Python中，最有名的ORM框架是SQLAlchemy。我们来看看SQLAlchemy的用法。

   首先通过pip安装SQLAlchemy：

   1	$ pip install sqlalchemy

   第一步，导入SQLAlchemy，并初始化DBSession：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

   # 导入: from sqlalchemy import Column, String, create_engine from sqlalchemy.orm import sessionmaker from sqlalchemy.orm import declarative_base # 创建对象的基类: Base = declarative_base() # 定义User对象: class User(Base): # 表的名字: __tablename__ = 'user' # 表的结构: id = Column(String(20), primary_key=True) name = Column(String(20)) # 初始化数据库连接: engine = create_engine('mysql+mysqlconnector://root:password@localhost:3306/test') # 创建DBSession类型: DBSession = sessionmaker(bind=engine)

   以上代码完成SQLAlchemy的初始化和具体每个表的class定义。如果有多个表，就继续定义其他class，例如School：

   1 2 3 4

   class School(Base): __tablename__ = 'school' id = ... name = ...

   1	create_engine()

   用来初始化数据库连接。SQLAlchemy用一个字符串表示连接信息：

   ‘数据库’mysql+mysqlconnector://root:password@localhost:3306/test’

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

   ```mysql+mysqlconnector```表示使用MySQL的```mysql-connector-python```驱动，```root```是用户名，```password```是数据库密码，```localhost```是机器地址，```3306```是端口号，```test```是数据库名。 你只需要根据需要替换掉用户名、口令等信息即可。 下面，我们看看如何向数据库表中添加一行记录。 由于有了ORM，我们向数据库表中添加一行记录，可以视为添加一个User对象： ```python # 创建session对象: session = DBSession() # 创建新User对象: new_user = User(id='5', name='Bob') # 添加到session: session.add(new_user) # 提交即保存到数据库: session.commit() # 关闭session: session.close()

   可见，关键是获取session，然后把对象添加到session，最后提交并关闭。DBSession对象可视为当前数据库连接。

   如何从数据库表中查询数据呢？有了ORM，查询出来的可以不再是tuple，而是User对象。SQLAlchemy提供的查询接口如下：

   1 2 3 4 5 6 7 8 9

   # 创建Session: session = DBSession() # 创建Query查询，filter是where条件，最后调用one()返回唯一行，如果调用all()则返回所有行: user = session.query(User).filter(User.id=='5').one() # 打印类型和对象的name属性: print('type:', type(user)) print('name:', user.name) # 关闭Session: session.close()

   运行结果如下：

   1 2	type: <class '__main__.User'> name: Bob

   可见，ORM就是把数据库表的行与相应的对象建立关联，互相转换。

   由于关系数据库的多个表还可以用外键实现一对多、多对多等关联，相应地，ORM框架也可以提供两个对象之间的一对多、多对多等功能。

   例如，如果一个User拥有多个Book，就可以定义一对多关系如下：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

   class User(Base): __tablename__ = 'user' id = Column(String(20), primary_key=True) name = Column(String(20)) # 一对多: books = relationship('Book') class Book(Base): __tablename__ = 'book' id = Column(String(20), primary_key=True) name = Column(String(20)) # “多”的一方的book表是通过外键关联到user表的: user_id = Column(String(20), ForeignKey('user.id'))

   当我们查询一个User对象时，该对象的books属性将返回一个包含若干个Book对象的list。

   小结

   ORM框架的作用就是把数据库表的一行记录与一个对象互相做自动转换。
   正确使用ORM的前提是了解关系数据库的原理。
   ORM框架的使用方法是：先定义映射关系，然后就可以把数据库表看成一个对象来操作。

   ]]> https://www.furinaluna.top/posts/57e0396f.html 2026-03-30T00:36:52.000Z

   数据库表是一个二维表，包含多行多列。把一个表的内容用Python的数据结构表示出来的话，可以用一个list表示多行，list的每一个元素是tuple，表示一行记录，比如，包含id和name的user表：

   没办法，准备转python了，后续再更新，急。

   个人浅薄的看法：如果还在学前端的话，建议学完vue/react，和ts，再转python，没学前端的可以直接学python。

   先学python基础，很简单，有编程基础三四天就可以过完

   学习资料：

   • 菜鸟教程python3
   • python官方文档

   学习fastapi，django或者flask也行，选一个，快一点

   学习资料：

   • 菜鸟教程fastapi
   • fastapi官方文档

   学orm了解基本概念，然后学个sqlalchemy，快速上手基础增删改查

   学习资料：

   • 廖雪峰的sqlalchemy教程
   • sqlalchemy官方文档

   知道怎么样快速实现ai应用开发

   怎么调ai接口并且和前端后端交互，让ai模型按照具体项目所需要的提示词进行响应等等。可以网上找找项目，课程可以看黑马的，但是建议不用全看，多数时候看相关的官方文档。

   继续深入学习

   一般的人还是先不要搞底层，算法那些，我们暂时只学应用层面，搓ai应用开发。快速找个实习，你要能够快速做出东西来，对自己做的项目优化可说，基本的面试题会一点，进一个中小厂实习积累经验应该没问题。

   待更新

   ]]> https://www.furinaluna.top/posts/797bc1cb.html 2026-03-19T14:13:37.000Z

   没办法，准备转python了，后续再更新，急。

   个人浅薄的看法：如果还在学前端的话，建议学完vue/react，和ts，再转python，没学前端的可以直接学python。

   为进一步提升工作室的整体形象与信息展示体验，半月工作室官网已于近日完成全新站点迁移与升级，并正式上线运行。
   而此站点则将作为我个人的技术博客，用于记录工作室的技术进展、项目经验、学习笔记等。
   本次迁移标志着工作室在技术建设与规范化运营方面迈出了重要一步。新站点采用前后端分离的现代 Web 架构，在页面设计、访问速度与可扩展性等方面均进行了系统性的优化。

   🔧 本次迁移主要内容

   新站点👉 lab.furinaluna.top

   更清晰地体现工作室 / 实验室属性，便于对外展示与长期维护。
   前端架构全面升级：
   新站点基于现代前端技术栈重构，页面结构更加清晰，视觉风格更加简洁统一。
   为后续系统扩展预留空间：
   新站点已按前后端分离模式设计，已经了接入后台管理系统。

   🌱 为什么要进行站点迁移？

   随着工作室项目与成员规模的逐步扩大，原有页面在扩展性与管理方式上已难以满足后续需求。本次迁移不仅是一次页面调整，更是一次面向长期发展的技术升级，为以下目标打下基础：

   更系统地展示工作室成员与项目成果
   更方便地进行内容维护与更新
   构建规范、可持续演进的技术体系

   🚀 展望未来

   新站点的上线只是开始。接下来，工作室将陆续推进：

   成员与项目的动态展示
   技术文章
   招新
   我们也欢迎大家在使用过程中提出宝贵建议，帮助工作室不断完善与进步。

   让我们以全新的站点为起点，继续在技术道路上稳步前行。

   半月工作室

   📍 lab.furinaluna.top

   ]]> https://www.furinaluna.top/posts/694a08e1.html 2025-12-22T08:29:29.000Z

   为进一步提升工作室的整体形象与信息展示体验，半月工作室官网已于近日完成全新站点迁移与升级，并正式上线运行。
   而此站点则将作为我个人的技术博客，用于记录工作室的技术进展、项目经验、学习笔记等。
   ]]>

   2026-09-11T13:48:57.195Z Furina 考核时间

   大一上学期考核（3次）

   • 内容：以基本的编码能力和思维能力为基础，检验你们的学习能力和积极进取的态度。在牛客网上写算法编程题，不要求全对，但希望你们可以独立思考和解决问题

   大一下学期考核（3次）（重点）

   • 内容：寒假期间 会分学习的方向，如前端、后端、嵌入式等等，到时候在放假前会发通知，请大家提前做好准备。

   关于大一上学期算法考核题

   为什么大一上要算法考核题

   有同学会说："哎，学长，我大一学的太少了，你出的题目太难了，你这不是为难我吗，把我当日本人整
   其实，算法考核题不是“为难”大家，而是为了培大家的能力。

   • 1.首先，你们大一会学习c语言，大一下学期会学习c++，数据结构与算法，大二还有算法设计与分析等等，你先接触一点这些考核题，对你的专业学习肯定会有帮助的，只要你自己想过，写过，你肯定会学到新的东西的。而且到时候你们就会知道，一个人见识越多，才会越优秀。这些都是后话。
     总结，对你们专业考试有帮助

   • 2.基本的学习能力。觉得难很正常，因为学的东西太少了，而这就是考核题的第二个作用，培养你们的自主学习能力，我们程序员，都是在不断学习的，遇到问题，我们会去搜索，去解决问题。这就是自主学习的能力。有问题你要会找办法解决，首先一定是自己要去找答案，互联网这么发达对吧，什么都可以找到，你说太乱了，太杂了没有好的总结资料，那肯定是很少的，所以信息检索能力也是一个非常重要的东西，学会如何在网上找到高质量的知识和体系。还有就是如今，技术一直都在更新迭代，想要能在计算机的行业站住脚，非常考验我们的学习能力和思考能力。比如一个框架，也许过几天又出新的版本了，又或者出了新的流行的框架，别人一下就掌握了，而你却没有，那你就落后了。为什么？因为你没有好的学习的能力与总结能力（这个在数学上有的大佬叫它元学习能力）。很多技术是相连通的，你越学到后面就越会发现，比如高数，线代，概率论，离散数学，你觉得这些对我有个猫的用处，但其实，你学精了，你学其他的，有种手到擒来的感觉。说的有点多了，展开来吹牛讲可以讲一晚上。
     总之，考核题一个是让你们脑子动起来，一个是让你们学会学习。遇到问题要知道怎么解决，去找大佬，去网上搜索，去哔哩哔哩，去逛论坛，去问AI，这都是很重要的能力。学习能力，总结能力，信息检索能力这种东西，即使从事其他行业，甚至对你的生活都有很大的帮助

   • 3.工作面试和考研升学，首先一点，去进入一些中大厂，几乎没有不考算法题的，无论是前端还是后端。哎嘿，那又回到原来的问题，为什么考算法考核题，实际的工作业务中，有很多场景会利用到算法的一些思想，比如一个前端，公司给他一个项目，他需要做一个页面，这个页面需要展示很多数据，而这些数据是从后端接口获取的，那么他就需要对这些数据进行排序，筛选，分页等等，你觉得这些数据怎么处理，暴力遍历一遍，你发现页面渲染非常慢，公司经理叫你优化一下，你不会，然后你就偶吼了（这只是一个简单的例子）还有叫你写一个什么富文本编辑器呀乱七八糟的。
     还有就是你开发时候的一些场景，算法锻炼出的的逻辑思路让你知道要做什么

   比如叫我做一个项目的评论区，我第一步肯定要数据库设计，我要考虑到评论区的一些功能，比如评论，回复，点赞，删除等等，我要考虑到这些功能的实现，我要找后端要接口，和后端沟通。我要考虑前端渲染，用什么框架，前端性能等等。（你写一道算法题，你是不是也要想，哎，这题用什么，动规，贪心，回溯，如果是动规，那我下一步要怎么做来着，哦，找动规状态转移方程，建立DP表，哎，还有dp的初始化，哎，测试对了。啊，为什么过不了超时了，怎么优化？哦。记忆化搜索，滚动数组对吧。。。。。）

   总之，之后你们学习的一些技术，给你一个要求，你要知道第一步是什么，第二步是什么。怎么做更好，哪步错了，怎么改。这些通过写一定的算法题，你能够有一个清晰的认知，业务逻辑的思路和解一道算法题目的思路是很相似的

   • 4.最后，考核题不是为了打击大家，而是为了帮助大家，希望大家能够在考核题中有所收获，有所成长。写不出来不要紧，去看一下答案，学习一下，多思考，多总结，多提升。一定不要傻傻的死磕哈。

   • 5.有想走算法方面的同学，可以去看看

   • 算法竞赛
   • 牛客网
   • 力扣
   • acwing
   • 如何评估自己的算法能力

   总结上学期招新要求

   只要你

   • 能够独立思考，解决问题

   • 能够有积极进取的态度，会学习，有能力，不放弃

   • 能够有良好的学习态度，有良好的学习习惯，有良好的信息检索能力

   • 良好的人品，有责任心，有团队精神

   欢迎学弟学妹来我们半月工作室，一起学习，一起进步，一起成长，我们一起加油哦

   

   写的可能有比较多的瑕疵，最近事情多，见谅

   关于大一下学期考核题

   待更新

   ]]> https://www.furinaluna.top/posts/3c9e7367.html 2025-12-01T11:13:38.000Z

   考核时间

   大一上学期考核（3次）

   • 内容：以基本的编码能力和思维能力为基础，检验你们的学习能力和

   2026-09-11T13:48:57.151Z Furina 前言

   本篇主要用于我自己的复习，如果想速成的话掌握这些够用了，再看看书上或者视频的解题的模板过程

   考试内容

   • 时间复杂度(直接带入和主定理法)
   • 分治
   • 动态规划
   • 贪心算法
   • 回溯
   • 分支限界

   时间复杂度(直接带入和主定理法)

   分治

   分治的基本思想

   将一个较难解决的规模较大的问题，分解成多个相似的规模较小的子问题，递归地解决这些子问题，然后将这些子问题的解合并成原问题的解。

   分治的基本步骤

   1. 分解：将原问题分解成多个相似的子问题。
   2. 解决：（一般通过递归）地解决这些子问题。
   3. 合并：将这些子问题的解合并成原问题的解。

   分治算法的特点（条件）

   1. 原问题的规模缩小到一定程度就可以直接解决。
   2. 原问题可以分解成多个相似的子问题。（分治法的前提：最优子结构性质）
   3. 子问题的解可以合并成原问题的解。（能否利用分治法完全取决于这个特征：可以合并）
   4. 子问题之间是独立的，不包含公共的子问题。（子问题相互独立，互不影响）

   案例

   • 归并排序
   • 快速排序
   • 二分查找
   • 大整数乘法
   • 平面内最近点对问题
   • 矩阵乘法
   • Strassen矩阵乘法
   • 最大子数组问题
   • 快速傅里叶变换(FFT)

   动态规划（带备忘录法自顶向下，空间换时间，储存记录子问题的解，避免重复计算）

   动态规划的基本思想

   解决多阶段决策最优化问题的数学模型。将多阶段决策过程分解成多个子问题，每个子问题对应一个阶段，每个阶段的决策依赖于前一个阶段的决策结果。通过动态规划的方法，从第一个阶段开始，逐步计算每个阶段的最优解，最终得到多阶段决策过程的最优解。（从全局考虑）

   动态规划的基本步骤

   1. 分析最优解的性质是不是：最优子结构性质、无后效性、重叠子问题，是否满足动规的前提。
   2. 合适划分子问题，子问题重叠度高，考虑动态规划。
   3. 确定动态规划的状态转移方程。
   4. 确定边界条件。
   5. 自底向上计算每个状态的最优解。(迭代)/自顶向下(备忘录法)。
   6. 根据计算结果，构造最优解。用备忘录和标记函数值通过追溯来得到最优解。

   特点

   1. 最优子结构性质：如果问题的最优解所包含的子问题的解也是最优的，我们就称该问题具有最优子结构性质（即满足最优子结构性质的问题可以用动态规划求解）。
   2. 无后效性（马尔可夫性）：即某阶段状态一旦确定，则该状态下的决策不再受到以后决策的影响。
   3. 子问题重叠性质：子问题之间是重叠的，即不同的子问题之间存在公共的子子问题。（与分治法的区别，分治法的子问题是独立的，互不影响）

   案例

   • 0-1背包问题
   • 最长公共子序列问题
   • 最大子段和问题（也可以用分治法解决）
   • 矩阵链乘法问题
   • 最小编辑距离问题

   0-1背包问题

   贪心算法

   贪心算法的基本思想

   部分最优解构成全局最优解。

   贪心的性质（贪心不可以解决0-1背包问题，可以解决部分背包问题）

   1. 贪心选择性质：每一步都做出当前最优的选择，期望通过一系列的最优选择，最终得到全局最优解。（与动态规划的区别：动态规划的每一步都考虑了所有可能的选择（全局），而贪心算法只考虑当前最优的选择。或者说动态规划有重叠子问题性质，贪心有贪心选择性质）
   2. 最优子结构性质：问题的最优解包含子问题的最优解。

   案例

   • 活动选择问题
   • 哈夫曼编码问题
   • 最小生成树问题（Kruskal算法，Prim算法）
   • 单源最短路径问题（Dijkstra算法）
   • 多机调度问题
   • 糖果均分问题
   • 装载问题
   • 背包问题（部分背包问题，不是0-1背包问题）
   • 旅行商问题
   • 最优二叉查找树问题
   • 最小路径覆盖问题
   • 最小路径权问题
   • 最小费用流问题
   • 最大流问题

   回溯（通法，深度优先搜索，栈，递归，剪枝，解空间树的画法）

   回溯的基本思想

   搜索解空间树，找到所有满足约束条件的所有解。

   回溯的基本步骤

   1. 针对问题，定义问题的解空间。
   2. 确定解空间树的搜索策略。
   3. 确定剪枝函数。
   4. 以深度优先搜索的方式，搜索解空间树。
   5. 在解空间树上，从根节点出发，沿着一条路径，不断选择子节点，直到找到一个满足约束条件的解，或者到达叶子节点，无法继续选择。
   6. 如果找到一个满足约束条件的解，则记录下来。
   7. 如果到达叶子节点，无法继续选择，则返回上一个节点，重新选择其他节点，继续搜索。
   8. 重复步骤4-6，直到解空间树上所有节点都被搜索过。
   9. 输出所有满足约束条件的解。
      DFS递归
      模板：

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21

   type dfs(type x, ... ) // 可以存在多个变量 { if( ... ) // 达成目标，找到答案 { ... // 输出答案或判断最优解等等 return; } if( ... ) // 达到搜索边界（即到边界了还没搜到，有时没有此步骤） { return; } for( ... ) // 遍历所有子节点 { if( ... ) // 可以转移状态，一般用标志变量判断 { ... // 修改标志变量，表明此节点不可转移 dfs( ... ) // 搜索子节点，经常为x+1 ... // 还原标志变量，表面此节点可转移(回溯) } } }

   案例

   • 全排列问题
   • n皇后问题
   • 0-1背包问题
   • 图的着色问题
   • 旅行商问题
   • 最大团问题
   • 最小覆盖问题
   • 最大流问题
   • 最小费用流问题

   解空间树

   • 1子集树
     给定问题是从n个元素的集合S中找出满足某种条件的所有子集，相应的解空间树称为子集树。如0-1背包问题的解空间树就是子集树。对于01背包，子集树有2^n+1^-1个节点，每个节点对应一个子集。遍历子集树的时间复杂度为O(2^n)。

   • 2排列树
     给定问题是从n个元素找出满足某种条件的所有排列，相应的解空间树称为排列树。如n皇后问题、旅行商问题的解空间树就是排列树。旅行商问题的解空间树有n!个节点，每个节点对应一个排列。遍历排列树的时间复杂度为O(n!)。

   分支限界

   分支限界的基本思想

   把问题的解空间转化为解空间树，然后用广度优先搜索或者最小耗费（最大效益）优先策略的方式，搜索解空间树。（找到某一个解/最优解，回溯找的是所有解）

   分支限界的方式

   分支限界根据从活结点表中选择下一个扩展结点的方式，可分为队列式分支限界和优先队列式分支限界。

   • 队列式分支限界（FIFO）

   • 优先队列式分支限界/最小耗费优先/最大效益优先
     出队的队首结点，是优先级最高（最有利）的结点，成为当前扩展结点。
     最大（效益）优先队列：大根堆（大顶堆）（最大化问题）
     最小（耗费）优先队列：小根堆（小顶堆）（最小化问题）

   左用分支函数，右用限界函数

   分支函数生成子节点，限界函数判断是否剪枝

   案例

   • 0-1背包问题
   • 装载问题
   • 旅行商问题
   • 最小路径覆盖问题
   • 最小路径权问题
   • 最小费用流问题
   • 最大流问题
   • 8数码问题

   ]]> https://www.furinaluna.top/posts/3274548c.html 2025-11-27T13:17:59.000Z

   前言

   本篇主要用于我自己的复习，如果想速成的话掌握这些够用了，再看看书上或者视频的解题的模板过程

   考试内容

   ]]>

   2026-09-11T13:48:57.195Z Furina

   以下是我和工作室的林学姐总结的后端学习路线

   具体的学习路线可以点击这个链接参考下黑马提供的这个路线

   当然，也可以看看工作室学长、学姐传承下来的学习路线图

   

   这个视频也可以参考下
   后端学习路线

   后端是什么

   后端在计算机科学和软件开发的领域中，指的是处理服务器端逻辑、数据存储、以及与前端进行通信的部分。后端通常运行在服务器上，不可见于最终用户，但负责处理所有业务逻辑、数据存取、以及与前端的接口交互。

   • 说最简单点，后端就是软件的 “大脑” 和 “心脏”，它在幕后负责处理所有核心工作，确保你在前端的每一个操作都能得到正确的响应和结果。它虽然不直接与用户见面，却是整个系统稳定、高效运行的关键。（大一用C语言做的的学生管理系统，后台管理系统，就是简单的后端，大二的时候学校会教Java，还有数据库）

   以下是林学姐提供的图示
   后端开发流程

   

   后端技术栈

   

   后端主要职责

   

   后端开发语言

   • 后端开发语言主要有Java、C#、PHP、Python、JavaScript、Node.js、C/C++等。

   • 后端开发选择上的话建议首选Java其次Python。

   开发工具

   • 无脑使用IDEA
     地址：IDEA官方网站
     不过想要免费的话，可以去网上找激活码教程，或者联系学长也可以

   • python的话，也可以使用pycharm

   我主修前端的，不过也了解后端的知识，search到了一些后端的学习资源，可以参考下，具体的可以问后端的学长学姐

   后端学习资源

   Java基础

   • 黑马程序员（如果选黑马的话直接按照他们给的路线和教程学习即可）

   • 韩顺平 零基础30天学会Java

   • 菜鸟教程（可以在线练习）

   • 廖雪峰的官方网站

   练手项目(不要只copy，练手项目做一做，别骗自己)

   • JAVA GUI 图书馆管理系统

   • 坦克大战小游戏

   • Swing编写的俄罗斯方块

   • 小小记账本(了解数据库的可以看一下)

   MySQL数据库

   -2022年的黑马程序员 MySQL数据库入门到精通
   （这个视频的话，我作为前端感觉可以速成一下，看前面57节基础篇，后续的话可以根据需要再看）

   • 尚硅谷MySQL数据库(小姐姐版)

   • MYSQL菜鸟教程

   • SQL 教程

   开发框架

   按照黑马的路线或者尚硅谷的学习路线来
   哔哩哔哩上都有对应的视频，按照视频学习即可。

   持续更新

   ]]> https://www.furinaluna.top/posts/bae03965.html 2025-11-25T01:51:55.000Z

   以下是我和工作室的林学姐总结的后端学习路线

   具体的学习]]>

   2026-09-11T13:48:57.172Z Furina

   前言：以下是我和工作室的舒学姐总结的嵌入式学习路线，希望对大家有所帮助。欢迎大家补充和指正

   ---

   软件工程嵌入式方向学习总结

   一、嵌入式开发：给万物“赋魂”

   你可以把嵌入式开发想象成一个“赋魂”的过程。我们身边有无数普通的机器和设备，嵌入式工程师的工作，就是为这些冰冷的机器设计和植入一个“大脑”和“神经”系统，让它们变得“聪明”起来，能够感知环境、独立思考并执行命令。

   二、一个生动的比喻：智能机器人的“体内世界”

   想象一下，我们要造一个能自己打扫房间的扫地机器人。它的“身体”是轮子、刷子和外壳。而它的“生命”——也就是嵌入式系统——则由以下几部分构成：

   1. 硬件层 - 机器人的“身体和感官”

   这是嵌入式系统的物质基础，就像机器人的骨骼、五官和神经末梢。

   • 主控制器：相当于机器人的大脑。但这是一种“专注”、“高效”的大脑（通常是微控制器MCU，如STM32系列），专门为特定任务而生，不像我们用的电脑CPU那样“啥都干”。
   • 传感器：相当于机器人的眼睛、耳朵和皮肤。比如：
     • 红外传感器/超声波传感器 -> 用来“看”路，防止撞墙。
     • 灰尘传感器 -> 用来“感觉”地面是否干净。
   • 执行器：相当于机器人的手脚。比如：
     • 电机和轮子 -> 负责移动。
     • 抽气风扇 -> 负责吸尘。

   2. 软件层 - 机器人的“思想和本能”

   这是嵌入式系统的灵魂，决定了这个“身体”如何思考和行动。

   • 嵌入式操作系统：一个精简、高效的管理员。它负责管理大脑的“思维”资源，比如先处理“避障”任务，再处理“吸尘”任务。常见的如FreeRTOS，它是一个非常轻量级的任务调度器。
   • 应用软件/驱动程序：这是你写的核心代码，是机器人的“技能和本能”。
     • 驱动程序：你写的代码告诉大脑如何控制轮子转动、如何读取传感器的数据。（直接和硬件打交道）
     • 应用逻辑：你写的算法，比如“如果传感器发现前方有障碍，就立刻让轮子转向”。（处理数据，做出决策）

   三、这个方向主要学什么？

   1. C语言是母语：这是和硬件沟通最直接、最高效的语言，必须非常精通。
   2. 玩转硬件基础：要懂数字电路和模拟电路，知道电阻、电容、晶体管是怎么工作的，能看懂芯片的数据手册。
   3. 理解计算机结构：学习计算机组成原理和体系结构，明白CPU、内存、总线是如何协同工作的。
   4. 拥抱微控制器：深入学习一种主流的微控制器（如STM32或ESP32），学会如何配置它的各种功能（GPIO、定时器、串口、ADC等）。
   5. 掌握实时操作系统：学习像FreeRTOS这样的系统，理解多任务、消息队列、信号量等概念，让你的程序能“一心多用”。
   6. 软硬结合，动手实践：最重要的环节！买一块开发板，亲手焊接电路，点亮第一个LED灯，驱动一个电机，完成一个属于自己的小项目（比如智能小车、天气站）。

   四、未来的职业方向

   毕业后，你可以成为：

   • 嵌入式软件开发工程师
   • 嵌入式硬件开发工程师
   • 固件工程师
   • 物联网开发工程师

   你会在各行各业大展身手：智能家居、汽车电子、无人机、工业自动化、医疗仪器、航空航天等等。

   五、总结一下

   软件工程（嵌入式方向）= 软件编程的思维 + 硬件电子的动手能力。

   它不是一个纯虚拟的编程世界，而是一个能让你写的每一行代码，都直接在物理世界中产生效果的非常有成就感的领域。

   ---

   嵌入式的学习资源还是太少了，我下面再补充一些学习资源吧，虽然我不是嵌入式开发的，但我也了解一点并且search到了一些比较好的资源，分享给大家~

   六、嵌入式学习资源推荐

   1、书籍教材(虽然但是，建议想清楚再决定，不要买了就不看了，或者直接看视频，看技术文档，电子版的)

   学习阶段	推荐书籍	推荐理由
   入门基础	《C Primer Plus》	嵌入式开发的“圣经”，讲解细致，实例丰富，能帮你彻底吃透C语言的指针、内存管理等核心知识点。 (C语言建议直接看哔哩哔哩的视频)
   入门基础	《嵌入式系统 - 塑造世界》	以实际硬件平台为依托，通过实验案例讲解I/O接口、中断处理等基础概念，特别适合零基础理解嵌入式系统的核心逻辑。
   硬件基础	《数字电子技术基础》（阎石 著）	电子类专业经典教材，清晰讲解逻辑门、时序电路等内容，帮你看懂硬件电路原理，为读懂芯片手册打下基础。
   进阶提升	《ARM Cortex-M3与Cortex-M4权威指南》	深入讲解主流ARM内核的架构和编程模型，是学习STM32等热门微控制器的核心参考资料。
   进阶提升	《FreeRTOS参考手册》（官方文档）	FreeRTOS官方核心资料，详细介绍任务调度、信号量、消息队列等关键功能，搭配实例可快速上手实时操作系统开发。
   实战精通	《嵌入式Linux开发实战》	聚焦嵌入式Linux的系统构建与驱动开发，适合想向Linux嵌入式方向进阶的学习者，内容贴合工业级开发需求。

   2、开源项目与实战平台

   • 0voice/embedded_software_learn (GitHub)

   • 如果访问GitHub速度慢，可以访问GitCode这个
     非常适合初学者的开源仓库，将学习路径拆分为C语言基础、驱动开发、RTOS、嵌入式Linux等9个模块，每个模块都有中文文档和示例代码，还包含面试题总结，适配电赛、毕设和求职等多种场景。

   • Awesome-Embedded (GitCode)
     汇总了嵌入式开发的经典资源，涵盖书籍、工具和项目案例，可通过该仓库快速找到不同阶段的学习素材。

   • 普中科技51单片机开发板
     入门硬件的高性价比选择，配套教程和例程丰富，能完成点亮LED、串口通信等基础实验，帮助新手建立硬件操作的直观认知。

   • STM32F103开发板
     嵌入式进阶的主流硬件，网上有大量HAL库教程和实战项目（如智能小车、环境监测站），适配从裸机开发到RTOS移植的全流程学习。

   3、在线课程与社区

   • STM32开发指南 —— 面向IoT领域（这个也不错）

   • bilibili上找嵌入式相关的视频
     有许多专业的嵌入式开发视频，讲解原理、实操项目，适合系统学习和项目实践。

   • CSDN 嵌入式板块(不过有一说一，csdn现在不怎么样了，和GitHub比起来格局小了)
     有大量开发者分享的实战笔记、问题排查经验，比如驱动调试、开发板踩坑等内容，遇到硬件或代码问题时可快速检索解决方案。

   • 知乎 嵌入式话题圈
     能获取行业动态和职业规划建议，还有资深工程师分享的学习路径，适合了解嵌入式在智能家居、汽车电子等领域的实际应用场景。

   End

   以下是你们舒学姐提供的图片

   ]]> https://www.furinaluna.top/posts/3643abdf.html 2025-11-24T10:32:37.000Z

   前言：以下是我和工作室的舒学姐总结的嵌入式学习路线，希望对大家有所帮助。欢迎大家补充和指正

   ---

   软件工程嵌入式方向学习总结

   2026-09-11T13:48:57.191Z Furina

   持续更新中

   ---

   1基础模板

   不一定用这个，看题目需要。

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

   #include <bits/stdc++.h> #define endl '\n' using ll=long long;//定义long long为ll using namespace std; void solve() { // 解题 } signed main() { ios::sync_with_stdio(false); cin.tie(0);//关闭cin同步，提高效率 cout.tie(0);//关闭cout同步，提高效率 int t = 1; cin >> t; // 单测则注释 while (t--) solve(); return 0; }

   ]]> https://www.furinaluna.top/posts/d097ebe.html 2025-11-21T07:04:13.000Z

   持续更新中

   ---

   1基础模板

   不一定用这个，看题目需要。

   ✨必学 ✅推荐 ❌不推荐 大纲 1.前言 - 学编程需要的特质 2.前端学习七阶段 1.前端入门 2.巩固基础 3.前端工程化 4.前端优化 5.前端生态 6.前端求职 7.前端未来 3.尾声-持续学习 前言 - 学编程需要的特质 不怕秃头 相信自己有能力，你要知道，现在的所有技术都是人发明的，理论上讲，只要你可以一直学习，就可以掌握所有的技术，换句话说，你可以成为一个技术大牛。但是，你需要有以下特质： 兴趣 坚持 付出 心态 一、前端入门 描述：学习前端基础三件套，建议从实战开始，边学边练，培养兴趣，快速入门。 （前端的前期阶段和后端比起来应该更简单，因为入门很快，正反馈比较快，你认真学基本可以快速地掌握前端基础，做出一些好看的静态页面，增加你的自信心。后期的话也不难，只要你不当摆子，It行业忌讳的就是不持续学习） 资源： MDN W3Cschool中文网 pink老师前端入门教程 阿里云前端实战学习 b站上门各种视频等等 目标:了解和实践各语言的基本语法，可以使用开发工具来独立开发一个留言板网站。 开发工具 描述：工欲善其事，必先利其器。 浏览器 ✨Chrome（推荐，不过可能要做一些配置，国内访问会被墙，直接用代理或者Edge就可以了） ✅Firefox ✅Edge ❌Opera Safari 编辑器 ✨VS Code ✅WebStorm Atom Sublime Text HbuilderX ❌记事本 在线IDE 文档笔记 ✨Markdown ✨Typora 在线笔记: 语雀 腾讯文档 石墨文档 等等 ✨HTML 描述：HTML是超文本标记语言，用于创建网页的结构。 资源： MDN HTML 文档 ✨基本语法 ✨标签 分区 div 标题 h1~h6 段落 p 超链接 a 图片 img 列表 ul/ol 表格 table 表单 form 其他标签 span、strong、em、br、hr等 ✅HTML5新特性 语义化标签 article、section、nav、aside、header、footer等 浏览器支持 多媒体标签 audio、video等 Canvas 画布 ❌SVG 矢量图 本地存储 localStorage sessionStorage ❌Web SQL Web Workers 应用缓存(Cache Manifest) 无障碍等等 ✨CSS 描述：CSS是层叠样式表，用于描述网页的外观和布局。 资源： MDN CSS 文档 ✨基本语法 ✨引入方式 行内样式 内部样式表 外部样式表 ✨选择器 通用选择器 * 标签选择器 id选择器 #id 类选择器 .class 属性选择器 [attr] 派生选择器 子选择器 > 后代选择器 “空格” 相邻兄弟选择器 + 通用兄弟选择器 ~ 组合选择器 逗号选择器 , 并集选择器 伪类选择器 链接伪类 :link 动态伪类 :active 静态伪类 :hover 其他伪类 :first-child、:last-child、:nth-child(n)、:nth-last-child(n) 选择器优先级 内联样式 > ID选择器 > 类选择器 = 属性选择器 = 伪类选择器 > 标签选择器 > 通配符选择器（一般而言） ✨属性 单位 像素 px 相对单位 em、rem、% 视口单位 vw、vh 背景 文本 字体 列表 表格 ✨文档流 标准流 浮动流 定位流 ✨内联元素/块级元素/行内块元素 ✨盒子模型 content(内容) padding(内边距) border(边框) margin(外边距) ✨浮动 设置浮动 float 清除浮动 clear ✨定位 静态定位 static 绝对定位 absolute 相对定位 relative 固定定位 fixed 粘性定位 sticky ✨层叠规则 BFC和IFC机制 CSS3新特性 盒子阴影 box-shadow 圆角 border-radius 渐变 过渡 transition 动画 animation 2D/3D转换 transform ✨响应式布局 媒体查询 Flex布局 Grid布局 瀑布流 ✨JavaScript （就是Java脚本，不过是弱类型语言）,学过一门编程语言很好理解，很快就可以学完 描述:具有函数优先的轻量级，解释性或即时编译型的编程语言 资源： MDN JavaScript 文档 wangdoc ✨基本语法 ✨数据类型 值类型 字符串 String 数字 Number 布尔值 Boolean 空值 Null 未定义 Undefined 符号 Symbol 引用类型 对象 Object 数组 Array 函数 Function ✅数据类型转换 ✅函数 ✨概念 ✨自定义函数 调用方式 ✨全局调用 构造函数调用 ✨函数方法调用 apply() 调用 call() 调用 bind() 调用 ✨闭包 ✨对象 概念 this 原型链和继承 常用的对象 数组 Array 字符串 String 日期 Date 正则表达式 RegExp 数学 Math 全局对象 window 事件对象 Event 错误对象 Error 自定义对象 ✨作用域(简单记忆：一个大括号就是一个作用域) ✨BOM API ✨DOM API ✨JSON ✨AJAX JavaScript 执行机制 ✨ES6+特性 描述：ES6是ECMAScript 2015的简称，是JavaScript的一个版本，引入了许多新的语法和特性。 资源 阮一峰的ES6入门 官方镜像 ES6 标准中文文档 ✨let和const ✨箭头函数 ✨模板字符串 ✨解构赋值 ✨Symbol ✨Set和Map数据结构 ✨Promise & async/await异步编程 ✨Proxy代理 Generator函数异步编程 ✨TypeScript(有时间可以学，直接学框架也行) 描述：TypeScript是JavaScript的一个超集，添加了静态类型检查和其他一些特性。 资源： TypeScript 二、巩固基础（日积月累） （这部分内容比较多，建议是日积月累，平时专业课到后面也会学到，追求速度可以先去学框架了。但是✨JavaScript一定要学好，尤其是✨ES6+特性，不然看不懂后面的框架的） 描述：学习前端、计算机、软件开发相关基础知识，并且巩固上阶段学的前端三件套。 📌目标:熟悉前端三件套语法，尤其是JS,并了解互联网、域名、浏览器、服务器等等，我觉得至少要了解这些，开发方向的程序员怎么样都要了解一些，以后从事这个行业少不了和这些打交道 基础知识(先有个印象) ✅互联网 ✨协议 ✨域名 ✨服务器 ✨DNS ✅浏览器（面试重点） 浏览器DOM事件流/事件委托 ✨浏览器渲染机制 ✨浏览器加载顺序 ✨浏览器事件循环 浏览器同源策略 跨域解决方案 浏览器缓存机制 控制台 console.log() 调试工具（浏览器开发者工具） ✅HTTP HTTP请求 HTTP协议 HTTP请求类别 常见的状态码 1xx 信息性状态码 2xx 成功状态码 3xx 重定向状态码 4xx 客户端错误状态码 5xx 服务器错误状态码 WebSocket Cookie Session HTTPS 计算机基础(其实基本上就是408考研的内容) ✅数据结构与算法 ✨时间、空间复杂度 数据结构 ✨数组 ✨链表 ✨栈 ✨队列 ✨树 ✨图 ✨哈希表 算法 ✨排序 ✨双指针 ✨查找 ✨分治 ✨动态规划（DP） ✨递归 ✨回溯 ✨贪心 ✨位运算 ✨DFS（深度优先搜索） ✨BFS（广度优先搜索） ✨图论 ✅计算机网络 ✨协议 ✨IP地址 ✨端口号 ✨TCP/UDP ✨HTTP/HTTPS ✨DNS ✨路由 ✨交换机 ✨路由器 ✨防火墙 ✅操作系统 进程、线程 进程/线程之间的通讯方式 进程调度算法 进程/线程状态 死锁 内存管理 软件开发基础（大三软考也会考到） ✅软件设计模式 单例模式 代理模式 工厂模式 装饰着模式 观察者模式 策略模式 门面模式 ✨Git版本控制 这个更是重量级的内容，建议是日积月累，不用去背，用到多查文档，用得多了就记住了。 资源： Git教程 Git命令参考 常用的命令 git init git clone git add git commit git push git pull git branch git checkout git merge ✅Linux服务器 常用的命令 ✅正则表达式(Java和JavaScript有) 三、前端工程化 描述：前端工程化是使用软件工程的技术和方法来进行掐断的开发流程、技术、工具、经验等的规范化和标准化，以提高开发效率、代码质量和可维护性，减少不必要的重复工作时间。 看这篇文章，了解什么是前端工程化 目标:至少学会一门主流的前端开发框架（如React、Vue、Angular等），并配合脚手架、组件库、工具等从0开始搭建并开发一个完整的前端网站，可以试着模仿一些知名的站点。要求遵循企业开发规范，将项目代码提交到代码仓库中，斌且独立发布到线上，供他人访问。此外，建议要多找机会组织和参与一些团队开发的项目，如果你将来要从事开发，这几乎是必备的技能，一个人的社交能力在工作还是生活还是学习都是非常重要的。要多加练习。 研发大致流程 需求分析 技术选型 初始化(广义的，包括工作的分配) 开发 本地测试 代码提交 编译、打包、构建 部署 集成测试 发布上线 监控运维 代码托管 描述:集中存储、备份你的代码，还能和团队成员协作开发。 ✨GitHub 这个也是重量级，程序员不会这个，那属实是太难了。 资源 GitHub官方网站 GitHub官方文档 Gitee(国内的，和GitHub类似，更快) 资源 Gitee官方网站 Gitee官方文档 GitLab ✨Node.JS 描述：一个开源与跨平台的JavaScript运行时环境,非常流行！ 资源 Node.js官方网站 Node.js中文网 ✨包管理 描述：用于安装Node.js的扩展、工具等。 ✨npm ✨yarn ✨pnpm ❌bower ✅npx ✨前端开发框架 描述：用于快速构建前端应用的开发框架，提供了组件化、路由、状态管理等功能，帮助开发者更高效地开发前端应用。 CSS框架 ✅Bootstrap 资源 Bootstrap官方网站 Bootstrap中文网 ✨Tailwind CSS 资源 Tailwind CSS官方网站 Tailwind CSS中文网 JavaScript框架 ✨Vue（大厂，中小厂） 资源 Vue官方网站 Vue中文网 ✅Vue 2 ✨Vue 3 ✨React（大厂） 资源 React官方网站 React中文网 ❌Angular Svelte UmiJS 封装库 ✨组件库 ✨Element UI(Vue) 资源 Element UI官方网站 Element UI中文网 ✨Ant Design (React) 资源 Ant Design官方网站 Ant Design中文网 ✅LayUI ✅VantUI(Vue) MaterialUI 数据可视化 ✨ECharts(大屏) Highcharts D3.js ✅ AntV 组件(插件) 富文本编辑器 弹窗 ✨轮播图 工具库 ✨Axios() 这个非常重要 资源 Axios官方网站 Axios中文网 Lodash Moment.js Day.js 时间处理Moment.js 动效库 ✅Animate.css Ant Motion 字体图标库 ✨Iconfont IconPark ✅FontAwesome 脚手架 描述：用于快速生成新项目的目录模板，提升开发效率和开发舒适性 Vue CLI 资源 Vue CLI官方网站 Vue CLI中文网 ✨Vite（打包工具） 资源 Vite官方网站 Vite中文网 ✨前端架构设计 描述：一系列工具和流程的集合，旨在提升前端代码的质量，并实现高效可持续的工作流 模块化 组件化 MVVM架构 设计原则 ✨SPA单页面应用 ✨多页应用 ✨前端路由 PWA 有损服务 ✅服务端渲染 描述：在服务器端渲染HTML页面，将动态生成的内容发送给客户端，而不是在客户端使用JavaScript渲染。 资源 服务端渲染官方网站 服务端渲染中文网 服务端渲染-知乎 Next.js(React) Nuxt.js(Vue) ❌Universal(Angular) ✨CSS预编译 描述：用新的扩展语言以增强CSS的能力，并通过预编译的方式将其转换为浏览器认识的CSS代码。 ✨Sass 资源 Sass官方网站 Sass中文网 Less Stylus 部署 ✨Web服务器 ✨Nginx 描述：一个高性能的HTTP服务器和反向代理服务器，常用于部署静态网站和动态应用。 资源 Nginx官方网站 Nginx中文网 反向代理 解决跨域问题 改写请求头 Apache 容器 Docker 描述：容器是一个标准化软件单元，将代码及其所有依赖打包在一起，以便于在任何环境中运行。Docker容器镜像是一个轻量的独立的可执行包，包含运行应用程序所需的所有内容，包括代码、运行时、系统工具、系统库和设置。 资源 Docker官方网站 Docker中文网 Docker从入门到实践 Kubernetes 四、前端优化 描述：通过优化前端代码和资源，提升页面加载速度、用户体验和搜索引擎排名。 目标：实践前端优化方法，优化自己做过的项目 待更新 五、前端生态 描述：前端技的领域越来越广，有非常多前端工程师需要了解和关注的技术。 目标：用用学到的技术，做更多事情，如开发文档网站，小程序,APP等等。 待更新 六、前端求职 待更新 七、前端未来 描述：前端技术在不断发展，有很多新的技术和工具出现。前端工程师需要保持学习和跟进，以跟上技术的发展。 目标：关注前端技术的最新动态，学习新的技术和工具，提升自己的技能。 未来的路一定充满光明 ]]> https://www.furinaluna.top/posts/e5cf9037.html 2025-11-20T06:37:38.000Z ✨必学 ✅推荐 ❌不推荐 大纲 1.前言 - 学编程需要的特质 2.前端学习七阶段 2026-09-11T13:48:57.171Z Furina 有序数列查找特定大小数的算法：二分查找（Binary Search） 凸函数或者凹函数寻找极值的算法：三分查找（Ternary Search） 二分查找 分析 以递增数组为例，将其分为两半。若中间值大于要找的数，说明要找的数在左边一半；若中间值小于要找的数，说明要找的数在右边一半。不断将范围缩小一半，直到找到要找的数。 时间复杂度：O(log n) （n为数据规模） 代码实现 整数 查找 $\geq$ x的第一个数： （将 if (a[mid] $\geq$ x) 改为 if (a[mid] > x) ，可查找 > x的第一个数） 1 2 3 4 5 6 7 8 9 10 11 // a[ ]为储存数据的有序递增数组 // l ~ r为二分查找的数组范围 int l = 0, r = n - 1; while (l < r) { int mid = (l + r) / 2; if (a[mid] >= x) r = mid; else l = mid + 1; } 查找 $\leq$ x的最后一个数： （将 if (a[mid] $\leq$ x) 改为 if (a[mid] < x) ，查找 < x的最后一个数） 易错点：此时 mid为（l+r+1）/2，若忘记 “+1” ，将会死循环。 1 2 3 4 5 6 7 8 9 10 11 // a[ ]为储存数据的有序递增数组 // l ~ r为二分查找的数组范围 int l = 0, r = n - 1; while (l < r) { int mid = (l + r + 1) / 2; if (a[mid] <= x) l = mid; else r = mid - 1; } 实数 查找满足一定条件的实数：（即以下代码令 check(x) == true 的 x） 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 // check(int x): 判断x是否满足条件 // eps: 精度（因为浮点数误差，不可直接比大小） // BEGIN: 查找左边界 // END: 查找右边界 bool check(int x); double eps = 1e-6; double l = BEGIN, r = END; while (r - l > eps) { double mid = (l + r) / 2; if (check(mid)) l = mid; else r = mid; } 三分查找 分析 将数组分为三份，分别对应数组的左中右三个位置。若左中右三个位置的函数值在同一侧，则将数组缩小到左中右三个位置；若左中右三个位置的函数值在不同侧，则将数组缩小到中间两个位置。不断缩小数组范围，直到找到极值。 时间复杂度：O(log n) （n为数据规模） 代码实现 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 // f(double x): 给定区间内的凹函数或凸函数 // eps: 精度（因为浮点数误差，不可直接比大小） // BEGIN: 查找左边界 // END: 查找右边界 double f(double x); double eps = 1e-6; double l = BEGIN, r = END; while(r - l > eps) { double m1 = l + (r - l) / 3, m2 = r - (r - l) / 3; if(f(m1) > f(m2)) // 此为找最小值，若要找最大值，则改为< l = m1; else r = m2; } ]]> https://www.furinaluna.top/posts/f0faee69.html 2025-11-17T04:44:59.000Z 有序数列查找特定大小数的算法：二分查找（Binary Search） 凸函数或者凹函数寻找极值的算法：三分查找（Ternary Search） 二分查找 ]]> 2026-09-11T13:48:57.151Z Furina 提升效率的快速幂运算 快速幂 时间复杂度 O(log_2 n) (n为幂次) 代码实现 1 2 3 4 5 6 7 8 9 10 11 12 long long fastpow(long long a, long long b) { long long ans = 1; while (b) { if (b % 2 == 1) ans = ans * a; a = a * a; b >>= 1; } return ans; } 变体-大数取模 一般能用到快速幂算法的，答案都会非常巨大，肯定是超出已有数据类型范围的，所以题目一般会说答案对某个数字取模。快速幂可以完成这个操作，只需要进行很小的修改。 时间复杂度 O(log_2 n) (n为幂次) 代码实现 1 2 3 4 5 6 7 8 9 10 11 12 13 long long fastpow(long long a, long long b, long long mod) { a %= mod;//开头先取一次模 long long ans = 1; while (b) { if (b % 2 == 1) ans = ans * a % mod;//每次运算都取模 a = a * a % mod;//每次运算都取模 b >>= 1; } return ans; } 例题 P1226 【模板】快速幂||取余运算 ]]> https://www.furinaluna.top/posts/716f5d8f.html 2025-11-17T01:41:17.000Z 提升效率的快速幂运算 快速幂 时间复杂度 O(log_2 n) (n为幂次) 代码实现 2026-09-11T13:48:57.195Z Furina C++ 标准模板库 (STL, Standard Template Library)：包含一些常用数据结构与算法的模板的 C++ 软件库。其包含四个组件——算法 (Algorithms)、容器 (Containers)、仿函数 (Functors)、迭代器 (Iterators). 示例： 算法：sort(a.begin(), a.end()) 容器：priority_queue pque 仿函数：greater() 迭代器：vector::iterator it = a.begin() 1 前言 STL 作为一个封装良好，性能合格的 C++ 标准库，在算法竞赛中运用极其常见。灵活且正确使用 STL 可以节省非常多解题时间，这一点不仅是由于可以直接调用，还是因为它封装良好，可以让代码的可读性变高，解题思路更清晰，调试过程 往往 更顺利。 不过 STL 毕竟使用了很多复杂的结构来实现丰富的功能，它的效率往往是比不上自己手搓针对特定题目的数据结构与算法的。因此，STL 的使用相当于使用更长的运行时间换取更高的编程效率。因此，在实际比赛中要权衡 STL 的利弊，不过这一点就得靠经验了。 接下来，我会分享在算法竞赛中常用的 STL 容器和算法，对于函数和迭代器，就不着重展开讲了。 2 常用容器 2.1 内容总览 打勾的是本次将会详细讲解的，加粗的是算法竞赛中有必要学习的。 2.1.1顺序容器 [ ] array [x] vector [ ] deque [ ] forward_list [ ] list 2.1.2 关联容器 [x] set [x] map [ ] multiset [ ] multimap 2.1.3 无序关联容器 [ ] unordered_set [ ] unordered_map [ ] unordered_multiset [ ] unordered_multimap 2.1.4 容器适配器 [x] stack [x] queue [x] priority_queue [ ] flat_set [ ] flat_map [ ] flat_multiset [ ] flat_multimap 2.1.5 字符串 [x] string (basic_string<char>) 2.1.6 对与元组 [x] pair [ ] tuple 2.2 向量 vector #include <vector> 连续的顺序的储存结构（和数组一样的类别），但是有长度可变的特性。 2.2.1 常用方法 构造 vector<类型> arr(长度, [初值]) 时间复杂度：O(n)： 常用的一维和二维数组构造示例，高维也是一样的（就是会有点长）. 1 2 3 4 vector<int> arr(100); // 构造初始长100的int数组 vector<int> arr(100, 1); // 构造初始长100的int数组，初值为1 vector<vector<int>> mat(100, vector<int> ()); // 构造初始100行，不指定列数的二维数组 vector<vector<int>> mat(100, vector<int> (666, -1)) // 构造初始100行，初始666列的二维数组，初值为-1 构造二维数组的奇葩写法，千万别用： 1 2 3 4 vector<int> arr[100]; // 正确，构造初始100行，不指定列数的二维数组，可用于链式前向星存图 vector<int> arr[100](100, 1); // 语法错误！ vector<int> arr(100, 1)[100]; // 语法错误！ vector<int> arr[100] {{100, 1}, 这里省略98个 ,{100, 1}}; // 正确但奇葩，使用列表初始化 尾接 & 尾删 .push_back(元素)：在 vector 尾接一个元素，数组长度 . .pop_back()：删除 vector 尾部的一个元素，数组长度 时间复杂度：均摊 O(1) 1 2 3 4 5 6 7 8 9 // init: arr = [] arr.push_back(1); // after: arr = [1] arr.push_back(2); // after: arr = [1, 2] arr.pop_back(); // after: arr = [1] arr.pop_back(); // after: arr = [] 中括号运算符 和一般数组一样的作用 时间复杂度：O(1) 获取长度 .size() 获取当前 vector 的长度 时间复杂度：O(1) 1 2 for (int i = 0; i < arr.size(); i++) cout << a[i] << endl; 清空 .clear() 清空 vector 时间复杂度：O(n) 判空 .empty() 如果是空返回 true 反之返回 false. 时间复杂度：O(1) 改变长度 .resize(新长度, [默认值]) 修改 vector 的长度 如果是缩短，则删除多余的值 如果是扩大，且指定了默认值，则新元素均为默认值 (旧元素不变) 时间复杂度：O(n) 2.2.2 适用情形 一般情况 vector 可以替换掉普通数组，除非该题卡常。有些情况普通数组没法解决：n×m的矩阵，1<=n,m<=10^6^，且 n×m<=10^6^. 如果用普通数组 int mat[1000010][1000010]，浪费内存，会导致 MLE。 如果使用 vector<vector<int>> mat(n + 10, vector<int> (m + 10))，完美解决该问题。 另外，vector的数据储存在堆空间中，不会爆栈。 2.2.3 注意事项 提前指定长度 如果长度已经确定，那么应当直接在构造函数指定长度，而不是一个一个 .push_back(). 因为 vector 额外内存耗尽后的重分配是有时间开销的，直接指定长度就不会出现重分配了。 1 2 3 4 5 6 7 vector<int> a; for (int i = 0; i < 1e8; i++) a.push_back(i); // 优化后: 259ms vector<int> a(1e8); for (int i = 0; i < a.size(); i++) a[i] = i; 当心 size_t 溢出 vector 获取长度的方法 .size() 返回值类型为 size_t，通常 OJ 平台使用的是 32 位编译器（有些平台例如 cf 可选 64 位），那么该类型范围为 [0 , 2^32^) 1 2 vector<int> a(65536); long long a = a.size() * a.size(); // 直接溢出变成0了 2.3 栈 stack #include <stack> 通过二次封装双端队列 (deque) 容器，实现先进后出的栈数据结构。 2.3.1 常用方法 作用 用法 示例 构造 stack<类型> stk stack<int> stk; 进栈 .push(元素) stk.push(1); 出栈 .pop() stk.pop(); 取栈顶 .top() int a = stk.top(); 查看大小/清空/判空 .size()/.clear()/.empty() 略 2.3.2 适用情形 如果不卡常的话，就可以直接用它而不需要手写栈了。另外，vector也可以当栈用： vector.back() 取尾部元素 → 栈顶 vector.push_back() → 进栈 vector.pop_back() → 出栈 2.3.3 注意事项 不可访问内部元素！下面是错误用法 1 2 3 4 5 for (int i = 0; i < stk.size(); i++) cout << stk[i] << endl; for (auto ele : stk) cout << ele << endl; 2.4 队列 queue #include <queue> 通过二次封装双端队列 (deque) 容器，实现先进先出的队列数据结构。 2.4.1 常用方法 作用 用法 示例 构造 queue<类型> que queue que; 进队 .push(元素) que.push(1); 出队 .pop() que.pop(); 取队首 .front() int a = que.front() 取队尾 .back() int a = que.back() 2.4.2 适用情形 如果不卡常的话，就可以直接用它而不需要手写队列了。 2.4.3 注意事项 不可访问内部元素！下面都是错误用法 1 2 3 4 5 for (int i = 0; i < que.size(); i++) cout << que[i] << endl; for (auto ele : que) cout << ele << endl; 2.5 优先队列 priority_queue #include <queue> 提供常数时间的最大元素查找，对数时间的插入与提取，底层原理是二叉堆。 2.5.1 常用方法 构造 构造priority_queue<类型, 容器, 比较器> pque 类型：要储存的数据类型 容器：储存数据的底层容器，默认为vector<类型>，竞赛中保持默认即可 比较器：比较大小使用的比较器，默认为 less<类型>，可自定义 1 2 priority_queue<int>pque1; // 储存int的大顶堆 priority_queue<int, vector<int>, greater<int>> pque2; // 储存int的小顶堆 对于需要自定义比较器的情况，涉及一些初学时容易看迷糊的语法（重载小括号运算符 / lambda 表达式），在此就不展开讲了。如果想要了解，可以查阅 cppreference 中的代码示例。 其他 作用 用法 示例 进堆 .push(元素) que.push(1); 出堆 .pop() que.pop(); 取堆顶 .top() int a = que.top(); 查看大小 / 判空 略 略 进出队复杂度为 O(logn),取堆顶复杂度为 O(1) 2.5.2 适用情形 持续维护元素的有序性：每次向队列插入大小不定的元素，或者每次从队列里取出大小最小/最大的元素，元素数量 n ，插入操作数量 k 每次插入后进行快速排序：k*nlogn 使用优先队列维护：k*logn 2.5.3 注意事项 仅堆顶可读,只可访问堆顶，其他元素都无法读取到。下面是错误用法 cout << pque[1] << endl; 所有元素不可写 堆中所有元素是不可修改的。下面是错误用法： 1 pque.top() = 1; 如果你恰好要修改的是堆顶元素，那么是可以完成的： 1 2 3 int tp = pque.top(); pque.pop(); pque.push(tp + 1); 2.6 集合 set #include <set> 提供对数时间的插入、删除、查找的集合数据结构。底层原理是红黑树。 集合三要素 解释 set multiset unordered_set 确定性 一个元素要么在集合中，要么不在 ✔ ✔ ✔ 互异性 一个元素仅可以在集合中出现一次 ✔ ❌（任意次） ✔ 无序性 集合中的元素是没有顺序的 ❌（从小到大） ❌（从小到大） ✔ 2.6.1 常用方法 构造 set<类型, 比较器> st 类型：要储存的数据类型 比较器：比较大小使用的比较器，默认为 less<类型>，可自定义 1 2 set<int> st1; // 储存int的集合（从小到大） set<int, greater<int>> st2; // 储存int的集合（从大到小） 对于需要自定义比较器的情况，涉及一些初学时容易看迷糊的语法（重载小括号运算符 / lambda 表达式），在此就不展开讲了。 遍历 可使用迭代器进行遍历： 1 2 for (set<int>::iterator it = st.begin(); it != st.end(); ++it) cout << *it << endl; 基于范围的循环（C++ 11）： 1 2 for (auto &ele : st) cout << ele << endl; 其他 作用 用法 示例 插入元素 .insert(元素) st.insert(1); 删除元素 .erase(元素) st.erase(2); 查找元素 .find(元素) auto it = st.find(1); 判断元素是否存在 .count(元素) st.count(3); 查看大小 / 清空 / 判空 略 略 增删查时间复杂度均为 O(logn) 2.6.2 适用情形 元素去重：[1,1,3,2,4,4]->[1,2,3,4] 维护顺序：[1,3,7,2,5,4,6]->[1,2,3,4,5,6,7] 元素是否出现过：元素大小 [-10^18^,10^18^]，元素数量 10^6^，vis 数组无法实现，通过 set 可以完成。 2.6.3 注意事项 不存在下标索引** set 虽说可遍历，但仅可使用迭代器进行遍历，它不存在下标这一概念，无法通过下标访问到数据。下面是错误用法： cout << st[0] << endl; 元素只读 set 的迭代器取到的元素是只读的（因为是 const 迭代器），不可修改其值。如果要改，需要先 erase 再 insert. 下面是错误用法： 1 2 cout << *st.begin() << endl; // 正确。可读。 *st.begin() = 1; // 错误！不可写！ 不可用迭代器计算下标 set 的迭代器不能像 vector 一样相减得到下标。下面是错误用法： 1 2 auto it = st.find(2); // 正确，返回2所在位置的迭代器。 int idx = it - st.begin(); // 错误！不可相减得到下标。 2.7 映射 map #include <map> 提供对数时间的有序键值对结构。底层原理是红黑树。 映射：键值对的集合，键是唯一的，值可以重复。 例如： 1->2 2->3 3->4 性质 解释 map multimap unordered_map 互异性 一个键仅可以在映射中出现一次 ✔ ❌（任意次） ✔ 无序性 键是没有顺序的 ❌（从小到大） ❌（从小到大） ✔ 2.7.1 常用方法 构造 map<键类型, 值类型, 比较器> mp 键类型：要储存键的数据类型 值类型：要储存值的数据类型 比较器：键比较大小使用的比较器，默认为 less<类型>，可自定义 1 2 map<int, int> mp1; // int->int 的映射（键从小到大） map<int, int, greater<int>> st2; // int->int 的映射（键从大到小） 对于需要自定义比较器的情况，涉及一些初学时容易看迷糊的语法（重载小括号运算符 / lambda 表达式），在此就不展开讲了。类似于前端的箭头函数。学过前端都知道，斯，学Java的应该更知道，所以还是去学一下吧,qwq. 遍历 可使用迭代器进行遍历： 1 2 for (map<int, int>::iterator it = mp.begin(); it != mp.end(); ++it) cout << it->first << ' ' << it->second << endl; 基于范围的循环（C++ 11）： 1 2 3 4 5 6 for (auto &pr : mp) cout << pr.first << ' ' << pr.second << endl; 结构化绑定 + 基于范围的循环（C++17）： for (auto &[key, val] : mp) cout << key << ' ' << val << endl 其他 作用 用法 示例 增 / 改 / 查元素 中括号 mp[1] = 2; 查元素（返回迭代器） .find(元素) auto it = mp.find(1); 删除元素 .erase(元素) mp.erase(2); 判断元素是否存在 .count(元素) mp.count(3); 查看大小 / 清空 / 判空 略 略 增删改查时间复杂度均为 O(logn) 2.7.2 适用情形 需要维护映射的场景可以使用：输入若干字符串，统计每种字符串的出现次数。(map<string, int> mp) 2.7.3 注意事项 中括号访问时默认值 如果使用中括号访问 map 时对应的键不存在，那么会新增这个键，并且值为默认值，因此中括号会影响键的存在性。 1 2 3 4 5 map<char, int> mp; cout << mp.count('a') << endl; // 0 mp['a']; // 即使什么都没做，此时mp['a']=0已经插入了 cout << mp.count('a') << endl; // 1 cout << mp['a'] << endl; // 0 不可用迭代器计算下标 map 的迭代器不能像 vector 一样相减得到下标。下面是错误用法： 1 2 auto it = mp.find('a'); // 正确，返回2所在位置的迭代器。 int idx = it - mp.begin(); // 错误！不可相减得到下标。 2.8 字符串 string #include <string> 顾名思义，就是储存字符串的。 2.8.1 常用方法 构造 构造函数：string(长度, 初值) 1 2 3 string s1; // 构造字符串，为空 string s2 = "awa!"; // 构造字符串，并赋值awa! string s3(10, '6'); // 构造字符串，通过构造函数构造为6666666666 输入输出 C++ 1 2 3 string s; cin >> s; cout << s; C 1 2 3 4 5 6 #include <cstdio> string s; char buf[100]; scanf("%s", &buf); s = buf; printf("%s", s.c_str()); 其他 作用 用法 示例 修改、查询指定下标字符 [] s[1] = ‘a’; 是否相同 == if (s1 == s2) … 字符串连接 + string s = s1 + s2; 尾接字符串 += s += “awa”; 取子串 .substr(起始下标, 子串长度) string sub = s.substr(2, 10); 查找字符串 .find(字符串, 起始下标) int pos = s.find(“awa”); 数值与字符串互转（C++11） 源 目的 函数 int / long long / float / double / long double string to_string() string int stoi() string long long stoll() string float stof() string double stod() string long double stold() 2.8.2 适用情形 非常好用！建议直接把字符数组扔了，赶快投入 string 的怀抱。 2.8.3 注意事项 尾接字符串一定要用+= string 的 += 运算符，将会在原字符串原地尾接字符串。而 + 了再 = 赋值，会先生成一个临时变量，在复制给 string. 通常字符串长度可以很长，如果使用 + 字符串很容易就 TLE 了。 1 2 3 4 5 6 7 8 9 // 优化前: 15139ms string s; for (int i = 0; i < 5e5; i++) s = s + "a"; // 优化后: < 1ms (计时器显示0) string s; for (int i = 0; i < 5e5; i++) s += "a"; .substr() 方法的奇葩参数 一定要注意，C++ string 的取子串的第一个参数是子串起点下标，第二个参数是子串长度。 第二个参数不是子串终点！不是子串终点！要与 java 等其他语言区分开来。 .find() 方法的复杂度 该方法实现为暴力实现，时间复杂度为O(n^2^) 不要幻想 STL 内置了个 的 KMP 算法 2.9 二元组 pair #include <utility> 顾名思义，就是储存二元组的。 2.9.1 常用方法 构造 1 pair<第一个值类型, 第二个值类型> pr 第一个值类型：要储存的第一个值的数据类型 第二个值类型：要储存的第二个值的数据类型 1 2 3 4 pair<int, int> p1; pair<int, long long> p2; pair<char, int> p3; // ... 赋值 老式 1 pair<int, char> pr = make_pair(1'a'); 列表构造 C++11 1 pair<int, char> pr = {1, 'a'}; 取值 直接取值 取第一个值：.first 取第二个值：.second 1 2 3 pair<int, char> pr = {1, 'a'}; int awa = pr.first; char bwb = pr.second; 结构化绑定 C++17 1 2 3 pair<int, char> pr = {1, 'a'}; auto &[awa, bwb] = pr; 判同 直接用==运算符 1 2 3 pair<int, int> p1 = {1, 2}; pair<int, int> p2 = {1, 3}; if (p1 == p2) { ... } // false 2.9.2 适用场景 所有需要二元组的场景均可使用，效率和自己定义结构体差不多。 2.9.3 注意事项 无 3 迭代器简介 #include <iterator> 3.1 迭代器是什么？ 迭代器是 STL 中的一种数据结构，它可以帮助我们遍历容器中的元素。 不搞抽象，直接举例。 对于一个 vector，我们可以用下标遍历： 1 2 for (int i = 0; i < a.size(); i++) cout << a[i] << endl; 我们同时也可以用迭代器来遍历： 1 2 for (vector<int>::iterator it = a.begin(); it != a.end(); ++it) cout << *it << endl; a.begin() 是一个迭代器，指向的是第一个元素 a.end() 是一个迭代器，指向的是最后一个元素再后面一位 上述迭代器具有自增运算符，自增则迭代器向下一个元素移动 迭代器与指针相似，如果对它使用解引用运算符，即 *it，就能取到对应值了 3.2 为何需要迭代器？ 很多数据结构并不是线性的（例如红黑树），对于非线性数据结构，下标是无意义的。无法使用下标来遍历整个数据结构。 迭代器的作用就是定义某个数据结构的遍历方式，通过迭代器的增减，代表遍历到的位置，通过迭代器便能成功遍历非线性结构了。 例如，set 的实现是红黑树，我们是没法用下标来访问元素的。但是通过迭代器，我们就能遍历 set 中的元素了： 其实我也不太清楚红黑树，www，彭老师数据结构好像没有太细讲这个，总之会用就行了，不管它的来龙去脉 1 2 for (set<int>::iterator it = st.begin(); it != st.end(); ++it) cout << *it << endl; 3.3 迭代器用法 对于 vector 容器，它的迭代器功能比较完整，以它举例： .begin()：头迭代器 .end()：尾迭代器 .rbegin()：反向头迭代器 .rend()：反向尾迭代器 迭代器 + 整型：将迭代器向后移动 迭代器 - 整型：将迭代器向前移动 迭代器 ++：将迭代器向后移动 1 位 迭代器 --：将迭代器向前移动 1 位 迭代器 - 迭代器：两个迭代器的距离 prev(it)：返回 it 的前一个迭代器 next(it)：返回 it 的后一个迭代器 对于其他容器，由于其结构特性，上面的功能不一定都有（例如 set 的迭代器是不能相减求距离的） 3.4 常见问题 1 .end() 和 1 .rend() 指向的位置是无意义的值 对于一个长度为 10 的数组： 1 for (int i = 0; i < 10; i++) ，第 10 位是不可访问的 对于一个长度为 10 的容器： 1 for (auto it = a.begin(); it != a.end(); ++it) ，.end() 是不可访问的 不同容器的迭代器功能可能不一样 迭代器细化的话有正向、反向、双向，每个容器的迭代器支持的运算符也可能不同，因此不同容器的迭代器细节很有可能是不一样的。 删除操作时需要警惕 建议直接找大佬 建议：如无必要，别用迭代器操作容器。（遍历与访问没关系） 4 常用算法 #include <algorithm> 4.1 内容总览 打勾的是本次将会详细讲解的，其他的是算法竞赛中建议学习的，不在下表列出的在比赛中基本用不到。（很多函数的功能很简单，自己都能快速写出来，但是使用函数可以让代码可读性变得更高，这在比赛中是至关紧要的）反正我不太写得出来，还是太菜了 4.1.1 算法库 Algorithm [ ] count() [ ] find() [ ] fill() [x] swap() [x] reverse() [ ] shuffle() C++11 [x] unique() [x] sort() [x] lower_bound() / upper_bound() [x] max() / min() [ ] max_element() / min_element() [ ] prev_permutation() / next_permutation() 4.1.2 数学函数 cmath [x] abs() [x] exp() [x] log() / log10() / log2() [x] pow() [x] sqrt() [ ] sin() / cos() / tan() [ ] asin() / acos() / atan() [ ] sinh() / cosh() / tanh() [ ] asinh() / acosh() / atanh() C++11 [x] ceil() / floor() [x] round() C++11 4.1.3 数值算法 numeric [ ] iota() C++11 [ ] accumulate() [x] gcd() C++17 [x] lcm() C++17 4.1.4 伪随机数生成 random [ ] mt19937 [ ] random_device() 4.2 swap() 交换两个变量的值 用法示例 1 2 template< class T > void swap( T& a, T& b ); 1 2 3 4 5 6 7 int a = 0, b = 1; swap(a, b); // now a = 1, b = 0 int arr[10] {0, 1, 2, 3, 4, 5, 6, 7, 8, 9}; swap(arr[4], arr[6]); // now arr = {0, 1, 2, 3, 6, 5, 4, 7, 8, 9} 注意事项 这个 swap 参数是引用的，不需要像 C 语言一样取地址。 4.3 sort() 使用快速排序给一个可迭代对象排序 用法示例 1 2 template< class RandomIt, class Compare > void sort( RandomIt first, RandomIt last, Compare comp ); 默认排序从小到大 1 2 3 vector<int> arr{1, 9, 1, 9, 8, 1, 0}; sort(arr.begin(), arr.end()); // arr = [0, 1, 1, 1, 8, 9, 9] 如果要从大到小，则需要传比较器进去。 1 2 3 vector<int> arr{1, 9, 1, 9, 8, 1, 0}; sort(arr.begin(), arr.end(), greater<int>()); // arr = [9, 9, 8, 1, 1, 1, 0] 如果需要完成特殊比较，则需要手写比较器。 比较器函数返回值是 bool 类型，传参是需要比较的两个元素。 注意：如果传的两个参数相等，返回值必须是 false 1 2 3 4 5 6 bool cmp(pair<int, int> a, pair<int, int> b) { if (a.second != b.second) return a.second < b.second; return a.first > b.first; } 1 2 3 4 5 6 int main() { vector<pair<int, int>> arr{{1, 9}, {2, 9}, {8, 1}, {0, 0}}; sort(arr.begin(), arr.end(), cmp); // arr = [(0, 0), (8, 1), (2, 9), (1, 9)] } 4.4 lower_bound() / upper_bound() 在已升序排序的元素中，应用二分查找检索指定元素，返回对应元素迭代器位置。找不到则返回尾迭代器。 lower_bound(): 寻找 的第一个元素的位置 upper_bound(): 寻找 的第一个元素的位置 怎么找 / 的第一个元素呢？ 的第一个元素的前一个元素（如果有）便是 的第一个元素 的第一个元素的前一个元素（如果有）便是 的第一个元素 返回的是迭代器，如何转成下标索引呢？减去头迭代器即可。 用法示例 1 2 template< class ForwardIt, class T > ForwardIt lower_bound( ForwardIt first, ForwardIt last, const T& value ); 1 2 3 vector<int>::iterator it = lower_bound(arr.begin(), arr.end(), 7); int idx = it - arr.begin(); // idx = 4 我们通常写成一行： 1 2 3 4 5 vector<int> arr{0, 1, 1, 1, 8, 9, 9}; idx = lower_bound(arr.begin(), arr.end(), 7) - arr.begin(); // 4 idx = lower_bound(arr.begin(), arr.end(), 8) - arr.begin(); // 4 idx = upper_bound(arr.begin(), arr.end(), 7) - arr.begin(); // 4 idx = upper_bound(arr.begin(), arr.end(), 8) - arr.begin(); // 5 4.5 reverse() 反转一个可迭代对象的元素顺序 用法示例 1 2 template< class BidirIt > void reverse( BidirIt first, BidirIt last ); 1 2 3 4 5 vector<int> arr(10); iota(arr.begin(), arr.end(), 1); // 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 reverse(arr.begin(), arr.end()); // 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 4.6 max() / min() 返回最大值 / 最小值的数值 用法示例 1 2 int mx = max(1, 2); // 2 int mn = min(1, 2); // 1 在 C++11 之后，可以使用列表构造语法传入一个列表，这样就能一次性给多个元素找最大值而不用套娃了： 1 2 3 4 5 6 7 // Before C++11 int mx = max(max(1, 2), max(3, 4)); // 4 int mn = min(min(1, 2), min(3, 4)); // 1 // After C++11 int mx = max({1, 2, 3, 4}); // 4 int mn = min({1, 2, 3, 4}); // 1 4.7 unique() 消除数组的重复相邻元素，数组长度不变，但是有效数据缩短，返回的是有效数据位置的结尾迭代器。 例如：[1,1,4,5,1,4] -> [1,4,5,1,4,_] ，下划线位置为返回的迭代器指向。 1 2 template< class ForwardIt > ForwardIt unique( ForwardIt first, ForwardIt last ); 用法示例 单独使用 unique 并不能达成去重效果，因为它只消除相邻的重复元素。但是如果序列有序，那么它就能去重了。 但是它去重后，序列尾部会产生一些无效数据： [1,1,2,4,4,5,5]->[1,2,4,5,_,_,_]，为了删掉这些无效数据，我们需要结合 erase. 最终，给 vector 去重的写法便是： 1 2 3 vector<int> arr{1, 2, 1, 4, 5, 4, 4}; sort(arr.begin(), arr.end()); arr.erase(unique(arr.begin(), arr.end()), arr.end()); 4.8 数学函数 所有函数参数均支持 int / long long / float / double / long double 公式 示例 f(x)=|x| abs(-1.0) f(x)=e^x^ exp(2) f(x)=ln x log(3) f(x)=x^y^ pow(2, 3) f(x)=√x sqrt(2) f(x)=x(向上取整) ceil(2.1) f(x)=x(向下取整) floor(2.1) f(x)=<x> round(2.1) 注意事项 由于浮点误差，有些的数学函数的行为可能与预期不符，导致 WA。如果你的操作数都是整型，那么用下面的写法会更稳妥。 [原文地址:https://codeforces.com/blog/entry/107717 计算 a/b 取下整 别用：floor(1.0 * a / b) 要用：a / b 计算 a/b 取上整 别用：ceil(1.0 * a / b) 要用：(a + b - 1) / b 计算 a 的平方根取下整 别用：(int) sqrt(a) 要用：二分查找 链接 -> 二分查找 计算 a^b^ 别用：pow(a, b) 要用：快速幂 链接 -> 快速幂运算 计算 log2(a) 别用：log2(a) 要用：__lg （不规范，但是这是竞赛）/ bit_width（C++20 可用） 4.9 gcd() / lcm() （C++17）返回最大公因数 / 最小公倍数 1 2 int x = gcd(8, 12); // 4 int y = lcm(8, 12); // 24 如果不是 C++17，但是是 GNU 编译器（g++），那么可以用内置函数 __gcd(). 当然，gcd / lcm 函数也挺好写，直接写也行（欧几里得算法）： 1 2 3 4 5 6 7 8 9 10 11 int gcd(int a, int b) { if (!b) return a; return gcd(b, a % b); } int lcm(int a, int b) { return a / gcd(a, b) * b; } ]]> https://www.furinaluna.top/posts/d97dbae4.html 2025-11-16T10:42:00.000Z C++ 标准模板库 (STL, Standard Template Library)：包含一些常用数据结构与算法的模板的 C++ 软件库。其包含四个组件——算法 (Algorithms)、容器 (Containers)、仿函数 (Functors)、迭代器 (Iterato]]> 2026-09-11T13:48:57.195Z Furina “当月光洒在键盘上，我知道——今夜，注定无法平凡。” 这不是一篇普通的博文，而是我灵魂燃烧的见证！🔥 就在昨夜，星辰黯淡，网络低语，一场与未知 Bug 的终极对决，在寂静的凌晨悄然展开。无数报错如恶魔低语，No layout 的诅咒回荡在控制台深处……SSL证书拒绝握手，Git克隆失败，npm警告如潮水般涌来！ 但我——从未退却！ 以上内容ai生成 简单来说，我总算是完成了建站部署，虽然是托管到GitHub上面有点慢，找个时间套一个CDN,或者托管到Netlify,或者Vercel,或者Cloudflare上面吧 以后有机会再迁移吧 2025-11-21: 更新了一下，搞了一个域名，然后解析除了几个二级的域名，在cloudflash套cdn，再部署到另一个verel上面，感觉还不错。速度快了很多，移动端也可以访问了。有机会写一篇文章讲讲域名解析，cdn,部署之类的知识吧，初学者搞这个还是有点小复杂的。很多东西需要自己去摸索，慢慢来吧。 ]]> https://www.furinaluna.top/posts/fa05c009.html 2025-11-14T02:36:19.000Z “当月光洒在键盘上，我知道——今夜，注定无法平凡。” 这不是一篇普通的博文，而是我灵魂燃烧的见证！🔥 就在昨夜，星辰黯淡，网络低语，一场与未知 Bug 的终极对决，在寂静的凌晨悄然展开。无数报错如恶魔低语，No layout 的诅]]> 2026-09-11T13:48:57.195Z