Python 实战开发指南

目录

  • 1. 1. Python 核心语法
    • 1.1. 数据模型与魔法方法
      • 1.1.1. 对象标识与相等性
        • 1.1.1.1. 易错点：is vs ==
      • 1.1.2. 可变性与哈希
        • 1.1.2.1. 可变对象不可哈希
        • 1.1.2.2. 字典键必须可哈希
      • 1.1.3. 自定义类的魔法方法
        • 1.1.3.1. __repr__ vs __str__
        • 1.1.3.2. 实现可比较的类
      • 1.1.4. 容器协议
        • 1.1.4.1. 实现自定义序列
      • 1.1.5. 属性访问控制
        • 1.1.5.1. __getattr__ vs __getattribute__
        • 1.1.5.2. 使用 __slots__ 优化内存
      • 1.1.6. 运算符重载
        • 1.1.6.1. 数值运算
      • 1.1.7. 最佳实践总结
    • 1.2. 函数进阶
      • 1.2.1. 参数传递机制
        • 1.2.1.1. 易错点：传值 vs 传引用
      • 1.2.2. *args 和 **kwargs
        • 1.2.2.1. 位置参数与关键字参数
        • 1.2.2.2. 仅位置参数（Python 3.8+）
        • 1.2.2.3. 参数解包
      • 1.2.3. 闭包
        • 1.2.3.1. 闭包原理
        • 1.2.3.2. 易错点：循环中的闭包
      • 1.2.4. 装饰器
        • 1.2.4.1. 基本装饰器
        • 1.2.4.2. 带参数的装饰器
        • 1.2.4.3. 类装饰器
        • 1.2.4.4. 装饰器执行顺序
      • 1.2.5. 函数式编程
        • 1.2.5.1. map, filter, reduce
        • 1.2.5.2. 偏函数
        • 1.2.5.3. operator 模块
      • 1.2.6. 最佳实践
    • 1.3. 面向对象编程
      • 1.3.1. 类与实例
        • 1.3.1.1. 类属性 vs 实例属性
        • 1.3.1.2. 可变类属性陷阱
      • 1.3.2. 继承与组合
        • 1.3.2.1. 方法解析顺序（MRO）
        • 1.3.2.2. 组合优于继承
      • 1.3.3. 属性（Property）
        • 1.3.3.1. 使用 @property 实现访问控制
        • 1.3.3.2. 只读属性
      • 1.3.4. 描述符
      • 1.3.5. 抽象基类
      • 1.3.6. 数据类（Python 3.7+）
      • 1.3.7. 元类
        • 1.3.7.1. 使用 __init_subclass__ 替代简单元类
      • 1.3.8. 最佳实践
    • 1.4. 迭代器与生成器
      • 1.4.1. 迭代协议
        • 1.4.1.1. 可迭代对象 vs 迭代器
        • 1.4.1.2. 自定义迭代器
        • 1.4.1.3. 可重复使用的迭代器
      • 1.4.2. 生成器
        • 1.4.2.1. 基本生成器
        • 1.4.2.2. 生成器 vs 列表的内存对比
        • 1.4.2.3. yield from
        • 1.4.2.4. 生成器的 send 和 throw
      • 1.4.3. itertools 模块
        • 1.4.3.1. 无限迭代器
        • 1.4.3.2. 组合迭代器
        • 1.4.3.3. 过滤和分组
        • 1.4.3.4. 实用工具
      • 1.4.4. 实际应用
        • 1.4.4.1. 分块处理
        • 1.4.4.2. 滑动窗口
        • 1.4.4.3. 管道处理
      • 1.4.5. 最佳实践
    • 1.5. 上下文管理器
      • 1.5.1. 基本概念
        • 1.5.1.1. with 语句原理
      • 1.5.2. 实现上下文管理器
        • 1.5.2.1. 类方式
        • 1.5.2.2. 使用 contextlib
        • 1.5.2.3. 异常处理
      • 1.5.3. 实用上下文管理器
        • 1.5.3.1. 临时修改
        • 1.5.3.2. 数据库事务
        • 1.5.3.3. 锁管理
      • 1.5.4. 多个上下文管理器
        • 1.5.4.1. ExitStack：动态管理多个上下文
      • 1.5.5. 异步上下文管理器
      • 1.5.6. 最佳实践
    • 1.6. 装饰器深入
      • 1.6.1. 装饰器本质
      • 1.6.2. 保持函数元信息
      • 1.6.3. 常见装饰器模式
        • 1.6.3.1. 带参数的装饰器
        • 1.6.3.2. 可选参数的装饰器
        • 1.6.3.3. 带状态的装饰器（类实现）
        • 1.6.3.4. 缓存装饰器
        • 1.6.3.5. 类型检查装饰器
      • 1.6.4. 装饰类
        • 1.6.4.1. 添加方法到类
        • 1.6.4.2. 注册模式
      • 1.6.5. 方法装饰器
        • 1.6.5.1. 静态方法和类方法
        • 1.6.5.2. property 装饰器
      • 1.6.6. 异步装饰器
      • 1.6.7. 装饰器执行顺序
      • 1.6.8. 最佳实践
    • 1.7. 类型提示
      • 1.7.1. 基础类型提示
        • 1.7.1.1. 基本类型
        • 1.7.1.2. 容器类型
      • 1.7.2. Optional 和 Union
      • 1.7.3. Callable 和函数类型
      • 1.7.4. 泛型
        • 1.7.4.1. TypeVar
        • 1.7.4.2. Generic 类
      • 1.7.5. Protocol（结构化子类型）
      • 1.7.6. TypedDict
      • 1.7.7. Literal 和 Final
      • 1.7.8. 实用类型
        • 1.7.8.1. Any、Never、NoReturn
        • 1.7.8.2. Self（Python 3.11+）
        • 1.7.8.3. Annotated
      • 1.7.9. 类型检查工具
        • 1.7.9.1. mypy
        • 1.7.9.2. 配置文件（mypy.ini 或 pyproject.toml）
        • 1.7.9.3. 内联忽略
      • 1.7.10. 最佳实践
    • 1.8. 核心概念速览
      • 1.8.1. 一切皆对象
      • 1.8.2. 动态类型 vs 鸭子类型
    • 1.9. 本章重点
  • 2. 2. 并发异步编程
    • 2.1. GIL 深度解析
      • 2.1.1. 什么是 GIL
      • 2.1.2. GIL 的工作原理
        • 2.1.2.1. GIL 释放时机
      • 2.1.3. GIL 的影响
        • 2.1.3.1. CPU 密集型任务
        • 2.1.3.2. I/O 密集型任务
      • 2.1.4. 绕过 GIL 的方法
        • 2.1.4.1. 1. 多进程
        • 2.1.4.2. 2. 使用释放 GIL 的库
        • 2.1.4.3. 3. Cython 释放 GIL
        • 2.1.4.4. 4. 使用其他 Python 实现
      • 2.1.5. 线程安全的编程
        • 2.1.5.1. 使用锁
        • 2.1.5.2. 使用原子操作
        • 2.1.5.3. threading.local
      • 2.1.6. 最佳实践
      • 2.1.7. Python 3.12+ 的变化
    • 2.2. 多线程编程
      • 2.2.1. 基础使用
        • 2.2.1.1. 创建线程
        • 2.2.1.2. 线程属性
      • 2.2.2. 线程同步
        • 2.2.2.1. Lock（互斥锁）
        • 2.2.2.2. RLock（可重入锁）
        • 2.2.2.3. Semaphore（信号量）
        • 2.2.2.4. Event（事件）
        • 2.2.2.5. Condition（条件变量）
        • 2.2.2.6. Barrier（屏障）
      • 2.2.3. 线程池
      • 2.2.4. 避免死锁
        • 2.2.4.1. 死锁示例
        • 2.2.4.2. 避免死锁的方法
      • 2.2.5. 线程安全的数据结构
      • 2.2.6. 最佳实践
    • 2.3. 多进程编程
      • 2.3.1. 基础使用
        • 2.3.1.1. 创建进程
        • 2.3.1.2. 进程池
        • 2.3.1.3. ProcessPoolExecutor（推荐）
      • 2.3.2. 进程间通信
        • 2.3.2.1. Queue（队列）
        • 2.3.2.2. Pipe（管道）
        • 2.3.2.3. 共享内存
        • 2.3.2.4. Manager（共享复杂对象）
      • 2.3.3. 进程同步
        • 2.3.3.1. Lock 和 RLock
        • 2.3.3.2. Semaphore
        • 2.3.3.3. Event
      • 2.3.4. 实用模式
        • 2.3.4.1. 工作池模式
        • 2.3.4.2. 分块处理
        • 2.3.4.3. 超时处理
        • 2.3.4.4. 错误处理
      • 2.3.5. 注意事项
    • 2.4. asyncio 异步编程
      • 2.4.1. 基础概念
        • 2.4.1.1. 协程（Coroutine）
        • 2.4.1.2. 事件循环
      • 2.4.2. 任务管理
        • 2.4.2.1. 创建任务
        • 2.4.2.2. gather vs wait
        • 2.4.2.3. 超时控制
      • 2.4.3. 同步原语
        • 2.4.3.1. Lock
        • 2.4.3.2. Semaphore
        • 2.4.3.3. Event
        • 2.4.3.4. Queue
      • 2.4.4. 异步迭代器和生成器
        • 2.4.4.1. 异步迭代器
        • 2.4.4.2. 异步生成器
      • 2.4.5. 异步上下文管理器
      • 2.4.6. 与阻塞代码集成
        • 2.4.6.1. 运行阻塞代码
        • 2.4.6.2. 从同步代码调用异步
      • 2.4.7. 最佳实践
    • 2.5. 并发编程模式
      • 2.5.1. 生产者-消费者模式
        • 2.5.1.1. 异步版本
        • 2.5.1.2. 多进程版本
      • 2.5.2. 工作池模式
      • 2.5.3. 限流模式
        • 2.5.3.1. 令牌桶
        • 2.5.3.2. Semaphore 限流
      • 2.5.4. 重试模式
      • 2.5.5. 超时与取消模式
      • 2.5.6. 熔断器模式
      • 2.5.7. 最佳实践总结
    • 2.6. 并发 vs 并行
      • 2.6.1. 概念区分
      • 2.6.2. Python 并发模型选择
    • 2.7. 快速对比
      • 2.7.1. 性能对比（10 个 I/O 任务）
      • 2.7.2. 性能对比（CPU 密集型任务）
    • 2.8. 本章重点
    • 2.9. 选型指南
  • 3. 3. Web 开发
    • 3.1. FastAPI 实战
      • 3.1.1. 快速入门
        • 3.1.1.1. 基础应用
        • 3.1.1.2. 请求体与 Pydantic
      • 3.1.2. 依赖注入
        • 3.1.2.1. 基础依赖
        • 3.1.2.2. 类作为依赖
      • 3.1.3. 路由组织
        • 3.1.3.1. 使用 APIRouter
      • 3.1.4. 中间件
      • 3.1.5. 异常处理
      • 3.1.6. 后台任务
      • 3.1.7. 数据库集成
        • 3.1.7.1. SQLAlchemy 异步
      • 3.1.8. 测试
      • 3.1.9. 最佳实践
    • 3.2. Flask 实战
      • 3.2.1. 快速入门
        • 3.2.1.1. 基础应用
        • 3.2.1.2. 应用工厂模式
      • 3.2.2. 蓝图（Blueprint）
      • 3.2.3. 请求处理
        • 3.2.3.1. 获取请求数据
        • 3.2.3.2. 响应处理
      • 3.2.4. 数据库操作
        • 3.2.4.1. SQLAlchemy 模型
        • 3.2.4.2. 数据库查询
        • 3.2.4.3. 事务处理
      • 3.2.5. 认证与授权
        • 3.2.5.1. Flask-Login 集成
        • 3.2.5.2. JWT 认证
      • 3.2.6. 中间件和钩子
      • 3.2.7. 测试
      • 3.2.8. 部署
        • 3.2.8.1. Gunicorn
        • 3.2.8.2. Docker
      • 3.2.9. 最佳实践
    • 3.3. RESTful API 设计
      • 3.3.1. REST 原则
        • 3.3.1.1. 资源命名
        • 3.3.1.2. HTTP 方法语义
        • 3.3.1.3. 状态码
      • 3.3.2. 请求与响应设计
        • 3.3.2.1. 统一响应格式
        • 3.3.2.2. 错误响应
      • 3.3.3. 版本控制
        • 3.3.3.1. URL 版本
        • 3.3.3.2. 请求头版本
      • 3.3.4. 过滤、排序、分页
      • 3.3.5. HATEOAS（超媒体）
      • 3.3.6. API 文档
        • 3.3.6.1. OpenAPI 增强
      • 3.3.7. 最佳实践
    • 3.4. Web 安全
      • 3.4.1. 输入验证
        • 3.4.1.1. SQL 注入防护
        • 3.4.1.2. XSS 防护
        • 3.4.1.3. CSRF 防护
      • 3.4.2. 认证安全
        • 3.4.2.1. 密码处理
        • 3.4.2.2. JWT 安全
        • 3.4.2.3. Rate Limiting
      • 3.4.3. 安全响应头
      • 3.4.4. 敏感数据处理
        • 3.4.4.1. 日志脱敏
        • 3.4.4.2. 响应数据过滤
      • 3.4.5. 文件上传安全
      • 3.4.6. 安全检查清单
    • 3.5. 框架对比
    • 3.6. 快速对比
      • 3.6.1. FastAPI
      • 3.6.2. Flask
    • 3.7. 选择建议
    • 3.8. 项目结构
      • 3.8.1. 推荐的 FastAPI 项目结构
      • 3.8.2. 推荐的 Flask 项目结构
    • 3.9. 开发环境设置
  • 4. 4. Python 陷阱
    • 4.1. 常见错误
      • 4.1.1. 可变对象陷阱
        • 4.1.1.1. 可变默认参数
        • 4.1.1.2. 列表浅复制
        • 4.1.1.3. 列表乘法创建二维数组
      • 4.1.2. 作用域问题
        • 4.1.2.1. UnboundLocalError
        • 4.1.2.2. nonlocal 与嵌套函数
      • 4.1.3. 迭代陷阱
        • 4.1.3.1. 修改正在迭代的容器
        • 4.1.3.2. 迭代器耗尽
        • 4.1.3.3. zip 的最短原则
      • 4.1.4. 比较陷阱
        • 4.1.4.1. is vs ==
        • 4.1.4.2. 浮点数比较
        • 4.1.4.3. 链式比较
      • 4.1.5. 字符串陷阱
        • 4.1.5.1. 字符串不可变
        • 4.1.5.2. 编码问题
      • 4.1.6. 异常处理陷阱
        • 4.1.6.1. 捕获过于宽泛的异常
        • 4.1.6.2. finally 中的 return
        • 4.1.6.3. 异常中的变量作用域
      • 4.1.7. 最佳实践总结
    • 4.2. 性能陷阱
      • 4.2.1. 循环优化
        • 4.2.1.1. 避免在循环中重复计算
        • 4.2.1.2. 列表推导 vs 循环
        • 4.2.1.3. 使用生成器节省内存
      • 4.2.2. 数据结构选择
        • 4.2.2.1. 列表 vs 集合查找
        • 4.2.2.2. 合适的数据结构
        • 4.2.2.3. 字符串拼接
      • 4.2.3. 函数调用开销
        • 4.2.3.1. 避免不必要的函数调用
        • 4.2.3.2. 使用内置函数
      • 4.2.4. I/O 优化
        • 4.2.4.1. 批量读写
        • 4.2.4.2. 使用 pickle 的正确方式
      • 4.2.5. 数值计算
        • 4.2.5.1. 使用 NumPy
        • 4.2.5.2. 避免不必要的类型转换
      • 4.2.6. 缓存
        • 4.2.6.1. 使用 functools.lru_cache
        • 4.2.6.2. 自定义缓存
      • 4.2.7. 性能分析工具
        • 4.2.7.1. 使用 cProfile
        • 4.2.7.2. 使用 line_profiler
      • 4.2.8. 最佳实践
    • 4.3. 内存问题
      • 4.3.1. 引用计数与循环引用
        • 4.3.1.1. 引用计数基础
        • 4.3.1.2. 循环引用
        • 4.3.1.3. 检测内存泄漏
      • 4.3.2. 大对象处理
        • 4.3.2.1. 生成器代替列表
        • 4.3.2.2. 分块处理大文件
        • 4.3.2.3. numpy 内存映射
      • 4.3.3. slots 优化
      • 4.3.4. 字符串驻留
      • 4.3.5. 缓存注意事项
        • 4.3.5.1. lru_cache 内存泄漏
        • 4.3.5.2. 全局缓存增长
      • 4.3.6. 内存分析工具
        • 4.3.6.1. memory_profiler
        • 4.3.6.2. objgraph
        • 4.3.6.3. tracemalloc
      • 4.3.7. 最佳实践
    • 4.4. 调试技巧
      • 4.4.1. 打印调试
        • 4.4.1.1. f-string 调试（Python 3.8+）
        • 4.4.1.2. 漂亮打印
        • 4.4.1.3. 结构化输出
      • 4.4.2. 断点调试
        • 4.4.2.1. 内置 breakpoint()
        • 4.4.2.2. 条件断点
        • 4.4.2.3. ipdb（增强版 pdb）
      • 4.4.3. 日志调试
        • 4.4.3.1. 配置日志
        • 4.4.3.2. 日志装饰器
      • 4.4.4. 追踪执行
        • 4.4.4.1. trace 模块
        • 4.4.4.2. sys.settrace
      • 4.4.5. 性能分析
        • 4.4.5.1. cProfile
        • 4.4.5.2. timeit
      • 4.4.6. 异常调试
        • 4.4.6.1. 打印完整堆栈
        • 4.4.6.2. 自定义异常钩子
        • 4.4.6.3. 断言调试
      • 4.4.7. 调试工具
        • 4.4.7.1. IDE 调试器
        • 4.4.7.2. 远程调试
      • 4.4.8. 最佳实践
    • 4.5. 陷阱分类
    • 4.6. 快速参考：Top 10 陷阱
      • 4.6.1. 1. 可变默认参数
      • 4.6.2. 2. 循环中的闭包
      • 4.6.3. 3. is vs ==
      • 4.6.4. 4. 修改迭代中的列表
      • 4.6.5. 5. 字典迭代时修改
      • 4.6.6. 6. 浮点数比较
      • 4.6.7. 7. 类属性共享
      • 4.6.8. 8. 异常中的 return
      • 4.6.9. 9. GIL 与线程
      • 4.6.10. 10. 作用域陷阱
    • 4.7. 调试快速参考
    • 4.8. 性能检查快速参考
Python 实战开发指南
  • 搜索

© 版权所有 2024, Walter Fan。

利用 Sphinx 构建，使用的 主题 由 Read the Docs 开发.