从第一行代码,到写出能用的小程序
左边点目录,右边看知识点;顶上「全文速览」能把 21 章一次铺开通读,左上角搜索能搜到正文和代码里的每个词。暗色护眼,代码、表格、提示都保留原样,每章末尾还有小测。
把学过的知识真正敲出来:36 个单元、190+ 动手任务,案例 → 任务 → 看答案,附 10 套考试,纯本地无需联网。链接:https://myimage.cn/python-practical/
70 章逐个学:list / str / dict / set 等数据结构,到常用标准库、语法机制,再到 requests / numpy / fastapi 第三方扩展。每章 demo + 6 个任务附多解法。链接:https://myimage.cn/python-modules/
全部章节
第 1 章 先把 Python 跑起来
1.1 Python 能干什么(官方"课前甜点"三句话)
- 写几行代码就能完成别的语言几十行才能做的事;
- 自带强大的数据结构(列表、字典等)和海量现成工具库;
- 既适合写小脚本,也能开发大型应用和 AI 服务。
写过别的语言再来学 Python,先记住三个「不一样」,后面很多坑都跟它们有关。
第一,不用声明类型。别的语言要写 int age = 18;,Python 只写 age = 18。而且同一个名字随时能改成别的东西:
age = 18
print(age, type(age)) # 18 <class 'int'>
age = "十八"
print(age, type(age)) # 十八 <class 'str'>
# 输出:
# 18 <class 'int'>
# 十八 <class 'str'>这不是「一个盒子里的东西变了」,而是「标签从 18 上撕下来,贴到了 '十八' 上」(4.1 会再细讲)。好处是写起来快,代价是类型不对要等跑到那一行才暴露,所以后面会讲类型注解,以及它为什么对 FastAPI 特别重要。
第二,缩进就是大括号。别的语言用 { } 圈住代码块,Python 用缩进。看着只是排版,其实是语法的一部分:
score = 90
if score >= 60:
print("及格") # 缩进去的这行归 if 管
print("这句话不管及不及格都会打印")
# 输出:
# 及格
# 这句话不管及不及格都会打印及格
这句话不管及不及格都会打印第三,常用的东西都自带。不用装任何依赖就能处理 JSON、拼路径、算日期:
import json
from pathlib import Path
print(json.dumps({"name": "小明"}, ensure_ascii=False)) # {"name": "小明"}
print(Path("data/2026/a.txt").name) # a.txt
# 输出:
# {"name": "小明"}
# a.txt所谓「自带电池」(batteries included),说的就是这件事。等你开始写小工具会发现,很多需求不用装第三方包,一句 import 就够了。
1.2 两种运行方式
方式一:交互模式(适合试验单行代码)
终端输入 python 回车,出现 >>> 提示符:
>>> 1 + 2
3
>>> print("你好")
你好输入 exit() 或按 Ctrl+Z 回车退出。 交互模式下,最后一次输出的结果会存在 _ 里:
>>> 10 * 3
30
>>> _ + 5 # 相当于 30 + 5
35方式二:脚本模式(写真正的程序)
新建 hello.py,内容:
print("你好,世界")
# 输出:
# 你好,世界终端运行:python hello.py → 输出 你好,世界。
在 Windows 的 PowerShell 里,先把环境确认一下:
python --version # Python 3.15.2
py --version # 装了多个版本时,用 py 指定版本更稳
python .\hello.py # 跑脚本如果报「python 不是内部或外部命令」,多半是安装时没勾 Add Python to PATH;重跑安装包补上,或者先用 py 顶一下。VS Code 里按右上角那个三角形,本质也是在终端执行了上面这条命令,只是帮你把解释器和路径选好了。
交互模式真正好用的地方不是算数,而是查东西。忘了某个方法怎么用,直接问解释器:
>>> help(str.split)
>>> dir([]) # 看看列表身上到底有哪些方法
>>> type(1 + 1.5)
<class 'float'>写脚本时还能从命令行把参数传进去。sys.argv 是个列表,第 0 项是脚本自己的名字,真正传进来的从 1 开始:
# hello.py
import sys
name = sys.argv[1] if len(sys.argv) > 1 else "世界"
print(f"你好,{name}")
# 输出:
# 你好,世界python .\hello.py 小明你好,小明为什么要费这个事?因为脚本不是给人一行行敲的,它要能被别的程序、定时任务、批处理调用。参数从外面传进来,同一个 .py 文件才能处理不同的输入。
1.3 注释与编码
# 这是单行注释,Python 不会执行它
"""
这是多行注释(其实是多行字符串)
常用来写文件顶部的说明
"""
name = "小明" # 也可以在代码后面写注释(前面至少两个空格)中文编码:Python 3 默认就是 UTF-8,不需要像 Python 2 那样写
# -*- coding: utf-8 -*-。但读写文件时建议显式写encoding="utf-8"(见第 10 章)。
顺手把两件容易混的事说清楚。
"""...""" 严格讲不是注释,是一个字符串。它之所以常被放在文件开头当说明,是因为 Python 会把「模块或函数里的第一句字符串」当成文档字符串存起来,之后能用 help() 或 __doc__ 查到:
"""这个模块用来演示文档字符串。"""
def double(x):
"""把 x 翻倍。"""
return x * 2
print(double.__doc__) # 把 x 翻倍。
print(__doc__) # 这个模块用来演示文档字符串。
help(double) # 帮助里显示的就是上面那句说明
# 输出:
# 把 x 翻倍。
# 这个模块用来演示文档字符串。
# Help on function double in module __main__:
#
# double(x)
# 把 x 翻倍。
# (说明:这一段要连着上一段代码一起跑才有输出)所以真正的注释只有 # 一种;三引号放在函数第一行是「说明书」,放在别处就只是个没人用的字符串。写给别人用的函数,第一行留一句说明是性价比极高的习惯。
再说编码。源码里的中文能正常写,是因为 Python 3 默认按 UTF-8 读源文件;但 open() 读写文件用的是操作系统默认编码,中文 Windows 上是 GBK。同一份文件写的时候按 UTF-8、读的时候按 GBK,就会变成一堆问号或乱码。所以读写文件永远显式写上:
with open("note.txt", "w", encoding="utf-8") as f:
f.write("中文没问题")
with open("note.txt", encoding="utf-8") as f:
print(f.read()) # 中文没问题
# 输出:
# 中文没问题一句 encoding="utf-8" 省掉的是最难查的一类 bug:文件明明没坏,内容却全是乱码。附录 A7 还有具体例子。
1.4 输出、输入、缩进
print("姓名:", "小明", "年龄:", 18) # 逗号分隔,自动加空格
print("第一行\n第二行") # \n 换行
print("不换行", end="") # 默认 print 会换行,end="" 取消
name = input("请输入你的名字:") # 从键盘读,读到的永远是字符串
print("你好," + name)
# 输出(输入示例:小明):
# 姓名: 小明 年龄: 18
# 第一行
# 第二行
# 不换行请输入你的名字:你好,小明缩进是语法的一部分!同一段代码必须对齐(推荐 4 个空格)。缩进错了会报
IndentationError。
print() 其实比你以为的能干。它默认把多个参数用空格隔开、结尾自动换行,这两个行为都能改:
print("a", "b", "c") # a b c
print("a", "b", "c", sep="-") # a-b-c
print("2026", "01", "01", sep="/") # 2026/01/01
print("加载中", end="")
print("完成") # 加载中完成
# 输出:
# a b c
# a-b-c
# 2026/01/01
# 加载中完成sep 管「参数之间放什么」,end 管「打完之后放什么」。做进度提示、拼 CSV、把几段日志写在同一行时都会用到。
input() 有个几乎人人踩过的坑:它永远返回字符串。想算数得自己转类型:
a = input("第一个数:")
b = input("第二个数:")
print("直接相加:", a + b) # 输入 1 和 2 → 12
print("转成数字:", int(a) + int(b)) # 3
# (说明:这段要你自己输入内容才能继续,没有固定输出)第一个数:1
第二个数:2
直接相加: 12
转成数字: 3为什么是 12 不是 3?因为 + 对字符串的意思是「接起来」,对数字才是「相加」。Python 不会替你猜,也不会像 JS 那样悄悄转换(1 + "2" 在 JS 里给 "12",在 Python 里直接报 TypeError)。所以从用户、文件、接口拿到的文字,动手算之前先 int() / float() 转一下,这是写 Python 的肌肉记忆。《从入门到实践》里凡是读用户输入的例子,都要走这一步,原因就在这。
顺带提前认识一下最常用的输出写法,{} 里可以直接放变量,甚至直接算:
name = "小明"
print(f"你好,{name}") # 你好,小明
print(f"结果是 {1 + 2}") # 结果是 3
print(f"明年 {2026 + 1} 年") # 明年 2027 年
# 输出:
# 你好,小明
# 结果是 3
# 明年 2027 年第 2 章和第 10 章会把它讲透,现在先会用就行。
1.5 【本章小结】
| 你学到了什么 | 关键记忆点 |
|---|---|
| 两种运行方式 | python 进交互模式(试验单行);python xxx.py 跑脚本(写真正的程序) |
| 交互模式的小技巧 | _ 保存上一次的输出结果 |
| 注释 | # 单行;""" 多行(文件顶部说明常用) |
| 输入 / 输出 | print() 输出,默认换行;input() 输入,得到的永远是字符串 |
| 缩进 | 4 个空格,是语法的一部分,不统一会报 IndentationError / TabError |
| 编码 | Python 3 源码默认 UTF-8;读写文件时仍要显式写 encoding="utf-8" |
第 2 章 数字与文本(把 Python 当计算器)
2.1 数字
print(2 + 3, 7 - 2, 3 * 4) # 5 5 12
print(10 / 4) # 2.5 除法,结果一定是小数(float)
print(10 // 4) # 2 整除,向下取整
print(10 % 4) # 2 取余数
print(2 ** 10) # 1024 幂
print(round(3.14159, 2)) # 3.14 四舍五入保留 2 位
print(abs(-5)) # 5 绝对值
# 输出:
# 5 5 12
# 2.5
# 2
# 2
# 1024
# 3.14
# 5两种数字类型
| 类型 | 说明 | 例子 |
|---|---|---|
int 整数 | 不带小数点,任意大小 | 42、-7、10**100 |
float 小数 | 带小数点 | 3.14、2.0 |
print(type(10)) # <class 'int'>
print(type(10.0)) # <class 'float'>
print(int(3.9)) # 3 转整数(直接砍掉小数,不是四舍五入!)
print(float("3.5")) # 3.5 文字转小数
# 输出:
# <class 'int'>
# <class 'float'>
# 3
# 3.5【坑】
0.1 + 0.2不等于0.3(浮点精度问题),详见附录 A。
运算优先级:** > * / // % > + -,不确定就加括号:(1 + 2) * 3。
几个值得多问一句「为什么」的地方。
为什么除法要分 / 和 // 两种? 别的语言里 7 / 2 常常直接得 3(整数除法),Python 3 故意让它一定得到 3.5,因为「两个整数相除到底该不该截断」太容易埋 bug 了。想要整数商,就明明白白写 //:
print(7 / 2) # 3.5
print(7 // 2) # 3
print(-7 // 2) # -4 ← 不是 -3!
print(7 % 2) # 1
print(divmod(7, 2)) # (3, 1) 一次拿到商和余数
# 输出:
# 3.5
# 3
# -4
# 1
# (3, 1)-7 // 2 为什么是 -4?因为 // 是向下取整,在数轴上往左找第一个整数,-3.5 往左是 -4。记住这一点,写分页、算「第几组」的时候就不会在负数上翻车。
整数和浮点数混着算会怎样? 只要有一个是 float,结果就跟着变 float:
print(1 + 2, type(1 + 2)) # 3 <class 'int'>
print(1 + 2.0, type(1 + 2.0)) # 3.0 <class 'float'>
# 输出:
# 3 <class 'int'>
# 3.0 <class 'float'>Python 不会把 3.0 悄悄缩回 3。这也解释了为什么从文件里读出一个 2.0,后面整串计算都带上小数点。
数字里可以写下划线(3.6 起),纯粹为了人眼好读,解释器会忽略:
budget = 1_000_000
print(budget) # 1000000
print(f"{budget:,}") # 1,000,000 想输出千分位交给格式化
# 输出:
# 1000000
# 1,000,000为什么 0.1 + 0.2 不等于 0.3? 上面提过这个坑,这里说清原因:计算机用二进制存小数,而 0.1 换成二进制是无限循环的,就像 1/3 用十进制写成 0.3333... 永远写不完,只能截断。截断带来的那一点点误差,比较时就会冒出来:
print(0.1 + 0.2) # 0.30000000000000004
print(0.1 + 0.2 == 0.3) # False
import math
print(math.isclose(0.1 + 0.2, 0.3)) # True
# 输出:
# 0.30000000000000004
# False
# True所以小数比较别用 ==,用 math.isclose();涉及金额、计费,改用 decimal.Decimal,别指望 round() 兜底(附录 A1 还会再提)。
2.2 文本(字符串 str)
四种写法
a = '单引号'
b = "双引号" # 和单引号等价
c = "里面有双引号 \" 需要转义"
d = """多行
字符串"""
e = r"C:\new\test" # r 前缀 = 原始字符串,\n 不被当成换行常用操作
s = "Hello Python"
print(len(s)) # 12 长度
print(s[0], s[-1]) # H n 索引(负数从末尾数)
print(s[0:5]) # Hello 切片(含头不含尾)
print(s + "!!") # 拼接
print(s * 2) # 重复两次
print("Python" in s) # True 是否包含
print(s.upper(), s.lower()) # HELLO PYTHON / hello python
print(" hi ".strip()) # hi 去掉首尾空白
print("a,b,c".split(",")) # ['a', 'b', 'c'] 切成列表
print("-".join(["a","b","c"])) # a-b-c 列表拼成字符串
print(s.replace("Hello", "Hi"))# Hi Python 替换(返回新字符串)
print(s.find("Python")) # 6 找位置,找不到返回 -1
# 输出:
# 12
# H n
# Hello
# Hello Python!!
# Hello PythonHello Python
# True
# HELLO PYTHON hello python
# hi
# ['a', 'b', 'c']
# a-b-c
# Hi Python
# 6【重点】字符串不可变:
s[0] = "h"会报错。所有"修改"其实都是生成一个新字符串。
「改不动」听着像缺点,其实是有意为之。字符串太常用了——变量名、字典键、文件路径全是它,让它不可变,Python 才能放心地把它共享、缓存、拿去当字典的键。看个证据:
s = "abc"
before = id(s) # id() 是对象的"身份证号"
s = s + "d" # 看着像在 s 后面加了一个字符
print(s) # abcd
print(id(s) == before) # False → 已经是另一个新对象了
# 输出:
# abcd
# False代价是:循环里反复用 + 拼字符串,每一步都要把整段复制一遍,数据一大就明显变慢。所以拼很多段时统一用 join():它先算好总长度,一次拼完。
parts = ["2026", "01", "01"]
print("/".join(parts)) # 2026/01/01
print("".join(["a", "b", "c"])) # abc
# 输出:
# 2026/01/01
# abc还有个由此而来的高频 bug:所有字符串方法都不改原串,只返回新串,忘了接住返回值就等于白干。
s = "a-b-c"
print(s.replace("-", "/")) # a/b/c
print(s) # a-b-c 原串一点没动
# 输出:
# a/b/c
# a-b-c这也带来一个很好用的写法:因为每个方法都吐出一个新字符串,可以像流水线一样一路点下去。清洗用户输入、文件名、接口返回的文字时天天这么写:
raw = " Hello, PYTHON "
clean = raw.strip().lower().replace("python", "世界")
print(clean) # hello, 世界
name = " 小明 "
print(f"用户标识:{name.strip()}") # 用户标识:小明
# 输出:
# hello, 世界
# 用户标识:小明顺序是有讲究的:先 strip() 去掉两头空白,再 lower() 统一大小写,最后才替换。要是先替换再 strip(),前后带空格的文本就可能匹配不上。
split() 不传参数是被低估的一个用法:它按「任意空白」切,还会自动丢掉多余的空格、制表符、换行,处理粘贴来的文本特别省事:
text = "Python is\tsimple\nand fun"
print(text.split())
# ['Python', 'is', 'simple', 'and', 'fun']
print("a,b,c".split(","))
# ['a', 'b', 'c'] 传了分隔符就严格按它切
# 输出:
# ['Python', 'is', 'simple', 'and', 'fun']
# ['a', 'b', 'c']字符串方法速查表(不用背,用到回来查)
| 方法 | 作用 | 例子 |
|---|---|---|
len(s) | 长度 | len("abc") → 3 |
s.upper() / s.lower() | 转大/小写 | "Hi".upper() → HI |
s.strip() | 去首尾空白 | " a ".strip() → a |
s.split(sep) | 切成列表 | "a,b".split(",") → ['a','b'] |
sep.join(列表) | 列表拼成字符串 | "-".join(['a','b']) → a-b |
s.replace(a, b) | 替换 | "aa".replace("a","b") → bb |
s.find(x) | 找位置(找不到 -1) | "abc".find("b") → 1 |
s.count(x) | 出现次数 | "aab".count("a") → 2 |
s.startswith(x) / endswith(x) | 前/后缀判断 | "a.txt".endswith(".txt") → True |
x in s | 是否包含 | "b" in "abc" → True |
s.isdigit() | 是不是纯数字 | "123".isdigit() → True |
s.zfill(n) | 左边补 0 | "7".zfill(3) → 007 |
格式化(f-string,最推荐)
name, age = "小明", 18
print(f"{name} 今年 {age} 岁") # 小明 今年 18 岁
print(f"明年 {age + 1} 岁") # 花括号里可以算
print(f"{3.14159:.2f}") # 3.14 保留 2 位小数
print(f"{1234567:,}") # 1,234,567 千分位
print(f"{'左':<10}|{'右':>10}") # 左对齐/右对齐,占 10 字符
# 输出:
# 小明 今年 18 岁
# 明年 19 岁
# 3.14
# 1,234,567
# 左 | 右f 表示 f-string(格式化字符串字面量),是 Python 3.6 引入的一种字符串写法。 它的作用是:在字符串里直接用 { } 放变量或表达式,运行时把结果填进去。
为什么现在都写 f-string,不用 + 拼?对比一下就知道:
name, age = "小明", 18
print("你好," + name + ",今年 " + str(age) + " 岁") # 得自己把数字转成字符串
print(f"你好,{name},今年 {age} 岁") # 你好,小明,今年 18 岁
# 输出:
# 你好,小明,今年 18 岁
# 你好,小明,今年 18 岁+ 只能拼字符串,混进数字就得手动 str(),还容易漏掉空格;f-string 自动把值变成「给人看的样子」,{} 里还可以直接算。调试时有个特别省事的写法(3.8 起):= 会把表达式本身一起打出来。
x = 10
print(f"{x=}") # x=10
print(f"{x=}, {x * 2=}") # x=10, x * 2=20
# 输出:
# x=10
# x=10, x * 2=20再补几个处理文本时很顺手的方法:
filename = "report_2026.csv"
print(filename.removeprefix("report_")) # 2026.csv (3.9 起)
print(filename.removesuffix(".csv")) # report_2026
print("hello world".title()) # Hello World
# 输出:
# 2026.csv
# report_2026
# Hello World为什么不用切片写 filename[7:]?因为切片要数字符数,前缀一改就得重数一遍,还容易数错。按内容说「去掉这段」,读代码的人也一眼看得懂。
只想知道「有没有」,用 in 比 find() 更省心:
s = "hello.py"
print("py" in s) # True 直接给 True/False
print(s.find("py")) # 6 要位置才用它
print(s.find("xxx")) # -1 找不到返回 -1,忘了判断就会当成"在第 -1 位"
# 输出:
# True
# 6
# -1index() 和 find() 做一样的事,区别是找不到时抛 ValueError 而不是返回 -1——有时候这正是你想要的:出错就立刻停,别让一个 -1 悄悄流到后面去。
转义字符与原始字符串。反斜杠是「后面这个字符要特殊理解」的开关,\n 是换行、\t 是制表符、\" 是一个普通双引号:
print("第一行\n第二行") # 第一行(换行)第二行
print("他说 \"你好\"") # 他说 "你好"
print(r"C:\new\test") # C:\new\test
# 输出:
# 第一行
# 第二行
# 他说 "你好"
# C:\new\test
# (说明:路径、时间、目录内容随你自己的机器而变,你跑出来的会不一样)Windows 路径里的 \n、\t 恰好都是转义序列,所以写路径要么加 r 前缀,要么用正斜杠 "C:/new/test",要么干脆交给 pathlib(第 10 章)。这三种写法你会在别人的代码里都见到。
三引号最实际的用途是存多行文本:一段 SQL、一封邮件模板、给大模型用的长提示词。
prompt = """
你是一个 Python 助教。
请用大白话解释下面的代码,
不要堆术语。
"""
print(prompt.strip()) # 三引号把首尾的换行也存进来了,通常配 strip() 用
# 输出:
# 你是一个 Python 助教。
# 请用大白话解释下面的代码,
# 不要堆术语。动手练:把你的名字、年龄、城市用一句 f-string 打印出来。
2.3 【本章小结】
| 你学到了什么 | 关键记忆点 |
|---|---|
| 两种数字类型 | int 整数(任意大小);float 小数 |
| 三个特殊运算符 | // 整除、% 取余、** 幂(优先级 ** 最高) |
| 除法 | / 的结果一定是 float;int() 转换是"砍掉小数"不是四舍五入 |
| 字符串的索引与切片 | 索引从 0 开始,负数从末尾数;切片"含头不含尾" |
| 字符串不可变 | 所有"修改"其实都是生成新字符串 |
| 常用方法 | strip / split / join / replace / find / startswith / upper |
| 格式化 | f-string:f"{变量}"、f"{3.14159:.2f}"、f"{1234567:,}" |
第 3 章 列表:第一个容器
【本章导览】 一个一个变量太慢了,容器让你"批量管理数据":
- 列表长什么样?索引、切片、长度怎么取。
- 列表"可变"带来哪些增删改操作。
- 用列表当栈和队列(以及为什么队列要用
deque)。- 列表推导式:Python 最有代表性的语法糖,必须掌握。
- 拷贝的坑:
b = a为什么不是复制。难度:★★☆☆☆ | 预计用时:40 分钟 | 前置知识:第 2 章
3.1 列表长什么样
nums = [10, 20, 30, 40]
mixed = [1, "小明", True, 3.14] # 可以混装(但不推荐)
print(nums[0]) # 10
print(nums[-1]) # 40 倒数第一个
print(nums[1:3]) # [20, 30]
print(len(nums)) # 4
# 输出:
# 10
# 40
# [20, 30]
# 4
# (说明:耗时与机器性能有关,数值会不同)切片值得单独讲透,因为它是 Python 里最省力的一把刀,入门书往往只给一行例子就过去了。写法是 [起点:终点:步长],起点和终点都能省:
nums = [10, 20, 30, 40, 50]
print(nums[1:4]) # [20, 30, 40] 含头不含尾
print(nums[:3]) # [10, 20, 30] 省起点 = 从头开始
print(nums[3:]) # [40, 50] 省终点 = 一直到尾
print(nums[-3:]) # [30, 40, 50] 最后三个
print(nums[::2]) # [10, 30, 50] 隔一个取一个
print(nums[::-1]) # [50, 40, 30, 20, 10] 倒着来(不是 reverse,它返回新列表)
print(nums[:]) # [10, 20, 30, 40, 50] 一份副本(3.6 会讲它的用处)
# 输出:
# [20, 30, 40]
# [10, 20, 30]
# [40, 50]
# [30, 40, 50]
# [10, 30, 50]
# [50, 40, 30, 20, 10]
# [10, 20, 30, 40, 50]
# (说明:耗时与机器性能有关,数值会不同)为什么「含头不含尾」这么别扭?把索引想成元素之间的缝隙,而不是元素本身::3 就是「从头到第 3 条缝隙为止」,正好装进 3 个元素。这么定有三个顺手的地方——nums[:3] 一眼就是「前 3 个」;len(nums[1:4]) 直接等于 4 - 1;更重要是 nums[:i] + nums[i:] 严丝合缝拼回原列表:
i = 2
print(nums[:i], nums[i:]) # [10, 20] [30, 40, 50]
# 输出(需与上一段代码连着跑):
# [10, 20] [30, 40, 50]写分页、把数据切成前后两半、跑交叉验证时,这个性质省掉一堆 +1 / -1 的调试。
还有个细节:切片越界不报错,索引越界会报错。
print(nums[2:100]) # [30, 40, 50] 取到头自然停
# print(nums[100]) # IndexError: list index out of range
# 输出(需与上一段代码连着跑):
# [30, 40, 50]因为切片的语义是「取一段」,取到没东西就结束;索引是「精确指名要某一个」,没有就是你的逻辑错了。
切片还能整体替换一段,而且新的一段长度不必和原来一样:
words = ["a", "b", "c", "d"]
words[1:3] = ["X", "Y", "Z"]
print(words) # ['a', 'X', 'Y', 'Z', 'd']
# 输出:
# ['a', 'X', 'Y', 'Z', 'd']最后记住:切片不是列表专属,字符串、元组这些序列都能切,规则完全一样:
print("Python-3.15"[:6]) # Python
print((1, 2, 3)[::-1]) # (3, 2, 1)
# 输出:
# Python
# (3, 2, 1)3.2 列表是"可变的"
nums = [10, 20, 30]
nums[0] = 99 # 改
print(nums) # [99, 20, 30]
nums.append(40) # 末尾加 → [99, 20, 30, 40]
nums.insert(0, 5) # 指定位置插 → [5, 99, 20, 30, 40]
nums.remove(20) # 删掉第一个值为 20 的
last = nums.pop() # 弹出最后一个并返回
nums.sort() # 排序(从小到大)
nums.reverse() # 反转
nums.clear() # 清空
print(nums.count(99)) # 出现次数
print(nums.index(99)) # 首次出现的位置
# (说明:这一段需要外部环境(文件 / 网络 / 第三方服务)才能跑出结果)
sort()会直接改原列表;sorted(列表)不改原列表而是返回新列表。
三个「加元素」的方法,新手经常分不清该用哪个:
b = [3, 4]
a = [1, 2]
a.append(b)
print(a) # [1, 2, [3, 4]] 整个 b 当"一个元素"塞进去
a = [1, 2]
a.extend(b)
print(a) # [1, 2, 3, 4] 把 b 摊开,元素一个个加进来
a = [1, 2]
a = a + b
print(a) # [1, 2, 3, 4] 造了个新列表,再把标签贴过去
# 输出:
# [1, 2, [3, 4]]
# [1, 2, 3, 4]
# [1, 2, 3, 4]append 是「放一个东西」,extend 是「摊开再放」,+ 是「谁都不改,另造一个新的」。区别在写函数时特别要紧:想让外面的列表真的变化,只能用 append / extend(6.4 会解释为什么)。
remove() 只删第一个匹配的值,找到了就收工:
nums = [1, 2, 1, 2, 1]
nums.remove(1)
print(nums) # [2, 1, 2, 1] 后面两个 1 还在
# 输出:
# [2, 1, 2, 1]
# (说明:耗时与机器性能有关,数值会不同)想删干净,《从入门到实践》里给的套路是配 while,因为「还有没有」这件事可以一直问:
while 2 in nums:
nums.remove(2)
print(nums) # [1, 1, 1]
# 输出(需与上一段代码连着跑):
# [1, 1]更推荐的是干脆不改动原列表,用推导式造一个新的(5.1 会讲为什么遍历时改列表会漏元素):
nums = [n for n in nums if n != 2]
# (说明:这一段要连着上一段代码一起跑才有输出)几乎所有「就地修改」的方法都返回 None,这是个很常见的坑:
numbers = [3, 1, 2]
print(numbers.sort()) # None ← 不是排好序的列表!
print(numbers) # [1, 2, 3] 原列表已经被改好了
# 输出:
# None
# [1, 2, 3]为什么故意返回 None?这是 Python 的一个约定:会改原对象的方法不返回结果,用 None 提醒你「我动的是原来那个东西」。所以千万别写 lst = lst.sort(),那会把列表变成 None。append、insert、extend、remove、reverse、clear 全都是这样。想「既要原列表、又要排序结果」,用 sorted()。
排序还有个天天要用的参数 key=,意思是「按什么比」。Python 不知道一个元组里哪个字段该当大小,你得告诉它:
students = [("小明", 18), ("小红", 20), ("小李", 19)]
print(sorted(students, key=lambda s: s[1]))
# [('小明', 18), ('小李', 19), ('小红', 20)]
# 输出:
# [('小明', 18), ('小李', 19), ('小红', 20)]key 会对每个元素算出一个「用来比较的值」,然后按这个值排,元素本身原样保留。注意传的是函数本身(key=len 不带括号),不是调用结果。
3.3 用列表当"栈"和"队列"
# 栈:后进先出(像叠盘子)
stack = [1, 2, 3]
stack.append(4) # 入栈 → [1, 2, 3, 4]
stack.pop() # 出栈 → 4,剩 [1, 2, 3]
# 队列:先进先出(用 list.pop(0) 可以,但慢)
queue = [1, 2, 3]
queue.append(4) # 入队
queue.pop(0) # 出队 → 1(后面的元素都要前移,数据多时很慢)
# 队列的正确做法:用 collections.deque
from collections import deque
q = deque(["a", "b", "c"])
q.append("d")
q.popleft() # 'a' 从左边出队,速度快得多3.4 列表推导式(Python 的特色,务必掌握)
nums = [1, 2, 3, 4, 5]
squares = [x * x for x in nums] # [1, 4, 9, 16, 25]
evens = [x for x in nums if x % 2 == 0] # [2, 4] 带筛选
labels = [f"第{x}名" for x in nums] # ['第1名', ...]
matrix = [[row * 3 + c + 1 for c in range(3)] for row in range(3)]
# [[1,2,3], [4,5,6], [7,8,9]] 嵌套推导式推导式等价于一个
for循环,但更短、更快。读法:[对每个x做某件事 for x in 列表 if 条件]。
把上一行展开成普通循环,就明白它到底省了什么:
nums = [1, 2, 3, 4, 5]
squares = [] # 普通写法:三行
for x in nums:
squares.append(x * x)
squares = [x * x for x in nums] # 推导式:一行,且不用手动建空列表
print(squares) # [1, 4, 9, 16, 25]
# 输出:
# [1, 4, 9, 16, 25]
# (说明:耗时与机器性能有关,数值会不同)快一点的原因不是「少打字」,而是推导式在解释器内部直接把结果拼成列表,省掉了每一轮都去查一次 append、调一次方法的开销。不过更值得在意的是可读性:它把「对每个元素做什么」摆在最前面,一眼看出结果长什么样。
if 放在两个不同位置,意思完全不一样,这里最容易搞混:
nums = [1, 2, 3, 4]
print(["偶" if x % 2 == 0 else "奇" for x in nums]) # ['奇', '偶', '奇', '偶']
print([x for x in nums if x % 2 == 0]) # [2, 4]
# 输出:
# ['奇', '偶', '奇', '偶']
# [2, 4]
# (说明:耗时与机器性能有关,数值会不同)前面的 if/else 在表达式里,决定「每个元素变成什么」,所以结果长度不变;后面的 if 是过滤条件,决定「留不留」,结果会变短。想写「筛完再变形」,两个可以一起用:
print([x * x for x in nums if x % 2 == 0]) # [4, 16]
# 输出(需与上一段代码连着跑):
# [4, 16]把方括号换成花括号或圆括号,就得到另外三种推导式,语法是一套:
print({x * x for x in nums}) # {1, 4, 9, 16}(集合无序,显示顺序不保证)
print({x: x * x for x in nums}) # {1:1, 2:4, 3:9, 4:16} 字典推导式(7.4)
g = (x * x for x in nums) # 生成器表达式,要一个算一个(12.9)
print(sum(g)) # 30
# 输出(需与上一段代码连着跑):
# {16, 1, 4, 9}
# {1: 1, 2: 4, 3: 9, 4: 16}
# 30但别为了「一行搞定」而硬凑。嵌套两层以上、里面还有复杂 if/else 时,写回普通 for 循环反而更好读——三个月后回来改代码的人(很可能就是你自己)会感谢你。推导式的目标是「一眼看懂」,不是「越短越好」。
3.5 解包(把列表拆给多个变量)
a, b, c = [1, 2, 3]
first, *rest = [1, 2, 3, 4] # first=1, rest=[2,3,4]
x, y = y, x # 交换两个变量(经典写法)
# (说明:这一段要连着上一段代码一起跑才有输出)3.6 拷贝的坑(重要)
a = [1, 2, 3]
b = a # ❌ 这是"起别名",b 和 a 是同一个列表!
b.append(4)
print(a) # [1, 2, 3, 4] a 也被改了
c = a.copy() # ✅ 真正的拷贝(或 list(a)、a[:])
c.append(5)
print(a) # [1, 2, 3, 4] a 没变
# 输出:
# [1, 2, 3, 4]
# [1, 2, 3, 4]但 copy() 只复制了外面一层。列表里还装着列表时,里面那层仍然是共用的:
import copy
nested = [[1, 2], [3, 4]]
b = nested.copy()
b[0].append(9)
print(nested) # [[1, 2, 9], [3, 4]] ← 内层被改到了
c = copy.deepcopy(nested)
c[0].append(0)
print(nested) # [[1, 2, 9], [3, 4]] ← 这回一点没动
# 输出:
# [[1, 2, 9], [3, 4]]
# [[1, 2, 9], [3, 4]]打个比方:copy() 是买了个新抽屉柜,但抽屉里的东西还是原来那些;deepcopy() 会一层层把里面的东西也复制一份。处理接口返回的嵌套 JSON、读进来的配置、二维表格时,这个坑特别常见(附录 A5 也有例子)。判断标准很简单:数据里有没有「套着」的列表或字典?有,就要想想是不是该 deepcopy。
3.7 【本章小结】
| 你学到了什么 | 关键记忆点 |
|---|---|
| 列表的读写 | nums[0]、nums[-1]、nums[1:3]、len(nums) |
| 列表可变 | append / insert / remove / pop / sort / reverse / clear / index / count |
sort() vs sorted() | sort() 改原列表;sorted() 返回新列表 |
| 栈与队列 | 栈用 append + pop;队列用 collections.deque 的 append + popleft |
| 推导式 | [表达式 for x in 序列 if 条件],读法:"对每个 x 做某件事" |
| 解包 | a, b = [1, 2];first, *rest = [...];x, y = y, x 交换 |
| 拷贝的坑 | b = a 是起别名;真拷贝用 a.copy() / list(a) / a[:](嵌套结构要 deepcopy) |
第 4 章 走向编程第一步:变量、if 与 while
【本章导览】 从这一章开始,代码不再是从上到下走到底,而是会"做判断、会重复":
- 变量:怎么起名字、怎么赋值、Python 的变量和别的语言有什么不同。
if分支:完整的语法结构、什么值算"真 / 假"、三元表达式。while循环:执行流程、为什么必须有"推进条件"、三种常用循环套路。break/continue/ 循环的else怎么用。难度:★★☆☆☆ | 预计用时:40 分钟 | 前置知识:第 1~3 章
4.1 变量与赋值
变量是什么:变量就是给数据起的一个名字。写下 age = 18,意思是"让 age 这个名字指向数字 18",后面用 age 就等价于用 18。
Python 的变量更像贴在对象上的一张标签,而不是一个装东西的盒子。所以
a = 18之后a = "abc"完全合法——标签撕下来贴到别的东西上就行了(这就是"动态类型")。
width, height = 10, 5 # 同时赋多个值(多重赋值)
area = width * height # 50
counter = 0
counter = counter + 1 # 也可以写 counter += 1
a, b = 1, 2
a, b = b, a # 交换两个变量(经典写法,不需要临时变量)
PI = 3.14159 # 全大写是"约定上的常量",语法上仍可改,只是大家约定不改命名规则(必须遵守,否则报错)
- 只能由字母、数字、下划线组成,且不能用数字开头:
name1✅、1name❌ - 区分大小写:
age和Age是两个不同的变量 - 不能用保留字(关键字)当名字,比如
if、for、class、True、None、print也不建议用(会覆盖内置函数) - 合法示例:
user_name、name2、_private、年龄(支持中文,但不推荐)
命名风格(约定,不遵守也能跑,但会被人吐槽)
| 场景 | 风格 | 例子 |
|---|---|---|
| 变量 / 函数 | 小写 + 下划线 | user_name、get_age() |
| 常量 | 全大写 | MAX_SIZE |
| 类名 | 大驼峰 | DataLoader |
保留字的完整清单见 第 8 章 8.1。
4.2 if 判断:让程序"做选择"
什么是 if:if 是条件分支语句。它的意思是——如果某个条件成立,就执行某段代码;否则执行另一段(或不执行)。
完整语法结构
if 条件1:
条件1 成立时执行的代码 # 必须缩进(4 个空格)
elif 条件2:
条件1 不成立、但条件2 成立时执行
elif 条件3:
... # elif 可以有任意多个,也可以没有
else:
上面都不成立时执行 # else 最多一个,也可以省略
# (说明:这一段需要外部环境(文件 / 网络 / 第三方服务)才能跑出结果)四个要点:
- 条件后面必须有冒号
:—— 忘了冒号是最常见的新手错误。 - 冒号下面的代码块必须缩进,缩进决定"这段代码归谁管"。
elif是 "else if" 的缩写,可以有 0 个或多个。else可选,表示"其他所有情况"。
age = 20
if age < 18:
print("未成年")
elif age < 60:
print("成年人")
else:
print("老年人")
# 输出:
# 成年人多个
if是挨个都判断一遍;if / elif / else是只走第一个成立的分支,判断完就跳过其余的。
if 支持嵌套(一层套一层,注意别套太深)
score = 85
if score >= 60:
if score >= 90:
print("优秀")
else:
print("及格")
else:
print("不及格")
# 输出:
# 及格什么算"真",什么算"假"(非常重要)
if 后面不一定非要是比较表达式,任何值都能当条件。Python 里以下这些值被判定为假(False),其余都是真(True):
| 假值 | 说明 |
|---|---|
False | 布尔假 |
None | 空值 |
0、0.0 | 数字零 |
"" | 空字符串 |
[]、()、{}、set() | 空容器 |
name = input("请输入姓名:")
if name: # 直接把字符串当条件:非空就是真
print("你好," + name)
else:
print("你没输入名字")
nums = []
if not nums: # 推荐这种写法判断"列表为空"
print("列表是空的")
# 输出(输入示例:小明):
# 请输入姓名:你好,小明
# 列表是空的比较运算符与逻辑运算符
# 比较:== != > < >= <
if age == 18: ...
# 逻辑:and(都真才真)、or(有一个真就真)、not(取反)
if age >= 18 and age < 60: ...
if age < 6 or age > 70: ...
if not name: ...
# 链式比较(Python 特色,别的语言少见)
if 18 <= age < 60: ... # 等价于 age >= 18 and age < 60
# (说明:这一段要连着上一段代码一起跑才有输出)短路求值:
and前面为假时,后面根本不会执行;or前面为真时,后面也不执行。 所以if name and name.startswith("小")是安全的——name是None时不会报错。
三元表达式(一行写个小 if)
# 其他语言:条件 ? 值1 : 值2
# Python:值1 if 条件 else 值2
level = "及格" if score >= 60 else "不及格"
tip = "成年" if age >= 18 else "未成年"
# (说明:这一段要连着上一段代码一起跑才有输出)只适合简单的二选一。逻辑一复杂就老老实实写
if/else,可读性优先。
短路求值还有个很 Python 的用法:给个默认值。
name = input("名字(直接回车就用默认的):") or "匿名"
print(f"你好,{name}")
# 输出(输入示例:小明):
# 名字(直接回车就用默认的):你好,小明为什么能这么写?因为 Python 的 and / or 返回的不是 True / False,而是参与运算的某个值本身:
print(0 or "默认值") # 默认值
print("" or "默认值") # 默认值
print("abc" or "默认值") # abc
print([] or [1, 2]) # [1, 2]
# 输出:
# 默认值
# 默认值
# abc
# [1, 2]or 从左往右找,碰到第一个「真」的值就把它交出来;and 反过来,碰到第一个「假」的值就交出来。别的语言里 || 通常只给你布尔值,所以这个写法得专门记一下。
有个前提要留心:0、False、空列表这些都算「假」。如果用户真的填了 0,上面这招会把 0 替换成默认值——这种时候老老实实判断 if value is None: 更稳。
4.3 while 循环:让程序"重复做"
什么是 while:while 是条件循环语句。意思是——只要条件还成立,就反复执行下面这段代码,直到条件不成立为止。
语法
while 条件:
条件成立时反复执行的代码 # 同样要缩进
# (说明:这一段要连着上一段代码一起跑才有输出)执行流程(理解这个就不会写出死循环):
① 判断条件 → ② 成立就执行循环体 → ③ 回到 ① 再判断 → …… → 条件不成立 → 退出循环# 打印 1 到 5
i = 1
while i <= 5:
print(i)
i += 1 # ← 关键:让条件一步步走向不成立。忘了这行就是死循环!
# 输出:
# 1
# 2
# 3
# 4
# 5【坑】死循环:循环体里没有任何让条件变化的代码,程序就永远出不来(只能
Ctrl+C中断)。 写while时先问自己一句:"这个循环靠什么停下来?"
三种最常用的循环套路
套路一:计数器循环(知道要跑几次)
# 打印斐波那契数列前 10 项
a, b = 0, 1
count = 0
while count < 10:
print(a, end=" ")
a, b = b, a + b # 同时赋值,避免中间变量
count += 1 # 计数器推进
# 输出:
# 0 1 1 2 3 5 8 13 21 34 套路二:无限循环 + break(不知道要跑几次,"满足条件就跳出")
# 让用户反复输入,直到输入 quit
while True: # 故意写成恒真
cmd = input("请输入命令(quit 退出):")
if cmd == "quit":
break # 直接跳出整个循环
print("你输入了:", cmd)
# 输出(输入示例:quit):
# 请输入命令(quit 退出):套路三:输入校验(错了就重来,直到输入合法)
while True:
text = input("请输入整数:")
if text.lstrip("-").isdigit():
num = int(text)
break
print("输入不合法,请重来")
print("收到:", num)
# 输出(输入示例:3):
# 请输入整数:收到: 3break / continue / 循环的 else
i = 0
while i < 10:
i += 1
if i == 3:
continue # 跳过本轮剩下的代码,直接进入下一轮
if i == 8:
break # 直接结束整个循环
print(i) # 1 2 4 5 6 7(没有 3,到 8 就停)
# 输出:
# 1
# 2
# 4
# 5
# 6
# 7# 循环的 else:循环"正常跑完、没被 break 打断"时才执行
n = 5
i = 2
while i < n:
if n % i == 0:
print(f"{n} 能被 {i} 整除,不是质数")
break
i += 1
else:
print(f"{n} 是质数") # 只有循环没被 break 才会走到这里
# 输出:
# 5 是质数循环的
else是 Python 特色,最常见的用法就是上面这种"找了一圈没找到"的场景。
再补三个《从入门到实践》里反复出现、实战也确实天天用的套路。
用一个开关控制循环。当「什么时候停」有好几种情况时,与其在循环体里到处撒 break,不如立一个标志变量:
active = True
while active:
msg = input("说点什么(q 退出):")
if msg == "q":
active = False # 只在这一处决定"要不要继续"
else:
print("回声:", msg)
# (说明:这段要你自己输入内容才能继续,没有固定输出)读代码的人只看 active 在哪儿被改,就知道循环什么时候结束。退出条件越多,这个写法越清爽。
用 while 把数据从一个列表搬到另一个。这是处理「待办 → 已完成」这类队列的标准写法:
unconfirmed = ["小明", "小红", "小李"]
confirmed = []
while unconfirmed: # 列表空了就是假,循环自动停
person = unconfirmed.pop() # 一边取、一边从原列表删掉
print("已验证:", person)
confirmed.append(person)
print("未验证:", unconfirmed) # []
print("已验证:", confirmed) # ['小李', '小红', '小明']
# 输出:
# 已验证: 小李
# 已验证: 小红
# 已验证: 小明
# 未验证: []
# 已验证: ['小李', '小红', '小明']妙处在于不用自己管下标、也不用数还剩几个:pop() 顺手把元素摘走了,while 列表 又天然知道什么时候收工。注意顺序是倒的(因为从末尾弹),想保持原顺序可以用 deque.popleft()(见 3.3)。
边问边往字典里存。input() + while + 字典,几乎就是所有「信息登记表」的雏形:
answers = {}
while True:
name = input("姓名(直接回车结束):").strip()
if not name:
break
answers[name] = input("想去哪座城市?")
print(answers)
# (说明:这段要你自己输入内容才能继续,没有固定输出)姓名(直接回车结束):小明
想去哪座城市?杭州
姓名(直接回车结束):小红
想去哪座城市?成都
姓名(直接回车结束):
{'小明': '杭州', '小红': '成都'}为什么用字典?因为「一个名字对应一份回答」正是键值对要解决的问题,接口返回的 JSON 也大多长这样(第 10 章)。顺带留意 .strip():用户多敲了空格," " 是「真」的,会被当成一个有效名字,去了空白才能可靠地判断「没填」。
4.4 【本章小结】
| 你学到了什么 | 关键记忆点 |
|---|---|
| 变量 | 是"贴在数据上的标签";动态类型、可多重赋值、a, b = b, a 交换 |
| 命名 | 字母/数字/下划线,不能数字开头,区分大小写,不能用保留字 |
if 语法 | if 条件: → elif 条件: → else:,冒号 + 缩进缺一不可 |
| 真假判断 | False / None / 0 / "" / 空容器 为假,其余为真;if not nums: 判空 |
| 运算符 | == != > < >= <=;and / or / not(短路);支持链式 18 <= age < 60 |
| 三元表达式 | 值1 if 条件 else 值2,只用于简单二选一 |
while | "只要条件成立就反复执行";必须写推进语句,否则死循环 |
| 循环控制 | break 结束循环、continue 跳过本轮、else 在没被 break 时执行 |
第 5 章 控制流工具
【本章导览】 这一章把"重复"和"选择"讲完,顺便认识 Python 的两个特色语法:
for循环:和while有什么区别?range()、enumerate()怎么用。break/continue/ 循环的else。pass:什么都不做的占位语句,为什么它很重要。match(3.10+):不止是 switch,而是"按数据的形状拆开它"。- 5.0 节先补一个类与接口的速览——因为本章示例会用到
class,而类在第 12 章才正式讲。难度:★★★☆☆ | 预计用时:50 分钟 | 前置知识:第 4 章
5.0 先修速览:类、对象和接口(看懂后面示例就够了)
为什么插这一节:本章 5.4 会用到
class,第 11 章的自定义异常也会用到。 这里只讲"够看懂示例"的最小知识,系统讲解在第 12 章。
① 类 = 图纸,对象 = 按图纸造出来的东西
class Dog: # Dog 是一个"类"(图纸/模板)
kind = "犬科" # 类变量:所有狗共享
def __init__(self, name): # 构造器:造一只狗的时候自动调用
self.name = name # 实例变量:每只狗自己有一份
def bark(self): # 方法:这只狗能做的事
return f"{self.name}:汪汪!"
d1 = Dog("旺财") # 按图纸造一个对象(实例化)
d2 = Dog("小黑")
print(d1.bark()) # 旺财:汪汪!
print(d1.name, d2.name) # 旺财 小黑 ← 各自有自己的数据
print(d1.kind, Dog.kind) # 犬科 犬科 ← 类变量是共享的
# 输出:
# 旺财:汪汪!
# 旺财 小黑
# 犬科 犬科| 名词 | 含义 | 上面的例子 |
|---|---|---|
| 类(class) | 图纸、模板 | Dog |
| 对象 / 实例(instance) | 按图纸造出来的具体东西 | d1、d2 |
| 属性(attribute) | 对象身上的数据 | d1.name |
| 方法(method) | 对象能做的事(其实就是类里的函数) | d1.bark() |
self | "当前这个对象自己",调用时 Python 自动传入 | d1.bark() 等价于 Dog.bark(d1) |
② 继承:在别人的图纸上改
class Animal: # 父类
def speak(self):
raise NotImplementedError # 不实现,留给子类
class Cat(Animal): # 子类:括号里写父类,表示"继承"
def speak(self): # 重写(覆盖)父类的同名方法
return "喵喵!"
print(Cat().speak()) # 喵喵!
# 输出:
# 喵喵!
raise NotImplementedError的意思是"这个方法必须由子类实现,父类不提供"。
③ 接口是什么:只规定"你必须有什么方法",不规定怎么实现
Python 没有 interface 关键字(这是 Java / Go / C# 的东西)。Python 里"接口"是一种约定,常见三种写法,从宽松到严格:
# 写法 1:pass 占位(最宽松,纯约定,忘了实现也不会报错)
class DataLoader:
def load(self):
pass
# 写法 2:raise NotImplementedError(推荐,忘了实现会明确报错)
class DataLoader:
def load(self):
raise NotImplementedError("子类必须实现 load()")
# 写法 3:抽象基类 abc(最严格,忘了实现连实例化都不允许)→ 详见 12.6
from abc import ABC, abstractmethod
class DataLoader(ABC):
@abstractmethod
def load(self): ...# 子类按约定去实现,调用方只管调 load(),不关心具体实现是谁
class CsvLoader(DataLoader):
def load(self):
return "读 CSV 文件"
class JsonLoader(DataLoader):
def load(self):
return "读 JSON 文件"
for loader in [CsvLoader(), JsonLoader()]:
print(loader.load())
# 读 CSV 文件
# 读 JSON 文件
# 输出(需与上一段代码连着跑):
# 读 CSV 文件
# 读 JSON 文件鸭子类型:Python 的经典哲学——"如果它走起来像鸭子、叫起来像鸭子,那它就是鸭子"。 即:不检查你是什么类,只看你有没有那个方法。所以上面的
for循环能同时接受CsvLoader和JsonLoader。
④ 记住三句话就够了
class 类名:定义图纸,类名()造对象;self指"当前这个对象",方法第一个参数必须是它;- "接口"就是一份方法清单的约定,谁实现谁就能被当成它来用。
5.1 for 循环
什么是 for:for 是遍历循环——把一组数据里的元素一个一个取出来处理。 和 while 的区别:while 关心"条件还成立吗",for 关心"还有没有下一个"。
words = ["cat", "dog", "bird"]
# while 写法:自己管下标,容易出错
i = 0
while i < len(words):
print(words[i])
i += 1
# for 写法:直接拿元素,简洁得多
for w in words:
print(w)
# 输出:
# cat
# dog
# bird
# cat
# dog
# bird能放在 for ... in ... 后面的东西,叫"可迭代对象":列表、字符串、元组、字典、集合、文件、range() 都可以。
for ch in "Python": # 字符串:逐个字符
print(ch)
for k in {"a": 1}: # 字典:默认遍历"键"
print(k)
# 输出:
# P
# y
# t
# h
# o
# n
# awords = ["cat", "dog", "bird"]
for w in words:
print(w, len(w))
# cat 3 / dog 3 / bird 4
for i, w in enumerate(words): # 同时拿位置和值
print(i, w)
# 0 cat / 1 dog / 2 bird
# 输出:
# cat 3
# dog 3
# bird 4
# 0 cat
# 1 dog
# 2 bird为什么 Python 的 for 长这样? 别的语言常写 for (i = 0; i < n; i++),管的是「第几个」;Python 直接把元素本身递给你。因为绝大多数遍历只关心「处理每个东西」,压根不需要下标;真要位置,再请 enumerate() 出来。这一个小设计,省掉了无数 i < len(...) 和下标越界。
range() 也顺带说个反直觉的事实:它不会真的造出一串数字。
import sys
r = range(1_000_000)
print(r) # range(0, 1000000)
print(len(r), r[5]) # 1000000 5 ← 第 5 个是按公式算出来的
print(sys.getsizeof(r)) # 几十字节,跟范围多大无关
print(sys.getsizeof(list(r))) # 真造出列表,就是好几 MB 了
# 输出:
# range(0, 1000000)
# 1000000 5
# 48
# 8000056range 只记住起点、终点、步长,你要第几个它临时算一个。所以 for i in range(10**9): 不会撑爆内存(当然它也跑不完)。真正把一百万个数字一次性造出来的是 list(range(...)) 和列表推导式——这就是 12.9 要讲生成器的原因。
还有个从别的语言过来容易懵的点:循环变量在循环结束后还在。
for w in ["a", "b"]:
pass
print(w) # b
# 输出:
# b因为 Python 没有「块级作用域」,只有函数作用域和模块作用域(6.8 的 LEGB)。for、if、with 都不会开辟新的作用域,里面起的名字外面照样看得见,所以别在循环里随手用了外面已经有的变量名。
为什么遍历时不能改这个列表? 光记结论容易忘,看一遍过程就明白了:
words = ["cat", "dog", "bird", "bee"]
for i, w in enumerate(words):
print("这一轮拿到:", i, w)
if len(w) == 3:
words.remove(w)
print("最后:", words)
# 输出:
# 这一轮拿到: 0 cat
# 这一轮拿到: 1 bird
# 这一轮拿到: 2 bee
# 最后: ['dog', 'bird']这一轮拿到: 0 cat
这一轮拿到: 1 bird
这一轮拿到: 2 bee
最后: ['dog', 'bird']dog 从头到尾没被检查过。原因是 for 背后那个迭代器只记「下一个该给第几个」,删掉 cat 之后,dog 往前挪到了第 0 位,迭代器却已经走到第 1 位了——于是直接跨过它。索引在动、列表也在动,两边对不上。
zip() 和 enumerate() 之所以好用,也是同一个思路:让 Python 去管「配对」和「数数」,你只管处理拿到的值。它们返回的是迭代器(要一个给一个),所以数据很长时也不会先把结果全存下来。
遍历时不要直接改原列表(会漏元素),遍历副本或推导式生成新列表:
PYTHONfor w in words[:]: # 遍历切片副本 if len(w) == 3: words.remove(w) # (说明:这一段要连着上一段代码一起跑才有输出)
5.2 range()
for i in range(5): # 0 1 2 3 4(不含 5)
print(i)
list(range(2, 8)) # [2, 3, 4, 5, 6, 7]
list(range(0, 10, 2)) # [0, 2, 4, 6, 8] 步长 2
list(range(10, 0, -1)) # [10, 9, ..., 1] 倒着数
# 输出:
# 0
# 1
# 2
# 3
# 45.3 break / continue / 循环的 else
for n in range(2, 10):
for x in range(2, n):
if n % x == 0:
print(n, "=", x, "*", n // x)
break # 跳出内层循环
else:
# 循环正常结束(没有被 break)才执行
print(n, "是质数")
# 输出:
# 2 是质数
# 3 是质数
# 4 = 2 * 2
# 5 是质数
# 6 = 2 * 3
# 7 是质数
# 8 = 2 * 4
# 9 = 3 * 3for num in [1, 2, 3, 4]:
if num % 2 == 0:
continue # 跳过本轮,继续下一次
print(num) # 只打印 1, 3
# 输出:
# 1
# 3循环的
else是 Python 特色:循环没被 break 中断时才执行。
5.4 pass:看起来"什么都没做",其实很有用
为什么需要它?——因为空代码块 Python 不认
Python 靠缩进界定代码块。下面这样写会直接报错:
def todo():
# ❌ IndentationError: expected an indented block(期望一个缩进的代码块)
# (说明:这一段需要外部环境(文件 / 网络 / 第三方服务)才能跑出结果)因为函数体是空的,Python 不知道这个函数到哪儿结束。pass 就是一句"这里暂时什么都不做,但语法要合法"的占位语句——它执行时真的什么都不发生,唯一的作用是让代码能跑起来。
用法 1:先搭骨架,后填实现(最常用,强烈推荐这个习惯)
def load_data():
pass # 明天再写
def train_model():
pass # 后天再写
def save_result():
pass
# 现在整个程序可以先跑通流程、先测试调用顺序
# 再逐个把 pass 换成真正的实现就像盖房子先砌出房间格局,之后再装修。写项目时强烈建议这样"先骨架后实现",避免一开始就被细节卡住。
用法 2:明确表示"这个分支我故意什么都不做"
for name in ["a.txt", ".hidden", "b.txt"]:
if name.startswith("."):
pass # 跳过隐藏文件,这里确实不需要做什么
else:
print("处理", name)
# 输出:
# 处理 a.txt
# 处理 b.txtimport os
try:
os.remove("temp.txt")
except FileNotFoundError:
pass # 文件本来就不存在,正好是我们想要的结果,忽略即可【坑 · 很重要】 千万不要用
except: pass把错误默默"吞掉"——一旦出问题你将完全查不到原因,这是最难调试的 bug 来源。至少记录一行日志:PYTHONexcept ValueError: logging.warning("解析失败,已跳过") # 比裸 pass 好一万倍 # (说明:这一段需要外部环境(文件 / 网络 / 第三方服务)才能跑出结果)
用法 3:定义"接口"——只规定名字,实现交给子类
如果你还没看过 5.0 节的类与接口速览,建议先回去看一眼再往下读。 接口的三种写法(
pass/NotImplementedError/abc抽象基类)详见 12.6。
class DataLoader:
def load(self):
pass # 父类不实现,只是规定"子类必须有 load 方法"
class CsvLoader(DataLoader):
def load(self):
return "读 CSV 文件"
class JsonLoader(DataLoader):
def load(self):
return "读 JSON 文件"
for loader in [CsvLoader(), JsonLoader()]:
print(loader.load())
# 读 CSV 文件
# 读 JSON 文件
# 输出:
# 读 CSV 文件
# 读 JSON 文件用法 4:当一个"空容器"来装配置项
class Config:
pass # 什么都不定义,就是想要一个能挂属性的东西
config = Config()
config.debug = True
config.model = "doubao-pro"
print(config.model) # doubao-pro
# 输出:
# doubao-propass 的四个"亲戚",别搞混
| 写法 | 含义 | 能用在 |
|---|---|---|
pass | 什么都不做,继续往下执行 | 任何需要占位的地方 |
continue | 跳过本轮,进入下一轮循环 | 只能用在循环里 |
break | 直接结束整个循环 | 只能用在循环里 |
return | 结束函数并返回(或返回 None) | 只能用在函数里 |
另外:函数体里只写一个字符串(文档字符串)也能通过语法检查,效果类似
pass。但语义上它是"说明文档",不是占位,别混用。
5.5 match:不只是 switch,是"按数据的形状拆开它"
match 是 Python 3.10 才加入的新语法。如果只是判断一个值等于几,用 if/elif 更合适;match 真正的本事是:判断"这个数据长什么样",并顺手把里面的内容取出来。
① 最基础:等值匹配(就是 switch)
status = 404
match status:
case 200:
print("成功")
case 404:
print("找不到页面")
case 500:
print("服务器出错")
case _: # _ 是通配符,表示"其他所有情况"
print("未知状态")
# 输出:
# 找不到页面② 用 | 表示"或",把同类情况合并
match status:
case 200 | 201 | 204:
print("成功")
case 400 | 401 | 403:
print("客户端的问题")
case 500 | 502 | 503:
print("服务器的问题")
case _:
print("未知")
# 输出(需与上一段代码连着跑):
# 未知③ 匹配"结构"并拆出变量(这是它最有用的地方)
point = (3, 5)
match point:
case (0, 0):
print("在原点")
case (0, y):
print(f"在 Y 轴上,y = {y}")
case (x, 0):
print(f"在 X 轴上,x = {x}")
case (x, y):
print(f"坐标是 ({x}, {y})")
# 输出:
# 坐标是 (3, 5)注意
x、y会被自动绑定成里面真实的值,不用你自己去写point[0]、point[1]。
④ 匹配列表,支持"剩余项"
command = ["copy", "a.txt", "b.txt"]
match command:
case ["quit"]:
print("退出程序")
case ["copy", src, dst]:
print(f"把 {src} 复制成 {dst}")
case ["delete", *files]: # *files 收下剩下的所有项
print(f"删除这些文件:{files}")
case _:
print("识别不了这个命令")
# 输出:
# 把 a.txt 复制成 b.txt⑤ 匹配字典,直接按键取值
event = {"type": "click", "x": 10, "y": 20}
match event:
case {"type": "click", "x": x, "y": y}:
print(f"点击了位置 ({x}, {y})")
case {"type": "quit"}:
print("退出")
case _:
print("其他事件")
# 输出:
# 点击了位置 (10, 20)⑥ 加 if 守卫(更精细的条件)
match point:
case (x, y) if x == y:
print("这个点在对角线上")
case (x, y):
print(f"坐标是 ({x}, {y})")
# 输出(需与上一段代码连着跑):
# 坐标是 (3, 5)真实场景:处理 Agent / 大模型返回的不同"动作"
action = {"name": "search", "query": "Python 教程"}
match action:
case {"name": "search", "query": q}:
print("→ 去搜索:", q)
case {"name": "calculate", "expr": e}:
print("→ 去计算:", e)
case {"name": "finish", "answer": a}:
print("→ 任务完成:", a)
case _:
print("→ 未知动作,忽略")
# 输出:
# → 去搜索: Python 教程这正是后面做 Agent 时"模型决定调用哪个工具"的写法雏形。用
match写比一堆if "name" == ... and "query" in ...清爽得多。
match vs if/elif 怎么选
| 场景 | 用什么 |
|---|---|
| 简单判断一两个值、比较大小范围 | if / elif |
| 要判断"这个数据长什么样"并取出里面的字段 | match |
| 条件是复杂的逻辑组合(and/or/函数返回值) | if / elif |
5.6 【本章小结】
| 你学到了什么 | 关键记忆点 |
|---|---|
| 类 / 对象 / 接口(5.0) | 类是图纸、对象是成品;self 指自己;接口 = 方法清单的约定 |
for 循环 | 遍历"可迭代对象",一个一个取元素;比 while 更适合"有明确数据集"的场景 |
range() | range(5)、range(2, 8)、range(0, 10, 2)、倒着数 range(10, 0, -1) |
enumerate() | 同时拿位置和值:for i, w in enumerate(列表) |
| 遍历时改列表 | 遍历副本 words[:],或用推导式生成新列表 |
break / continue | 结束整个循环 / 跳过本轮;循环的 else 在"没被 break"时执行 |
pass | 占位语句:搭骨架、忽略分支、定义接口;别拿它吞异常 |
match | 按"数据的形状"匹配:等值、|、序列、字典、*剩余、if 守卫、_ 通配符 |
第 6 章 函数
【本章导览】 函数是"把代码打包复用"的第一步,也是后面写类、写装饰器的地基。这一章按顺序回答:
- 函数是什么、为什么要写函数(6.1)
- 怎么定义:
def语句逐行拆解、命名规则、函数体、文档字符串(6.2)- 怎么调用:执行流程、形参 vs 实参、返回值怎么用(6.3)
- 参数是怎么传进去的:为什么列表会被函数改掉、数字不会(6.4)
- 返回值:
None、多个返回值、提前return(6.5)- 参数的各种写法、解包传参、作用域、递归、闭包、lambda、注解、装饰器(6.6~6.14)
难度:★★★★☆(本章是全笔记最重要的一章) | 预计用时:90 分钟 | 前置知识:第 4~5 章
6.1 函数是什么?为什么要写函数?
定义:函数是一段有名字的、可以重复调用的代码块,用来完成一件确定的事。
你已经用过很多别人写好的函数了——print()、len()、input()、sum() 都是函数。写函数就是自己做一把工具给别人(和以后的自己)用。
四个必须写函数的理由
| 理由 | 说明 |
|---|---|
| 复用(DRY 原则) | 同样的代码只写一遍,用 100 次;要改也只改一处 |
| 拆分复杂度 | 一个大问题拆成若干小函数,每个函数只做一件事 |
| 便于测试和维护 | 函数有明确的输入/输出,可以单独调试 |
| 自解释 | calc_tax(price) 这个名字本身就是注释,比 10 行代码好读 |
用"榨汁机"理解函数的三要素
参数(输入) 返回值(输出)
苹果 ──▶ [ 函数名(榨汁机) ] ──▶ 苹果汁
内部怎么处理,调用者不用管(黑盒)def make_juice(fruit): # fruit 是参数(输入)
return f"{fruit}汁" # 返回值(输出)
print(make_juice("苹果")) # 苹果汁
print(make_juice("橙子")) # 橙子汁
# 输出:
# 苹果汁
# 橙子汁一句话记住:函数 = 名字 + 输入(参数)+ 加工过程(函数体)+ 输出(返回值)。 调用者只关心"传什么进去、拿什么出来",不关心里面怎么做的(这叫"封装")。
6.2 怎么定义函数:def 语句逐行拆解
语法模板
def 函数名(参数1, 参数2, ...): # ① def ② 函数名 ③ 括号参数 ④ 冒号
"""文档字符串(可选,强烈建议写)"""
函数体代码 # ⑤ 必须缩进(4 个空格)
...
return 返回值 # ⑥ 可选
# (说明:这一段需要外部环境(文件 / 网络 / 第三方服务)才能跑出结果)逐项说明:
| 组成部分 | 作用 | 注意 |
|---|---|---|
① def 关键字 | define 的缩写,告诉 Python"下面要定义函数了" | 必须小写 |
| ② 函数名 | 后面靠它调用 | 小写 + 下划线,建议动词开头:get_age / calc_sum / is_valid |
| ③ 参数列表 | 函数要处理的输入,写在括号里 | 可以没有参数:def hello(): |
④ 冒号 : | 表示"下面缩进的是函数体" | 忘了冒号是最常见的新手错误 |
| ⑤ 函数体 | 真正干活的代码 | 必须整体缩进,缩进结束 = 函数结束 |
⑥ return | 把结果交还给调用者 | 可以省略(见 6.5) |
def greet(name): # name 是"形参"(形式参数,占位的名字)
"""打招呼(这是文档字符串)"""
return f"你好,{name}"
print(greet("小明")) # "小明" 是"实参"(实际传入的值)
print(greet) # <function greet at 0x...> 函数本身也是对象(见 6.10)
# 输出:
# 你好,小明
# <function greet at 0x...>
# (说明:内存地址每次运行都不同)命名规则:和变量一样(字母/数字/下划线、不能数字开头、不能是保留字)。另外建议:
- 动词开头,让人一眼看出这个函数"干什么":
get_user()、calc_total()、is_empty() - 布尔函数用
is_/has_开头:is_valid()、has_permission() - 不要用
list、str、print这类内置名字(会把内置函数覆盖掉)
【坑】定义 ≠ 执行:写
def的时候,函数体里的代码不会运行,只是被"登记"下来。只有被调用时才执行。 另外,必须先定义、后调用——调用写在def前面会报NameError: name 'xxx' is not defined。
6.3 怎么调用函数
调用语法:函数名(实参)。括号不能省,只写 greet 拿到的是"函数这个对象本身",写 greet() 才是"执行它"。
调用时的执行流程(理解这个,调试时心里有数):
① 程序执行到 greet("小明")
② 跳进 greet 函数,把实参 "小明" 绑给形参 name
③ 从上到下执行函数体
④ 遇到 return(或函数体走完)→ 带着结果跳回调用处
⑤ 继续往下执行def add(a, b):
return a + b
result = add(1, 2) # ✅ 用变量接住返回值
print(result) # 3
add(1, 2) # ❌ 返回值没被接收,算完就丢了(不会报错,但结果没了)
print(add(1, 2) + 10) # ✅ 返回值可以直接参与运算 → 13
print(add(add(1, 2), 3))# ✅ 函数的返回值可以再当参数 → 6
# 输出:
# 3
# 13
# 6形参 vs 实参(面试爱问,其实很简单)
def greet(name): # name 是"形参"(parameter):定义时占位的名字
...
greet("小明") # "小明" 是"实参"(argument):调用时真正传进去的值函数里可以调用别的函数(甚至可以调自己,见 6.9 递归)
def area(w, h):
return w * h
def describe(w, h):
return f"面积是 {area(w, h)}" # 直接调用上面那个函数
print(describe(3, 4)) # 面积是 12
# 输出:
# 面积是 126.4 参数是怎么传进去的(重点,也很容易踩坑)
一句话结论:Python 传的是"对象的引用"(可以理解为把标签复制了一份给你)。 所以——在函数里"改对象的内容"会影响外面;"重新赋值"不会影响外面。
情况 A:传入不可变对象(数字、字符串、元组)→ 外面不受影响
def add_ten(n):
n = n + 10 # 这是"重新赋值":让 n 指向一个新数字
print("函数内:", n)
x = 5
add_ten(x) # 函数内:15
print("函数外:", x) # 5 ← x 没变
# 输出:
# 函数内: 15
# 函数外: 5情况 B:传入可变对象(列表、字典、集合)→ 改内容会影响外面!
def add_item(lst):
lst.append("新元素") # 这是"修改对象内容",改的是同一个列表
my_list = ["a"]
add_item(my_list)
print(my_list) # ['a', '新元素'] ← 外面的列表真的被改了!
# 输出:
# ['a', '新元素']不想被改怎么办?传一份副本进去
def add_item_safe(lst):
lst = lst[:] # 先复制一份(或 list(lst)),后面只改副本
lst.append("新元素")
return lst
my_list = ["a"]
new_list = add_item_safe(my_list)
print(my_list) # ['a'] ← 原列表没动
print(new_list) # ['a', '新元素']
# 输出:
# ['a']
# ['a', '新元素']对比表
| 你在函数里做的事 | 外面的变量会不会变 |
|---|---|
n = n + 1(给参数重新赋值) | ❌ 不会 |
lst.append(x)(改对象内容) | ✅ 会 |
lst[0] = 9(改对象内容) | ✅ 会 |
lst = lst[:] 之后再改 | ❌ 不会(改的是副本) |
实战建议:如果一个函数会修改传进来的列表,一定要在函数文档里写清楚,否则调用者会很崩溃。 更稳妥的做法是"不改输入,返回新值"(像
sorted()那样), Side effect 越少越好调试。
《从入门到实践》里给了个很实用的中间方案:调用时传一份副本。比如「把待打印的模型清单交给打印函数,打印完原清单还要留着」:
def print_models(models):
for m in models:
print("打印:", m)
models = ["phone", "case", "charger"]
print_models(models[:]) # 传切片副本(或直接 list(models))
print("原清单还在:", models)
# 输出:
# 打印: phone
# 打印: case
# 打印: charger
# 原清单还在: ['phone', 'case', 'charger']打印: phone
打印: case
打印: charger
原清单还在: ['phone', 'case', 'charger']一个 [:] 就把「这份数据后面还有用」写在了脸上。代价是复制了一份,但列表不大时几乎感觉不到。反过来,如果函数本来就该改这份数据(比如往购物车里加东西),那就大大方方地改,并在函数名和文档里说清楚。真正难维护的是「看不出会不会改」的那种函数。
6.5 返回值:return 的各种情况
# ① 不写 return → 默认返回 None
def say_hi():
print("hi")
print(say_hi()) # hi / None
# ② 写了 return 但不跟值 → 也是 None(常用来"提前结束函数")
def check(age):
if age < 0:
return # 提前退出
print("年龄合法")
# ③ return 后面的代码不会执行
def f():
return 1
print("永远不会被打印")
# ④ 可以有多个 return(守卫式写法,很常用)
def level(score):
if score >= 90:
return "优秀"
if score >= 60:
return "及格"
return "不及格"
# ⑤ 返回多个值 —— 其实是打包成一个元组
def get_point():
return 116.4, 39.9 # 等价于 return (116.4, 39.9)
x, y = get_point() # 解包接收
print(x, y) # 116.4 39.9
print(type(get_point())) # <class 'tuple'>
# 输出:
# hi
# None
# 116.4 39.9
# <class 'tuple'>【重点】 函数执行到
return就立刻结束,不管后面还有什么。 想返回"没有结果"就return None或直接return——调用方拿到的都是None。
6.6 参数的各种写法(重点)
# ① 默认值参数
def greet(name, greeting="你好"):
return f"{greeting},{name}"
print(greet("小明")) # 你好,小明
print(greet("小明", "早上好")) # 早上好,小明
# ② 关键字参数(指定名字传,顺序可打乱)
print(greet(greeting="Hi", name="Tom"))
# ③ 任意个位置参数 *args
def total(*nums):
return sum(nums)
print(total(1, 2, 3)) # 6
# ④ 任意个关键字参数 **kwargs
def show(**info):
for k, v in info.items():
print(k, v)
show(name="小明", age=18)
# name 小明
# age 18
# 输出:
# 你好,小明
# 早上好,小明
# Hi,Tom
# 6
# name 小明
# age 18
# (说明:耗时与机器性能有关,数值会不同)【坑】默认参数不要用可变对象:
PYTHONdef bad(x, lst=[]): # ❌ 多次调用会共用同一个列表 lst.append(x) return lst def good(x, lst=None): # ✅ 正确写法 lst = lst if lst is not None else [] lst.append(x) return lst
特殊参数(读框架源码会遇到)
def f(pos_only, /, standard, *, kwd_only):
print(pos_only, standard, kwd_only)
f(1, 2, kwd_only=3) # ✅
# f(pos_only=1, ...) # ❌ / 前面的只能按位置传
# f(1, 2, 3) # ❌ * 后面的只能按关键字传
# 输出:
# 1 2 3*args / **kwargs 到底用来干什么?(不是炫技,是刚需)
用途 1:写"转发型"函数——我不知道别人会传什么,原样交给下一个函数
def log_call(func):
def wrapper(*args, **kwargs): # 不管传什么,全接住
print("准备调用:", func.__name__)
return func(*args, **kwargs) # 再原样转交给真正的函数
return wrapper
@log_call
def add(a, b):
return a + b
print(add(1, 2)) # 准备调用:add → 3
# 输出:
# 准备调用: add
# 3这就是装饰器的标准写法。如果没有
*args/**kwargs,装饰器就只能适配固定参数个数的函数,没法通用。
用途 2:做通用工具,参数个数随意
def my_max(*args): # 2 个、3 个、100 个参数都能算
return max(args)
print(my_max(1, 5, 3)) # 5
def make_url(**parts): # 调用方想传几个字段都行
return "/".join(f"{k}={v}" for k, v in parts.items())
print(make_url(page=1, size=20)) # page=1/size=20
# 输出:
# 5
# page=1/size=20
# (说明:耗时与机器性能有关,数值会不同)6.7 解包传参
def add(a, b, c):
return a + b + c
args = (1, 2, 3)
print(add(*args)) # 6 用 * 把元组拆开
kwargs = {"a": 1, "b": 2, "c": 3}
print(add(**kwargs)) # 6 用 ** 把字典拆开
# 输出:
# 6
# 66.8 变量的作用域:函数里能看见哪些变量
定义:作用域(scope)就是"一个变量名能被看见、能被使用的范围"。
Python 查找一个名字时,按 LEGB 顺序依次找,找到就停:
| 缩写 | 范围 | 例子 |
|---|---|---|
| L Local | 函数内部 | 函数里定义的变量、参数 |
| E Enclosing | 外层嵌套函数 | 闭包里外层函数的变量(见 6.10) |
| G Global | 模块(文件)顶层 | 文件开头定义的变量 |
| B Built-in | Python 内置 | print、len、sum |
x = 10 # 全局(G)
def outer():
y = 20 # 外层函数的局部(对 inner 来说就是 E)
def inner():
z = 30 # 局部(L)
print(x, y, z) # 能读到外面的:10 20 30
inner()
outer()
# print(z) # ❌ NameError:外面看不见函数里的 z
# 输出:
# 10 20 30想在函数里"改"全局变量 → 必须 global 声明
count = 0
def increase():
global count # 声明:我要改的是外面那个 count,不是新建局部的
count += 1
increase()
print(count) # 1
# 输出:
# 1只读不写不需要
global:函数里print(x)读全局变量没问题;一旦写了x = ...,Python 就认为你在定义局部变量,此时先读后写会报UnboundLocalError。
嵌套函数里改外层变量 → 用 nonlocal
def counter():
n = 0
def add():
nonlocal n # 改的是外层函数的 n,不是全局变量
n += 1
return n
return add
c = counter()
print(c(), c(), c()) # 1 2 3
# 输出:
# 1 2 3建议:少用
global(会让代码难追踪)。更推荐"用参数传进去、用 return 传出来"。
6.9 递归:函数自己调用自己
定义:递归就是函数在内部调用自己,把一个大问题拆成"更小的同类问题"。
写递归只要抓住两个要素:
- 基线条件(什么时候停):问题小到可以直接给出答案,不再递归——忘了它就是无限递归。
- 递归条件(怎么变小):把原问题变成规模更小的同类问题。
# 阶乘:5! = 5 × 4 × 3 × 2 × 1
def factorial(n):
if n == 1: # ① 基线条件
return 1
return n * factorial(n - 1) # ② 递归条件:规模每次减 1
print(factorial(5)) # 120
# 输出:
# 120# 斐波那契数列(递归写法很直观,但效率低,实战用循环或缓存)
def fib(n):
if n <= 1:
return n
return fib(n - 1) + fib(n - 2)
print([fib(i) for i in range(10)]) # [0,1,1,2,3,5,8,13,21,34]
# 输出:
# [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]递归 vs 循环怎么选
| 场景 | 建议 |
|---|---|
| 问题本身就是"层层嵌套"的(目录树、JSON 树、语法解析) | 递归,代码短得多 |
| 简单的累加、遍历 | 循环,更快也更省内存 |
| 递归深度可能超过 1000 | 必须改成循环(Python 默认上限约 1000 层,超了报 RecursionError) |
递归每层调用都会占用栈空间,且 Python 不做尾递归优化。能用循环写清楚的,优先循环。
6.10 函数是"一等对象":可以当变量传来传去
什么叫一等对象:函数和其他数据(数字、字符串)一样,可以——
def shout(text):
return text.upper() + "!"
# ① 赋值给变量
yell = shout
print(yell("hello")) # HELLO!
# ② 放进列表 / 字典
funcs = [shout, len, str]
print(funcs[0]("hi")) # HI!
# ③ 当作参数传给另一个函数(回调函数)
def apply(func, value):
return func(value)
print(apply(shout, "hi")) # HI!
print(apply(len, "hello")) # 5
# ④ 当作返回值返回(这是装饰器的基础,见 6.14)
def get_func():
return shout
# 输出:
# HELLO!
# HI!
# HI!
# 5闭包(closure):一个内层函数,记住了外层函数的变量,即使外层函数已经执行完。
def make_multiplier(n): # 外层函数:负责"生产"函数
def multiplier(x): # 内层函数:记住了 n
return x * n
return multiplier # 返回内层函数(注意:不带括号!)
times3 = make_multiplier(3)
times10 = make_multiplier(10)
print(times3(5)) # 15
print(times10(5)) # 50
# 输出:
# 15
# 50闭包的价值:用函数"记住"一份配置。
times3和times10是同一个模板造出来的不同版本。 这是装饰器(6.14)和很多框架回调写法的底层原理。
闭包的一个经典坑:循环里创建闭包
# ❌ 想要 [×0, ×1, ×2],结果全是 ×2
funcs = []
for i in range(3):
funcs.append(lambda: i) # lambda 记住的是"变量 i",不是当时 i 的值
print([f() for f in funcs]) # [2, 2, 2]
# ✅ 用默认参数把当前值"固定"下来
funcs = []
for i in range(3):
funcs.append(lambda i=i: i) # 默认参数在定义时就绑定了值
print([f() for f in funcs]) # [0, 1, 2]
# 输出:
# [2, 2, 2]
# [0, 1, 2]6.11 lambda 匿名函数
square = lambda x: x * x
print(square(5)) # 25
pairs = [(1, "one"), (2, "two"), (3, "three")]
pairs.sort(key=lambda p: p[1]) # 按第二个元素排序
print(pairs) # [(1,'one'), (3,'three'), (2,'two')]
# 输出:
# 25
# [(1, 'one'), (3, 'three'), (2, 'two')]什么时候用 lambda、什么时候不用
| 情况 | 建议 |
|---|---|
| 一句话就能写完的小转换(排序 key、简单映射) | 用 lambda |
需要多行逻辑、if、循环,或要被多处复用 | 用 def |
| 需要写文档字符串、需要被单独测试 | 用 def |
判断标准很简单:能不能在一行里写完?能就用 lambda,不能就用
def。
lambda 最常见的三个搭档
students = [("小明", 18), ("小红", 20), ("小李", 19)]
# ① sorted(key=...) 指定按什么排序
print(sorted(students, key=lambda s: s[1])) # 按年龄排
# [('小明', 18), ('小李', 19), ('小红', 20)]
# ② map() 对每个元素做转换
print(list(map(lambda s: s[0], students))) # ['小明', '小红', '小李']
# ③ filter() 过滤
print(list(filter(lambda s: s[1] >= 19, students))) # 年龄 ≥19 的
# [('小红', 20), ('小李', 19)]
# 输出:
# [('小明', 18), ('小李', 19), ('小红', 20)]
# ['小明', '小红', '小李']
# [('小红', 20), ('小李', 19)]这几个用推导式往往更 Pythonic:
[s[0] for s in students]、[s for s in students if s[1] >= 19]—— 两种写法都要认识。
6.12 文档字符串与注解
def area(width: float, height: float) -> float:
"""计算矩形面积。
参数:
width: 宽
height: 高
返回:
面积
"""
return width * height
print(area.__doc__) # 查看文档字符串
print(area.__annotations__) # {'width': <class 'float'>, ...}
# 输出:
# 计算矩形面积。
#
# 参数:
# width: 宽
# height: 高
# 返回:
# 面积
#
# {'width': <class 'float'>, 'height': <class 'float'>, 'return': <class 'float'>}
# (说明:集合是无序的,每次打印的顺序都可能不同)注解到底有没有用? 先说清最容易误解的一点:它不会做类型检查,写错了照样跑。
def greet(name: str, times: int = 1) -> str:
return "\n".join([f"你好,{name}"] * times)
print(greet("小明", 2)) # 你好,小明(两行)
print(greet(123)) # 你好,123 ← 传了 int 也不报错
# 输出:
# 你好,小明
# 你好,小明
# 你好,123name: str 只是贴在名字上的一张便签,给人和工具看的。Python 自己不读它,编辑器靠它补全、提示类型不对,mypy / pyright 这类工具靠它做静态检查。那为什么现代 Python 代码里几乎人人都在写?因为框架会读它:
# FastAPI 里的样子(先看个大概,不用现在跑)
from fastapi import FastAPI
app = FastAPI()
@app.get("/users/{uid}")
def get_user(uid: int, name: str = "匿名"):
return {"uid": uid, "name": name}
# (说明:需要先装第三方库:pip install fastapi)FastAPI 在启动时把 uid: int 这张便签读走,于是知道「URL 里的 uid 要转成整数、转不了就自动返回 422」,还顺手把接口文档生成出来。在这类框架里,注解从「备注」变成了「配置」——这也是你后面写接口时要认真写注解的原因。
写法上再记两条版本变化:3.9 起可以直接写内置泛型 list[str]、dict[str, int],不用再 from typing import List, Dict;3.10 起「可以是 X 也可以是 None」写成 str | None,比 Optional[str] 好读。这两条在 3.15 上都是日常写法。
6.13 编码风格(PEP 8 精简版)
- 缩进用 4 个空格,不用 Tab
- 每行尽量不超过 79 字符
- 函数和类之间空两行,类内方法之间空一行
- 命名:变量/函数用
lower_case_with_underscores,类名用CapWords,常量用ALL_CAPS - 运算符两边和逗号后面加空格:
x = a + b
6.14 装饰器(官方教程未涵盖,但你必须会)
为什么要有装饰器:想给一个函数加上"计时 / 记日志 / 鉴权"这类通用功能,但不想改动函数内部的代码。装饰器就是干这个的。
先看效果
import time
from functools import wraps
def timer(func): # 装饰器:接收一个函数
@wraps(func) # 保留原函数的名字和文档(好习惯,不加会把名字改成 wrapper)
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs) # 真正调用原函数
print(f"{func.__name__} 耗时 {time.time() - start:.2f} 秒")
return result
return wrapper # 返回"加了料"的新函数
@timer # ← 这一行就是装饰器
def slow():
"""一个慢函数"""
time.sleep(0.5)
return "做完了"
print(slow())
# 输出:
# slow 耗时 0.51 秒
# 做完了
# (说明:耗时与机器性能有关,数值会不同)关键理解:@timer 到底做了什么
@timer
def slow(): ...
# 上面这两行,完全等价于:
def slow(): ...
slow = timer(slow) # 把原函数交给 timer,拿回一个新函数,再挂回同名变量
# (说明:这一段要连着上一段代码一起跑才有输出)所以装饰器本质上就是一个"接收函数、返回函数"的函数。
@只是让这行代码更好看的语法糖。
带参数的装饰器(进阶,认识写法即可)
def repeat(n): # 外层接收参数
def decorator(func): # 中层接收函数
@wraps(func)
def wrapper(*args, **kwargs):
for _ in range(n):
result = func(*args, **kwargs)
return result
return wrapper
return decorator
@repeat(3) # 执行 3 次
def hello():
print("你好")
hello() # 打印三遍"你好"
# (说明:这一段要连着上一段代码一起跑才有输出)装饰器在现实中都用在哪(你会天天见到)
| 场景 | 例子 |
|---|---|
| 注册 Web 路由 | @app.get("/hello")(FastAPI) |
| 暴露 MCP 工具 | @mcp.tool() |
| 计时 / 性能统计 | 上面的 timer |
| 登录鉴权 | @login_required |
| 自动重试 | @retry(times=3) |
| 缓存结果 | @lru_cache |
记住一句话:看到
@xxx写在函数/类上面,就表示"用 xxx 把这个函数加工一下"。
6.15 【本章小结】
| 你学到了什么 | 关键记忆点 |
|---|---|
| 函数是什么 | 有名字、可重复调用的代码块;三要素 = 名字 + 参数 + 返回值 |
| 定义语法 | def 名(参数): + 缩进函数体 + 可选 return;冒号和缩进不能忘 |
| 调用 | 函数名(实参);返回值要接住;形参是占位的名字,实参是真正的值 |
| 参数传递 | 传的是"对象引用":重新赋值不影响外面,改内容会影响外面 |
| 返回值 | 不写 return → None;return 后立刻结束;返回多个值其实是元组 |
| 参数写法 | 默认值、关键字、*args、**kwargs、/ 前只能位置传、* 后只能关键字传 |
| 作用域 | LEGB;改全局要 global,改外层嵌套变量要 nonlocal |
| 递归 | 基线条件 + 递归条件;深度上限约 1000 |
| 一等对象 / 闭包 | 函数能赋值、入参、返回;闭包 = 内层函数记住外层变量 |
| lambda | 一行能写完的小函数用 lambda,否则用 def |
| 装饰器 | @deco 等价于 f = deco(f),用来"不改原函数"地加功能 |
第 7 章 数据结构(核心章)
【本章导览】 列表只是开始,Python 还有三种常用容器,用对了能少写一半代码:
- 四种容器横向对比:什么时候用 list / tuple / dict / set。
- 元组:不可变、能当字典键、单元素必须加逗号。
- 集合:自动去重、
in判断极快、交并差运算。- 字典:键值对、增删改查、
get()、遍历方式、推导式。- 循环技巧:
enumerate/zip/items()/sorted/reversed。- 条件与比较:链式比较、
in、is、del的三种删除方式对比。难度:★★★☆☆ | 预计用时:60 分钟 | 前置知识:第 3 章(列表)
7.1 四种容器全景对比
| 容器 | 写法 | 有序 | 可变 | 元素可重复 | 能当字典键 |
|---|---|---|---|---|---|
| list 列表 | [1, 2] | 有 | 能 | 是 | 不能 |
| tuple 元组 | (1, 2) | 有 | 不能 | 是 | 能 |
| dict 字典 | {"a": 1} | 有(插入序) | 能 | 键不可重复 | 不能 |
| set 集合 | {1, 2} | 无 | 能(增删) | 自动去重 | 不能 |
7.2 元组 tuple
t = (1, 2, 3)
print(t[0], len(t), t[-1]) # 1 3 3
# t[0] = 9 # ❌ TypeError:元组不可改
empty = ()
single = (1,) # ⚠️ 单个元素必须加逗号!
also_single = 1, # 不加括号也行
x, y = (10, 20) # 解包
def get_point():
return 116.4, 39.9 # 返回多个值,其实是元组
a, b = get_point()
# 输出:
# 1 3 3tuple 的"不可变"是浅层的:里面装了 list 时,list 内部仍可改。
PYTHONt = ([1, 2], "a") t[0].append(3) # 可以!→ ([1, 2, 3], 'a')
7.3 集合 set
【先看这一句】集合是无序的,下面示例注释里写出的元素顺序只是某一次运行的结果;你自己跑出来顺序不一样是正常的。判断两个集合是否相等请用
==或集合运算,不要去比对打印出来的顺序。
basket = {"apple", "orange", "apple", "pear"}
print(basket) # {'apple', 'orange', 'pear'} 自动去重
print("apple" in basket) # True 判断存在,比列表快得多
a = set("abracadabra")
b = set("alacazam")
print(a - b) # 差集:在 a 不在 b → {'r', 'd', 'b'}
print(a | b) # 并集 → {'a','c','r','d','b','m','z','l'}
print(a & b) # 交集 → {'a', 'c'}
print(a ^ b) # 对称差(只在一个里)→ {'r','d','b','m','z','l'}
print({x for x in "abracadabra" if x not in "abc"}) # 集合推导式 → {'r','d'}
# 输出:
# {'apple', 'pear', 'orange'}
# True
# {'b', 'd', 'r'}
# {'b', 'a', 'c', 'z', 'd', 'r', 'l', 'm'}
# {'a', 'c'}
# {'b', 'r', 'z', 'm', 'd', 'l'}
# {'d', 'r'}
# (说明:集合是无序的,每次打印的顺序都可能不同)7.4 字典 dict
tel = {"jack": 4098, "sape": 4139}
tel["guido"] = 4127 # 新增
del tel["sape"] # 删除
print(tel["jack"]) # 4098
print(tel.get("nobody")) # None 不存在不报错
print(tel.get("nobody", 0)) # 0 可指定默认值
print(list(tel)) # ['jack', 'guido'] 所有键
print(sorted(tel)) # ['guido', 'jack'] 排序后的键
print("jack" in tel) # True
tel.setdefault("mary", 5000) # 没有就设默认值并返回
# 构造字典的其他方式
dict([("a", 1), ("b", 2)]) # {'a': 1, 'b': 2}
dict(a=1, b=2) # {'a': 1, 'b': 2}
{x: x**2 for x in (2, 4, 6)} # {2: 4, 4: 16, 6: 36} 字典推导式
# 输出:
# 4098
# None
# 0
# ['jack', 'guido']
# ['guido', 'jack']
# True遍历字典的四种姿势。默认给你的是键,想要值、想要键值对都得明说:
user = {"name": "小明", "age": 18, "city": "杭州"}
print(list(user)) # ['name', 'age', 'city'] ← 直接遍历就是键
print(list(user.keys())) # 同上,写全更清楚
print(list(user.values())) # ['小明', 18, '杭州']
print(list(user.items())) # [('name', '小明'), ('age', 18), ('city', '杭州')]
for k, v in user.items(): # 键和值一起拿,最常用
print(k, "=", v) # name = 小明 / age = 18 / city = 杭州
for k in sorted(user): # 想按字母顺序遍历,先给键排个序
print(k, "→", user[k])
# 输出:
# ['name', 'age', 'city']
# ['name', 'age', 'city']
# ['小明', 18, '杭州']
# [('name', '小明'), ('age', 18), ('city', '杭州')]
# name = 小明
# age = 18
# city = 杭州
# age → 18
# city → 杭州
# name → 小明
# (说明:耗时与机器性能有关,数值会不同)3.7 起字典正式保证按插入顺序保存,所以先放进去的键会先被遍历到;但「按大小排」仍然要自己 sorted()。
.keys() / .values() / .items() 返回的不是列表,是视图。这词听着玄,其实就一扇窗:
v = user.values()
user["age"] = 19
print(list(v)) # ['小明', 19, '杭州'] ← 窗外的字典变了,看到的内容跟着变
# 输出(需与上一段代码连着跑):
# ['小明', 19, '杭州']为什么这么设计?因为没必要为了遍历一次就把所有值复制一份,字典有几万条时省得很明显。想真的存一份下来,用 list(...) 包一下就行。
值的去重也是常见需求,set() 一行搞定:
favorites = {"小明": "Python", "小红": "Go", "小李": "Python"}
print(set(favorites.values())) # {'Go', 'Python'}(顺序不保证)
for lang in sorted(set(favorites.values())): # 去重后再排序
print("有人喜欢", lang)
# 输出:
# {'Python', 'Go'}
# 有人喜欢 Go
# 有人喜欢 Python
# (说明:集合是无序的,每次打印的顺序都可能不同)为什么字典查得快、又为什么列表不能当键? 打个比方:列表找东西像从第一个抽屉翻起,字典则给每个键算一个「柜子编号」,直接去那个柜子拿,跟柜子里有多少东西基本无关。代价是键必须能算出稳定不变的编号(这叫「可哈希」):
d = {}
# d[[1, 2]] = "x" # TypeError: unhashable type: 'list'
d[(1, 2)] = "x" # 元组不可变,可以当键
print(d) # {(1, 2): 'x'}
# 输出:
# {(1, 2): 'x'}列表能改,改完「编号」就不对了,之前存的东西再也找不回来,所以 Python 干脆不让列表当键。字符串、数字、元组不可变,都能当键。你写接口时从 JSON 里拿到的键一律是字符串,原因也在这。
真实数据长什么样:嵌套。入门书里字典常是 {"a": 1} 这种玩具,可实际从接口、数据库、配置文件里拿来的数据几乎都长这样:
users = [
{"name": "小明", "age": 18, "skills": ["Python", "SQL"]},
{"name": "小红", "age": 20, "skills": ["FastAPI", "Git"]},
]
for u in users:
print(f"{u['name']}({u['age']} 岁)会 {', '.join(u['skills'])}")
# 输出:
# 小明(18 岁)会 Python, SQL
# 小红(20 岁)会 FastAPI, Git小明(18 岁)会 Python, SQL
小红(20 岁)会 FastAPI, Git能看懂这个结构,读 API 文档就不慌了。常见的套法就三种:
# ① 列表里放字典:一堆记录,相当于表格的行(上面的 users)
# ② 字典里放列表:一个键对应多个值
teams = {"A 组": ["小明", "小李"], "B 组": ["小红"]}
print(teams["A 组"][0]) # 小明 ← 先按键取列表,再按位置取元素
# ③ 字典里放字典:用 id 当键,随手就能按 id 找到人
by_id = {1: {"name": "小明", "age": 18}, 2: {"name": "小红", "age": 20}}
print(by_id[1]["name"]) # 小明
# 输出:
# 小明
# 小明
# (说明:耗时与机器性能有关,数值会不同)第三种为什么常用?因为列表里找 id 为 1 的人得从头翻一遍,字典一步就到。所以接口返回「一堆对象」时给列表,返回「按 id 索引」时给字典,两种都很常见。
改嵌套数据的方式是「一层一层点进去」:
for u in users:
u["skills"].append("Docker")
print(users[0]["skills"]) # ['Python', 'SQL', 'Docker']
# 输出(需与上一段代码连着跑):
# ['Python', 'SQL', 'Docker']留个心眼:这改的是里面那个列表对象。3.6 说过浅拷贝只复制外层,所以复制这种嵌套数据时要用 copy.deepcopy()。
7.5 循环技巧(必会)
# 字典:items()
for k, v in tel.items(): ...
# 序列:enumerate() 带序号
for i, v in enumerate(["a", "b", "c"]):
print(i, v)
# 同时遍历两个序列:zip()
questions = ["name", "age"]
answers = ["小明", 18]
for q, a in zip(questions, answers):
print(f"{q} 是 {a}")
# 反向:reversed()
for x in reversed([1, 2, 3]): print(x) # 3 2 1
# 排序遍历:sorted()
for x in sorted([3, 1, 2]): print(x) # 1 2 3
# 去重 + 排序
for x in sorted(set([3, 1, 3, 2])): print(x) # 1 2 3
# 输出(需与上一段代码连着跑):
# 0 a
# 1 b
# 2 c
# name 是 小明
# age 是 18
# 3
# 2
# 1
# 1
# 2
# 3
# 1
# 2
# 3字典用熟之后,最常做的三件事
第一件是分组:把一堆数据按某个字段归到不同列表里。手写要先判断「这个键有没有」,用 setdefault() 就省了:
pairs = [("小明", "A"), ("小红", "B"), ("小李", "A")]
groups = {}
for name, team in pairs:
groups.setdefault(team, []).append(name)
print(groups) # {'A': ['小明', '小李'], 'B': ['小红']}
# 输出:
# {'A': ['小明', '小李'], 'B': ['小红']}
# (说明:集合是无序的,每次打印的顺序都可能不同)setdefault(team, []) 的意思是「有就取出来,没有就先放个空列表再取出来」,所以拿到的一定是个能 append 的列表。标准库里还有个更省事的:
from collections import defaultdict
groups = defaultdict(list)
for name, team in pairs:
groups[team].append(name) # 键不存在?自动帮你造个空列表
print(dict(groups)) # {'A': ['小明', '小李'], 'B': ['小红']}
# 输出(需与上一段代码连着跑):
# {'A': ['小明', '小李'], 'B': ['小红']}这里正好能看清 get() 的边界:它只管「取」,不管「存」。
d = {}
d.get("tags", []).append("a") # 默认值是临时造出来的,没人把它放回字典
print(d) # {} ← 白加了
# 输出:
# {}想「取不到就创建」,用 setdefault() 或 defaultdict,别指望 get()。
第二件是计数。手动统计词频时,一般要写 counter[w] = counter.get(w, 0) + 1,标准库给了一行版:
from collections import Counter
words = "hello python hello world".split()
c = Counter(words)
print(c) # Counter({'hello': 2, 'python': 1, 'world': 1})
print(c.most_common(2)) # [('hello', 2), ('python', 1)]
print(c["hello"]) # 2 ← 不存在的键返回 0,不会报错
# 输出:
# Counter({'hello': 2, 'python': 1, 'world': 1})
# [('hello', 2), ('python', 1)]
# 2
# (说明:集合是无序的,每次打印的顺序都可能不同)统计词频、统计接口返回的状态码、算购物清单数量,都是同一件事。
第三件是合并和按值排序:
a = {"x": 1, "y": 2}
b = {"x": 9, "z": 3}
print(a | b) # {'x': 9, 'y': 2, 'z': 3} 3.9 起,重名时右边说了算
a.update(b) # 结果一样,但 a 自己被改了
print(a) # {'x': 9, 'y': 2, 'z': 3}
scores = {"小明": 88, "小红": 95, "小李": 72}
print(sorted(scores, key=scores.get)) # ['小李', '小明', '小红']
# 输出:
# {'x': 9, 'y': 2, 'z': 3}
# {'x': 9, 'y': 2, 'z': 3}
# ['小李', '小明', '小红']
# (说明:集合是无序的,每次打印的顺序都可能不同)| 造新字典、update() 就地改,跟 sorted() 和 .sort() 的关系一模一样。按值排序那行看着绕,其实 key=scores.get 就是对「每个键」取出它的分数,再按分数给键排队——想拿「人 + 分数」就再遍历一次:
for name in sorted(scores, key=scores.get, reverse=True):
print(name, scores[name])
# 输出(需与上一段代码连着跑):
# 小红 95
# 小明 88
# 小李 72小红 95
小明 88
小李 727.6 条件控制与比较
if/while的完整语法见 第 4 章,这一节是在容器上的应用与 Python 特色写法。
# 链式比较(Python 特色)
if 1 < x < 10: ... # 等价于 1 < x and x < 10
# 成员判断
if "a" in ["a", "b"]: ...
if "a" not in "xyz": ...
# is 判断"是不是同一个对象"(None 必须用 is)
if x is None: ...
# and / or / not
if a and not b: ...
# 序列比较:按字典序逐项比
print((1, 2) < (1, 3)) # True
print([1, 2, 3] < [1, 2, 4]) # True
# (说明:这一段要连着上一段代码一起跑才有输出)【重点】
is比较"是不是同一个东西",==比较"值是否相等"。判断 None 用is None。
7.7 del 语句
a = [1, 2, 3, 4, 5]
del a[0] # 删一个元素 → [2,3,4,5]
del a[1:3] # 删切片 → [2,5]
del a[:] # 清空 → []
# del a # 连变量一起删掉(之后再引用会报 NameError)
d = {"a": 1, "b": 2}
del d["a"] # 删字典的键 → {'b': 2}del vs pop vs remove:到底该用哪个?
| 你想干什么 | 用什么 | 返回值 |
|---|---|---|
| 按位置删,并且要用被删的值 | a.pop(i) | 有(被删的元素) |
| 删最后一个(当栈用) | a.pop() | 有 |
| 按值删(只知道内容,不知道位置) | a.remove(v) | 无 |
| 按位置/切片删,不需要那个值 | del a[i] | 无 |
| 删一整段 | del a[1:3] | 无 |
| 删字典的键 | del d[key] 或 d.pop(key) | del 无 / pop 有 |
| 把变量本身删掉 | del a | 无 |
简单记:要拿回被删的值就用
pop,纯粹删掉就用del。del a删的是"标签"本身(对象没人引用后会被 Python 自动回收),日常很少用。
7.8 【本章小结】
| 你学到了什么 | 关键记忆点 |
|---|---|
| 四种容器 | list 可变有序;tuple 不可变、可当字典键;set 无序且去重;dict 键值对(键唯一) |
| tuple | 单元素必须写 (1,);"不可变"是浅层的(里面装 list 仍能改) |
| set | in 判断比列表快得多;- 差集、| 并集、& 交集、^ 对称差 |
| dict | d[k] 取(不存在报错)vs d.get(k, 默认)(安全);setdefault;items() 遍历 |
| 推导式 | 列表 [...]、集合 {...}、字典 {k: v for ...} |
| 循环技巧 | enumerate 带序号、zip 配对、sorted 排序遍历、reversed 反向 |
| 比较 | 链式 1 < x < 10;in / not in;is 比身份、== 比值,判断 None 用 is None |
| 删除 | 要拿回值用 pop,纯删用 del,按值删用 remove,删变量用 del a |
第 8 章 常用内置函数与关键字(保留字)
【本章导览】 前面章节零散用到的
len()、range()、enumerate()到底都是些什么?这一章一次讲清:
- 内置函数和关键字分别是什么,怎么区分它们和普通函数。
- 35 个关键字总览:每个单词什么意思、在哪一章学的。
- 常用内置函数按用途逐个详解(输入输出 / 类型转换 / 数学 / 序列迭代 / 判断 / 函数式 / 对象)。
- 高频内置函数的参数技巧与常见坑(
key=、start=、map/filter返回迭代器等)。难度:★★☆☆☆(偏查表,建议当工具章反复回看) | 预计用时:40 分钟
8.1 内置函数、关键字:两个基础概念
| 概念 | 定义 | 怎么识别 | 例子 |
|---|---|---|---|
| 内置函数(built-in function) | Python 自带、打开解释器就能用、不需要 import 的函数 | 直接用,名字后跟括号 | print()、len()、range()、sum() |
| 关键字 / 保留字(keyword) | Python 语法本身占用的单词,有固定含义 | 不能当变量名、函数名 | if、for、def、class、return |
| 标准库函数 | 属于某个模块,必须 import 才能用 | 前面有模块名 | math.sqrt()、os.listdir() |
len("abc") # ✅ 内置函数:直接能用
# math.sqrt(4) # ❌ NameError:要先 import math
# if = 3 # ❌ SyntaxError:关键字不能当变量名
# len = 3 # ⚠️ 能赋值,但会把内置 len 覆盖掉,千万别这么干遇到不会的函数怎么办?三个自带"说明书"
help(len) # 看官方说明文档(交互模式里最常用)
dir(__builtins__) # 列出所有内置名字
dir(str) # 列出字符串所有可用方法
import keyword
print(keyword.kwlist) # 列出所有关键字
print(keyword.iskeyword("if")) # True
# 输出:
# Help on built-in function len in module builtins:
#
# len(obj, /)
# Return the number of items in a container.
#
# ['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']
# True
# (说明:这一段要连着上一段代码一起跑才有输出)学习方法:不要背。用到时查这一章或附录 B,用得多了自然就记住了。
8.2 35 个关键字总览(按用途分类)
① 值与逻辑(6 个)
| 关键字 | 含义 | 章节 |
|---|---|---|
True / False | 布尔真 / 假 | 4.2 |
None | 空值(表示"什么都没有") | 6.5 |
and / or / not | 与 / 或 / 非(逻辑运算) | 4.2 |
in | 成员判断;也是 for ... in 的一部分 | 5.1 / 7.6 |
is | 判断"是不是同一个对象" | 7.6 |
② 控制流(10 个)
| 关键字 | 含义 | 章节 |
|---|---|---|
if / elif / else | 条件分支;也用于循环的 else | 4.2 / 5.3 |
for | 遍历循环 | 5.1 |
while | 条件循环 | 4.3 |
break | 结束整个循环 | 5.3 |
continue | 跳过本轮循环 | 5.3 |
pass | 什么都不做的占位语句 | 5.4 |
return | 结束函数并返回值 | 6.5 |
yield | 产出生成器 | 12.9 |
③ 定义与作用域(7 个)
| 关键字 | 含义 | 章节 |
|---|---|---|
def | 定义函数 | 6.2 |
class | 定义类 | 5.0 / 12.3 |
lambda | 定义匿名小函数 | 6.11 |
global | 声明"我要改全局变量" | 6.8 |
nonlocal | 声明"我要改外层嵌套函数的变量" | 6.8 |
del | 删除元素 / 变量 | 7.7 |
as | 起别名(import x as y、with ... as f、except ... as e) | 9.1 / 10.2 |
④ 异常与上下文(6 个)
| 关键字 | 含义 | 章节 |
|---|---|---|
try / except / finally | 捕获异常 | 11.2 |
raise | 主动抛出异常 | 11.3 |
assert | 断言(不满足就报错,调试用) | 11.6 |
with | 上下文管理器(自动清理资源) | 10.2 |
⑤ 导入与异步(6 个)
| 关键字 | 含义 | 章节 |
|---|---|---|
import / from | 导入模块 / 从模块导入名字 | 9.1 |
async / await | 异步编程(进阶,本笔记不展开) | — |
软关键字:
match/case(3.10+)、_、type属于"软关键字"——只在特定语境下保留,其它地方仍可当变量名。所以上面 35 个清单里没有它们。
8.3 内置函数逐个详解(按用途分组)
8.3.1 输入、输出与文件
print("a", "b", sep="-", end="!") # a-b! sep 改分隔符,end 改结尾(默认 \n)
name = input("请输入:") # 读键盘,返回的一定是字符串
f = open("a.txt", encoding="utf-8") # 打开文件(配合 with 使用,见 10.2)
# (说明:这段要你自己输入内容才能继续,没有固定输出)8.3.2 类型查看与转换
type(10) # <class 'int'> 查看类型
isinstance(10, int) # True 判断"是不是这个类型"(推荐,支持继承)
isinstance(10, (int, float)) # True 可以传元组,满足任一即可
int("12") # 12 字符串→整数("12.5" 要先转 float)
float("3.5") # 3.5
str(123) # '123' 任何东西转字符串(拼接、写文件前常用)
bool("") # False 空/0 转 False,其余转 True
list("ab") # ['a', 'b']
tuple([1, 2]) # (1, 2)
set([1, 1, 2]) # {1, 2} 去重
dict([("a", 1)]) # {'a': 1}8.3.3 数学相关
abs(-5) # 5 绝对值
round(3.14159, 2) # 3.14 四舍五入(注意"银行家舍入":round(2.5) → 2)
pow(2, 10) # 1024 幂,等价于 2 ** 10
divmod(10, 3) # (3, 1) 一次拿到"商和余数"
sum([1, 2, 3]) # 6 求和
sum([1, 2, 3], 10) # 16 第二个参数是初始值
max(3, 1, 2) # 3 最大值(也可传可迭代对象)
min([3, 1, 2]) # 1
max(["a", "bb", "c"], key=len) # 'bb' key 指定"按什么比"
max([{"n":1},{"n":5}], key=lambda d: d["n"]) # {'n': 5}8.3.4 序列与迭代(最常用的一组)
len("abc") # 3 长度(字符串/列表/字典/集合都行)
list(range(5)) # [0,1,2,3,4] 生成整数序列
list(range(1, 10, 2)) # [1,3,5,7,9] 起点、终点(不含)、步长
list(enumerate(["a","b"], start=1)) # [(1,'a'), (2,'b')] 带序号
list(zip([1,2], ["a","b"])) # [(1,'a'), (2,'b')] 配对
sorted([3, 1, 2]) # [1, 2, 3] 返回新列表,不改原列表
sorted([3, 1, 2], reverse=True) # [3, 2, 1]
sorted(["bb", "a"], key=len) # ['a', 'bb']
list(reversed([1, 2, 3])) # [3, 2, 1] 反向# iter / next:for 循环的底层原理(见 12.8 迭代器)
it = iter([1, 2, 3])
print(next(it), next(it)) # 1 2
# 输出:
# 1 28.3.5 真假判断
any([False, 1, 0]) # True 只要有一个为真就是 True
all([True, 1, "a"]) # True 全部为真才是 True
any([]) # False 空序列是 False
all([]) # True 空序列反而是 True("没有反例")8.3.6 函数式工具(map / filter)
list(map(str, [1, 2, 3])) # ['1', '2', '3'] 对每个元素做转换
list(map(lambda x: x * x, [1, 2, 3])) # [1, 4, 9]
list(filter(lambda x: x > 1, [1, 2, 3])) # [2, 3] 过滤,保留"返回 True"的
list(filter(None, ["a", "", "b"])) # ['a', 'b'] 传 None = 去掉假值更 Pythonic 的写法:
[str(x) for x in ...]、[x for x in ... if x > 1]。map/filter返回的是迭代器(只能用一次),要复用就list()包一下,或者直接用推导式。
8.3.7 对象相关
id(a) # 对象在内存里的"身份证号"(判断是不是同一个对象时用)
repr("a") # "'a'" 显示"给程序员看"的形式(f-string 里用 !r)
dir(obj) # 列出对象所有属性和方法(忘了有什么就调它)
help(str.split) # 查看某个方法的用法
getattr(obj, "name", "默认值") # 按字符串名字取属性,取不到给默认值
setattr(obj, "name", "小明") # 按字符串名字设置属性
hasattr(obj, "name") # 有没有这个属性
format(1234, ",") # '1,234' 格式化(f-string 的底层实现)
# (说明:这一段要连着上一段代码一起跑才有输出)8.4 高频内置函数的使用技巧与坑
| 函数 | 技巧 / 坑 |
|---|---|
len() | 只能用在"有长度"的东西上;生成器没有长度,会报 TypeError |
range() | 终点不包含;想倒着数要写负步长 range(10, 0, -1) |
enumerate() | 默认从 0 开始,要"第 1 项"就加 start=1 |
zip() | 长度不一致时按短的截断;想保留长的用 itertools.zip_longest |
sorted() | 不改原列表(列表自己的 .sort() 才改);key= 只写函数名不带括号 |
max() / min() | 也支持 key=;序列为空会报 ValueError(可给 default=) |
sum() | 只能加数字;字符串拼接请用 "".join(列表) |
round() | round(2.5) → 2(银行家舍入,遇 5 取偶),金额请用 decimal |
map() / filter() | 返回迭代器,打印出来是 <map object>,要 list() 才看得见 |
any() / all() | all([]) 是 True,逻辑上"没有反例就是全部满足",容易想反 |
8.5 怎么快速查到你想要的函数
# ① 忘了叫什么:列出内置名字
print([n for n in dir(__builtins__) if not n.startswith("_")])
# ② 大概知道干什么但忘了怎么用:help
help(sorted)
# ③ 忘了某个对象能做什么:dir + help
dir(str) # 字符串有哪些方法
help(str.split) # split 怎么用
# 输出:
# ['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BaseExceptionGroup', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EncodingWarning', 'EnvironmentError', 'Exception', 'ExceptionGroup', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportCycleError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'PythonFinalizationError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', 'abs', 'aiter', 'all', 'anext', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozendict', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'sentinel', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']
# Help on built-in function sorted in module builtins:
#
# sorted(iterable, /, *, key=None, reverse=False)
# Return a new list containing all items from the iterable in ascending order.
#
# A custom key function can be supplied to customize the sort order, and the
# reverse flag can be set to request the result in descending order.
#
# Help on method descriptor split:
#
# split(self, /, sep=None, maxsplit=-1) unbound builtins.str method
# Return a list of the substrings in the string, using sep as the separator string.
#
# sep
# The separator used to split the string.
#
# When set to None (the default value), will split on any
# whitespace character (including \n \r \t \f and spaces) and
# will discard empty strings from the result.
# maxsplit
# Maximum number of splits.
# -1 (the default value) means no limit.
#
# Splitting starts at the front of the string and works to the end.
#
# Note, str.split() is mainly useful for data that has been
# intentionally delimited. With natural text that includes
# punctuation, consider using the regular expression module.
# (说明:这一段要连着上一段代码一起跑才有输出)完整速查表见 附录 B。
8.6 【本章小结】
| 你学到了什么 | 关键记忆点 |
|---|---|
| 内置函数 vs 关键字 | 内置函数开箱即用(约 70 个);关键字是语法占用词,35 个,不能当变量名 |
| 查资料三件套 | help(x) 看用法、dir(x) 看有什么、keyword.kwlist 看关键字 |
| 类型转换 | int/float/str/bool/list/tuple/set/dict;isinstance() 做类型判断 |
| 数学 | abs / round / pow / divmod / sum / max / min(后两个支持 key=) |
| 迭代三宝 | enumerate(带序号)、zip(配对)、sorted(排序,key= 指定规则) |
| 判断 | any / all;all([]) 是 True |
| 函数式 | map / filter 返回迭代器,日常更推荐推导式 |
| 常见坑 | range 不含终点、zip 会截断、sorted 不改原列表、round(2.5) → 2 |
第 9 章 模块与包
【本章导览】 代码变多之后,必须学会"分文件管理":
import的四种写法及各自适用场景。- 自己写一个模块,并理解
import时会发生什么。if __name__ == "__main__":这句"咒语"到底干什么用。- 模块搜索路径、
dir()/help()查文档。- 包(package)与相对导入。
难度:★★☆☆☆ | 预计用时:25 分钟 | 前置知识:第 8 章
9.1 import 的各种写法
import math # 整个模块
print(math.sqrt(16)) # 4.0
from math import sqrt, pi # 只导入需要的
print(sqrt(9), pi) # 3.0 3.14159...
import numpy as np # 起别名(业界惯例)
from math import * # 全部导入(不推荐,容易重名)
# (说明:需要先装第三方库:pip install numpy)import 那一刻到底发生了什么? 三件事:找到文件 → 把里面的代码从头到尾执行一遍 → 把执行后产生的名字交给调用方。第二件事最要紧:模块顶层的 print()、读文件、连数据库,都会在导入时跑起来,所以模块里尽量只放定义(def / class / 常量),要执行的东西放进 if __name__ == "__main__":(9.2 就是干这个的)。
而且同一个模块只会执行一次:
import mytools # 打印"模块被加载了"
import mytools # 第二次什么也不打印,直接拿缓存里的
# (说明:需要先装第三方库:pip install mytools)Python 把导入过的模块记在 sys.modules 里,第二次直接取缓存。这既省时间,也避免了 A 导入 B、B 又导入 A 时无限绕圈。副作用是:改了模块代码,正在运行的程序不会自动更新,得重启(或 importlib.reload())。
由此还引出一个经典坑:别给自己的文件起标准库的名字。比如你新建了 random.py,同一目录里的代码写 import random 时,Python 会先找到你自己那个文件,然后报「找不到 randint」之类的怪错。同理还有 json.py、string.py、typing.py。导入时看到的 __pycache__ 文件夹,就是 Python 存编译缓存的地方,删掉也没关系,它会自动重建。
至于 from math import *:它把模块里所有公开名字一股脑倒进当前文件,谁先谁后很难追踪。想控制「哪些算公开」,模块里可以写 __all__ = ["sqrt", "pi"],但日常最省心的做法还是只导入要用的名字,或者干脆 import 模块 用全名。
9.2 自己写一个模块
新建 mytools.py:
"""我的工具模块"""
def double(x):
return x * 2
PI = 3.14159
print("模块被加载了") # 被 import 时会执行
# 输出:
# 模块被加载了使用:
import mytools
print(mytools.double(5)) # 10
print(mytools.PI) # 3.14159
# (说明:需要先装第三方库:pip install mytools)__name__ 的惯用法(让文件既能被导入、又能直接运行):
def double(x):
return x * 2
if __name__ == "__main__":
# 只有"直接运行这个文件"时才执行
print(double(10))
# 输出:
# 209.3 模块搜索路径与 dir()
import sys
print(sys.path) # Python 找模块的目录列表
import math
print(dir(math)) # 列出模块里所有可用的名字
print(dir()) # 列出当前作用域所有名字
print(help(math.sqrt)) # 查看帮助
# 输出:
# ['C:\\Users\\rssme\\AppData\\Local\\Temp\\codecheck_ig684u1x', 'C:\\Users\\rssme\\AppData\\Local\\Programs\\CodeBuddy CN\\resources\\app\\extensions\\genie\\out\\vendor\\shim', 'C:\\Users\\rssme\\AppData\\Roaming\\uv\\python\\cpython-3.15-windows-x86_64-none\\python315.zip', 'C:\\Users\\rssme\\AppData\\Roaming\\uv\\python\\cpython-3.15-windows-x86_64-none\\DLLs', 'C:\\Users\\rssme\\AppData\\Roaming\\uv\\python\\cpython-3.15-windows-x86_64-none\\Lib', 'C:\\Users\\rssme\\AppData\\Roaming\\uv\\python\\cpython-3.15.2-windows-x86_64-none', 'C:\\Users\\rssme\\AppData\\Roaming\\uv\\python\\cpython-3.15-windows-x86_64-none', 'C:\\Users\\rssme\\AppData\\Roaming\\uv\\python\\cpython-3.15-windows-x86_64-none\\Lib\\site-packages']
# ['__doc__', '__loader__', '__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh', 'atan', 'atan2', 'atanh', 'cbrt', 'ceil', 'comb', 'copysign', 'cos', 'cosh', 'degrees', 'dist', 'e', 'erf', 'erfc', 'exp', 'exp2', 'expm1', 'fabs', 'factorial', 'floor', 'fma', 'fmax', 'fmin', 'fmod', 'frexp', 'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'integer', 'isclose', 'isfinite', 'isinf', 'isnan', 'isnormal', 'isqrt', 'issubnormal', 'lcm', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan', 'nextafter', 'perm', 'pi', 'pow', 'prod', 'radians', 'remainder', 'signbit', 'sin', 'sinh', 'sqrt', 'sumprod', 'tan', 'tanh', 'tau', 'trunc', 'ulp']
# ['__builtins__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'math', 'sys']
# Help on built-in function sqrt in module math:
#
# sqrt(x, /)
# Return the square root of x.
#
# None
# (说明:这一段要连着上一段代码一起跑才有输出)9.4 包(package)
包就是含 __init__.py 的文件夹:
mypkg/
__init__.py
utils.py
models.pyfrom mypkg import utils # 导入包里的模块
from mypkg.utils import double # 直接导入函数
from mypkg import utils as u # 起别名
# (说明:需要先装第三方库:pip install mypkg)包内互相导入可用相对导入:
from . import models(.表示当前包)。
__init__.py 的作用说穿了很简单:告诉 Python「这个文件夹是一个包」,顺便可以在里面放包级别的初始化代码,或者把常用的名字提前导出来,让外部写 from mypkg import double。3.3 起没有它也能当「命名空间包」,但自己写项目还是老老实实加上,编辑器、测试工具、打包工具都认这个约定,少踩坑。
相对导入有个几乎人人撞过一次的报错:
ImportError: attempted relative import with no known parent package原因不是路径写错,而是你直接运行了包里面的那个文件(比如 python mypkg/utils.py)。这时 Python 把它当成一个独立脚本,压根不知道它属于 mypkg,. 也就无从谈起。两种解法:在项目根目录用 python -m mypkg.utils 运行(-m 会保留包身份),或者在包外面的入口文件里 from mypkg.utils import ...。
所以一个稍微像样的项目,目录通常长这样:
myproject/
main.py ← 唯一直接运行的文件
mypkg/
__init__.py
utils.py
models.py入口只有一个,其余文件都靠导入被用起来——这也是 if __name__ == "__main__": 在实际项目里的意义。
9.5 【本章小结】
| 你学到了什么 | 关键记忆点 |
|---|---|
| 导入方式 | import 模块 / from 模块 import 名字 / import 模块 as 别名;from x import * 不推荐 |
| 模块是什么 | 一个 .py 文件就是一个模块,被 import 时文件里的代码会执行一遍 |
__name__ | 直接运行该文件时是 "__main__",被导入时是模块名 → 用它区分两种身份 |
| 搜索路径 | sys.path 决定去哪儿找模块 |
| 查文档 | dir(模块) 看有什么、help(函数) 看怎么用 |
| 包 | 含 __init__.py 的目录;包内互相导入用 from . import xxx |
第 10 章 输入与输出
【本章导览】 程序不能只在屏幕上打几个字,它得会"说话"和"记事":
- 格式化输出:f-string /
str.format()/ 旧式%三种写法及其取舍。- 文件读写:
with open(...)、打开模式、常用方法、为什么必须写encoding="utf-8"。- JSON(AI 开发重中之重):Python 对象 ↔ JSON 字符串 ↔ JSON 文件,以及类型对应关系。
难度:★★★☆☆ | 预计用时:40 分钟 | 前置知识:第 7 章
10.1 格式化输出
name, age = "小明", 18
# ① f-string(推荐)
print(f"{name} 今年 {age} 岁")
print(f"{3.14159:.2f}") # 3.14
print(f"{1234567:,}") # 1,234,567
print(f"{0.25:.1%}") # 25.0%
print(f"{name!r}") # '小明' !r 显示 repr
# ② str.format()
print("{} 今年 {} 岁".format(name, age))
print("{0} {1} {0}".format("a", "b")) # a b a 可复用位置
print("{n} 今年 {a}".format(n=name, a=age)) # 按名字
# ③ 旧式 %(老代码里常见,认识即可)
print("%s 今年 %d 岁" % (name, age))
# 输出:
# 小明 今年 18 岁
# 3.14
# 1,234,567
# 25.0%
# '小明'
# 小明 今年 18 岁
# a b a
# 小明 今年 18
# 小明 今年 18 岁三种写法怎么取舍?f-string 是首选,因为变量就摆在要填的位置上,读起来不用在字符串和参数之间来回对视线。但有一种情况它帮不上忙:模板是运行时才拿到的(存在配置文件里、从数据库读出来、用户自己填的)。f-string 在写代码那一刻就把内容定死了,这时候得用 str.format():
template = "{name} 同学,你的成绩是 {score} 分" # 假设这行是从配置读来的
print(template.format(name="小明", score=95))
# 小明 同学,你的成绩是 95 分
# 输出:
# 小明 同学,你的成绩是 95 分% 只需看懂,不用再写:老项目、一些 logging 配置里还能见到。另外 f-string 里 {} 是要填东西的,想输出字面量花括号得写成 {{ 和 }}:
print(f"{{'name': '{name}'}}") # {'name': '小明'}
# (说明:这一段要连着上一段代码一起跑才有输出)10.2 读写文件
# 写(w 会覆盖,a 是追加)
with open("demo.txt", "w", encoding="utf-8") as f:
f.write("第一行\n")
f.write("第二行\n")
# 读
with open("demo.txt", "r", encoding="utf-8") as f:
content = f.read() # 全部读成一个字符串
with open("demo.txt", "r", encoding="utf-8") as f:
for line in f: # 逐行读(推荐,省内存)
print(line.strip())
# 输出:
# 第一行
# 第二行文件对象的常用方法
| 方法 | 作用 |
|---|---|
f.read() | 读全部 |
f.readline() | 读一行 |
f.readlines() | 读所有行,返回列表 |
f.write(s) | 写入字符串 |
f.writelines(列表) | 写入多行 |
打开模式
| 模式 | 含义 |
|---|---|
"r" | 读(默认,文件不存在会报错) |
"w" | 写(会清空原内容) |
"a" | 追加写入 |
"r+" | 读写 |
"b" | 二进制(如 "rb" 读图片) |
【重点】用
with:它会自动关闭文件,即使中途出错也不会泄漏资源。
with 凭什么能自动关? 把它展开成不用 with 的写法就明白了:
f = open("demo.txt", encoding="utf-8")
try:
content = f.read()
finally:
f.close() # 无论中间有没有出错,这句都会执行with 就是把这段模板压成一行。它要求后面的对象实现两个方法:进入时调 __enter__ 做准备,退出时调 __exit__ 做清理,哪怕中途抛了异常也会调。文件、数据库连接、线程锁、临时目录都是这个套路,所以 Python 里管它叫「上下文管理器」。
一个特别容易中招的坑:相对路径到底相对谁? 答案是「运行命令时所在的目录」(当前工作目录),不是 .py 文件所在的目录。在 VS Code 里从项目根目录运行、和 cd 进子目录再运行,同一个 open("data.txt") 会指向两个不同的文件,甚至一个能找到、一个报 FileNotFoundError。
from pathlib import Path
print(Path.cwd()) # 当前工作目录,看一眼就知道自己在哪儿
# 输出:
# C:\Users\<你的用户名>\Desktop\Biu Work\_imgtest\_gen
# (说明:路径、时间、目录内容随你自己的机器而变,你跑出来的会不一样)想让路径跟脚本位置绑定,用 __file__:
from pathlib import Path
base = Path(__file__).resolve().parent # 这个 .py 文件所在的目录
path = base / "data" / "config.json" # 用 / 拼路径
print(path)
# 输出:
# C:\Users\<你的用户名>\AppData\Local\Temp\<临时目录名>\data\config.json
# (说明:路径、时间、目录内容随你自己的机器而变,你跑出来的会不一样)resolve() 转成绝对路径,parent 拿到所在目录,/ 是 pathlib 专门用来拼路径的运算符——在 Windows 上会自动变成反斜杠,不用你自己判断系统。open() 也直接吃 Path 对象,所以后面两种写法可以混着用。
pathlib 是现在读写文件更顺手的写法,《从入门到实践》第 3 版整章都改用它了:
from pathlib import Path
p = Path("data/2026/report.txt")
p.parent.mkdir(parents=True, exist_ok=True) # 目录不存在就递归建,存在也不报错
p.write_text("第一行\n第二行\n", encoding="utf-8") # 不用自己 open/close
text = p.read_text(encoding="utf-8")
print(text.splitlines()) # ['第一行', '第二行']
print(p.name, p.stem, p.suffix) # report.txt report .txt
print(p.exists(), p.stat().st_size) # True,以及文件的字节数
# 输出:
# ['第一行', '第二行']
# report.txt report .txt
# True 22read_text() / write_text() 内部帮你把打开和关闭都做完了,splitlines() 比 readlines() 干净:它自动去掉每行末尾的 \n,交给你的是纯字符串列表。为什么推荐 pathlib 而不是 os.path?因为路径在这里是一个对象,能做的事都挂在它身上(.exists()、.glob()、.suffix),不用记 join / basename / splitext 一堆散装函数,还天然跨平台。第 13 章的 os / glob 在老代码里依然满地都是,两套都得认识。
逐行读大文件时别用 read() 或 readlines()(会把整个文件搬进内存),直接遍历文件对象,它一行一行地给:
with open("big.log", encoding="utf-8") as f:
count = 0
for line in f: # 内存里始终只有"一行"
if "ERROR" in line:
count += 1
print("错误行数:", count)
# (说明:需要先准备好这个文件:big.log)写多行也有个小陷阱:writelines() 不会帮你加换行符,名字听着像会自动加,其实不会。
with open("lines.txt", "w", encoding="utf-8") as f:
f.writelines([f"第 {i} 行\n" for i in range(1, 4)]) # \n 得自己写10.3 JSON(AI 开发的重中之重)
import json
data = {"name": "小明", "age": 18, "tags": ["AI", "Python"]}
# 写:Python 对象 → JSON 字符串
s = json.dumps(data, ensure_ascii=False, indent=2)
print(s)
# {
# "name": "小明",
# "age": 18,
# "tags": ["AI", "Python"]
# }
# 读:JSON 字符串 → Python 对象
back = json.loads(s)
print(back["name"]) # 小明
# 直接写文件 / 读文件
with open("data.json", "w", encoding="utf-8") as f:
json.dump(data, f, ensure_ascii=False)
with open("data.json", "r", encoding="utf-8") as f:
loaded = json.load(f)
# 输出:
# {
# "name": "小明",
# "age": 18,
# "tags": [
# "AI",
# "Python"
# ]
# }
# 小明类型对应关系
| Python | JSON |
|---|---|
| dict | object |
| list / tuple | array |
| str | string |
| int / float | number |
| True / False | true / false |
| None | null |
ensure_ascii=False让中文正常显示(否则会变成\u5c0f\u660e)。
把 JSON 真正用起来:让数据下次启动还在。程序里的变量一关掉就没了,想「记住」只能落到文件里。JSON 是首选,因为它是纯文本、人也能读、几乎所有语言和接口都认。《从入门到实践》里那个「记住用户名」的例子,完整跑一遍是这样:
import json
from pathlib import Path
FILE = Path("username.json")
def load_name():
if FILE.exists():
return json.loads(FILE.read_text(encoding="utf-8"))
return None
def save_name(name):
FILE.write_text(json.dumps(name, ensure_ascii=False), encoding="utf-8")
name = load_name()
if name:
print(f"欢迎回来,{name}!")
else:
name = input("第一次来,怎么称呼?").strip()
save_name(name)
print(f"记住你了,{name}!")
# 输出(输入示例:小明):
# 欢迎回来,[{'name': '小明', 'skills': ['Python', 'SQL']}, {'name': '小红', 'skills': ['FastAPI']}]!为什么要先 exists()?因为第一次运行时文件还没生成,read_text() 会抛 FileNotFoundError。这就是「读之前先确认东西在不在」最常见的落地方式。
数据一复杂,存的就是 7.4 讲过的嵌套结构,取的时候一层层点进去:
users = [
{"name": "小明", "skills": ["Python", "SQL"]},
{"name": "小红", "skills": ["FastAPI"]},
]
FILE.write_text(json.dumps(users, ensure_ascii=False, indent=2), encoding="utf-8")
back = json.loads(FILE.read_text(encoding="utf-8"))
print(back[0]["skills"][0]) # Python
# 输出(需与上一段代码连着跑):
# Pythonindent=2 只是让人看着舒服,接口传输时别加,白白多送一堆空格和换行。
JSON 只认上面那张表里的几种基本类型。日期、自定义对象直接塞进去会报错:
from datetime import datetime
# json.dumps({"time": datetime.now()}) # TypeError: Object of type datetime is not JSON serializable
print(json.dumps({"time": datetime.now().isoformat()}, ensure_ascii=False))
# (说明:这一段要连着上一段代码一起跑才有输出)得先自己转成字符串或字典。FastAPI 里的 pydantic 干的就是这层「对象 ↔ JSON」转换,所以定义模型时把类型写清楚特别重要。
读到坏数据会怎样? 会抛 json.JSONDecodeError,别让程序因为一个手滑改坏的配置文件直接崩掉:
try:
data = json.loads("{坏掉的 json")
except json.JSONDecodeError as e:
print("配置格式不对:", e) # 配置格式不对: Expecting property name enclosed in double quotes...
# (说明:这一段要连着上一段代码一起跑才有输出)它是 ValueError 的子类,所以 except ValueError: 一样接得住(第 11 章会讲异常)。
10.4 【本章小结】
| 你学到了什么 | 关键记忆点 |
|---|---|
| 三种格式化 | f-string 首选(简洁、能算表达式);str.format() 次之;% 老代码里认识即可 |
| f-string 常用格式 | {x:.2f} 小数位、{x:,} 千分位、{x:.1%} 百分比、{x:<10} 对齐、{x!r} repr |
| 读写文件 | with open(路径, 模式, encoding="utf-8") as f: —— with 会自动关闭文件 |
| 打开模式 | r 读、w 写(清空原内容)、a 追加、r+ 读写、b 二进制 |
| 读的三种方式 | read() 全部、readline() 一行、readlines() 列表;大文件用 for line in f |
| JSON 四兄弟 | dumps/loads 处理字符串;dump/load 处理文件 |
| JSON 中文 | 加 ensure_ascii=False,否则中文变成 \u5c0f\u660e |
| 类型对应 | dict↔object、list↔array、str↔string、True/False↔true/false、None↔null |
第 11 章 错误和异常
【本章导览】 程序出错不可怕,可怕的是出错后直接崩掉:
- 语法错误和异常有什么本质区别?常见的异常类型有哪些?
try / except / else / finally四个子句各自什么时候执行(尤其是else为什么有用)。- 用
raise主动抛异常,用自定义异常表达业务错误。with为什么能自动清理资源。assert断言的正确用法与误区。难度:★★★☆☆ | 预计用时:40 分钟 | 前置知识:第 6 章
11.1 语法错误 vs 异常
- 语法错误(SyntaxError):代码写错了,程序根本没开始跑。 PYTHON
# print("忘了括号" ← SyntaxError - 异常(Exception):语法没问题,但运行时出错。 PYTHON
print(10 / 0) # ZeroDivisionError print(int("abc")) # ValueError print(1 + "2") # TypeError print([1][5]) # IndexError print({"a":1}["b"]) # KeyError # (说明:这一段是在演示「除以 0」会直接报错,所以故意不写输出)
先学会看懂报错。新手最容易被一长串红字吓住,其实有用的只有两处:最后一行告诉你出了什么错,倒着往上找告诉你是在自己代码的哪一行炸的。
def divide(a, b):
return a / b
def run():
return divide(10, 0)
run()
# (说明:这一段是在演示「除以 0」会直接报错,所以故意不写输出)Traceback (most recent call last):
File "demo.py", line 7, in <module>
run()
File "demo.py", line 4, in run
return divide(10, 0)
File "demo.py", line 2, in divide
return a / b
ZeroDivisionError: division by zero最后一行是错误类型加说明;上面一串像面包屑,记录「谁调了谁」,最靠后的那一层才是真正出错的位置(这里是 divide 里的 a / b)。看到 IndexError 就去找下标,看到 KeyError 就去找字典键,看到 ModuleNotFoundError 就先检查包装没装、虚拟环境有没有激活。
另外几个会频繁照面的:NameError(名字没定义,多半是拼错或忘了先定义)、AttributeError(对象身上没这个属性/方法,比如把字符串当列表用了)、FileNotFoundError(路径不对,回看 10.2 那个工作目录的坑)、RecursionError(递归没写基线条件,见 6.9)、StopIteration(迭代器取完了,for 循环内部靠它收工,见 12.8)。
11.2 try / except / else / finally
try:
age = int(input("请输入年龄:"))
except ValueError:
print("请输入数字!") # 出现 ValueError 时执行
except (TypeError, KeyError) as e:
print("其他错误:", e) # 可捕获多种
else:
print("输入成功,年龄是", age) # 没出错才执行
finally:
print("这句无论怎样都会执行") # 常用来释放资源
# 输出(输入示例:小明):
# 请输入年龄:请输入数字!
# 这句无论怎样都会执行四个子句的分工(记住这张表就够了)
| 子句 | 什么时候执行 | 典型用途 |
|---|---|---|
try | 总是先执行 | 放"可能出错的代码" |
except | 出错时执行 | 补救、提示、降级 |
else | 没出错时执行 | 成功后才做的事 |
finally | 无论怎样都执行 | 释放资源(关文件、关连接) |
else有什么意义? 很多人觉得它多余。它的价值是:把"成功后才做的事"挪出try,这样try块里只剩真正可能出错的代码,except不会误捕获到后续代码的异常。PYTHON# 不推荐:成功后的逻辑写在 try 里,它的异常也会被 except 抓住 try: data = json.loads(text) save(data) # save 出错也会被当成"解析失败" except ValueError: print("解析失败") # 推荐:用 else 分开 try: data = json.loads(text) except ValueError: print("解析失败") else: save(data) # 只有解析成功才保存,且它的异常不会被误抓 # (说明:这一段要连着上一段代码一起跑才有输出)
Python 更习惯「先做,出错再说」。检查一个字典键存在不存在,两种写法:
# 先问再做(别的语言里更常见)
if "name" in user:
print(user["name"])
else:
print("没名字")
# 做了再说,出错再处理(Python 更推荐)
try:
print(user["name"])
except KeyError:
print("没名字")
# (说明:这一段要连着上一段代码一起跑才有输出)下面这种看着「危险」,其实有三个好处:不用把键查两遍(判断一次、取值又查一次);有些状态在「检查」和「使用」之间会变(文件刚检查完就被别的程序删了);正常流程不会被一堆 if 淹掉。Python 社区管这叫 EAFP(Easier to Ask Forgiveness than Permission,求原谅比求许可容易)。当然别走极端——把整个函数体都塞进 try 会让 except 抓错对象,这正是 11.2 里 else 要解决的问题。
重新抛出时,把原因带上:
def read_port(text):
try:
return int(text)
except ValueError as e:
raise ValueError(f"端口配置不合法:{text!r}") from e
# read_port("abc") → 报错里会连着显示原始的 int() 错误from e 把原始异常挂在新的异常上,日志里既能看到你补的上下文(「端口配置」),也能看到根因(「abc 不是整数」)。不加的话 Python 也会打印,但会多一段「During handling of the above exception...」,读起来绕。
为什么反复强调别写裸 except:?因为它连 KeyboardInterrupt(你按 Ctrl+C)和 SystemExit(程序想退出)都一起抓了,出问题时连中断都停不下来。至少要写清类型:
except Exception as e:
logging.warning("处理失败:%s", e) # 至少留下一条线索
# (说明:这一段需要外部环境(文件 / 网络 / 第三方服务)才能跑出结果)至于 except: pass,5.4 已经说过:那是最难查的一类 bug,错误被无声吞掉,等发现时数据早就不对了。
11.3 主动抛出异常
def check_age(age):
if age < 0:
raise ValueError("年龄不能是负数")
return age
# check_age(-1) → ValueError: 年龄不能是负数11.4 自定义异常
这里用到了"类"和"继承":语法看 5.0,继承详解看 12.4。
class MyError(Exception): # 继承 Python 自带的 Exception
"""自定义异常:继承 Exception 即可"""
pass # 不需要额外代码,pass 占位(见 5.4)
try:
raise MyError("出事了")
except MyError as e:
print("捕获到:", e)
# 输出:
# 捕获到: 出事了11.5 with 做清理
# with 会自动调用清理逻辑(关闭文件、释放锁)
with open("a.txt") as f:
data = f.read()
# 出了 with 块,文件自动关闭,即使里面出异常
# (说明:需要先准备好这个文件:a.txt)11.6 assert 断言:给自己看的"保险丝"
定义:assert 条件, "提示信息" 的意思是——"我敢打赌这个条件一定成立",不成立就立刻抛 AssertionError 并带上提示。
def divide(a, b):
assert b != 0, "除数不能为 0"
return a / b
print(divide(10, 2)) # 5.0
# divide(10, 0) # AssertionError: 除数不能为 0
# 输出:
# 5.0什么时候用
| 场景 | 建议 |
|---|---|
| 检查"按理说绝不可能发生"的内部状态(调试期) | ✅ 用 assert |
| 检查用户输入 / 外部数据(可能真的出错) | ❌ 用 if ... raise ValueError(见下) |
| 生产环境的错误处理 | ❌ 不要用 assert(见下方警告) |
# ✅ 正确:外部输入用 raise,用户能看到友好错误
def set_age(age):
if age < 0:
raise ValueError("年龄不能是负数")
return age
# ❌ 错误示范:assert 会被"关掉"
def set_age(age):
assert age >= 0, "年龄不能是负数"
return age【坑 · 重要】 用
python -O(优化模式)运行程序时,所有assert都会被跳过。 所以断言只能用来"调试期间自查",绝不能用来做真正的输入校验。
11.7 【本章小结】
| 你学到了什么 | 关键记忆点 |
|---|---|
| 语法错误 vs 异常 | 语法错误 = 写错了、跑不起来;异常 = 语法对、运行时出问题 |
| 常见异常 | ZeroDivisionError、ValueError、TypeError、IndexError、KeyError、FileNotFoundError |
| 四个子句 | try 先跑;except 出错才跑;else 没出错才跑;finally 一定跑 |
else 的价值 | 把"成功后才做的事"挪出 try,避免被 except 误捕获 |
| 捕获写法 | except ValueError as e;多个异常 except (A, B);别写裸 except: |
| 主动抛出 | raise ValueError("提示") |
| 自定义异常 | class MyError(Exception): pass |
with | 自动清理资源(关文件、释放锁) |
assert | 调试期自查;外部输入请用 raise;-O 模式会跳过断言 |
第 12 章 类、对象与接口
【本章导览】 从"写函数"升级到"写类",是组织大型程序的关键一步(5.0 节已经先修过一遍,这里是完整版):
- 名字与对象:为什么 Python 的变量像"标签"而不是"盒子"(12.1)。
- 定义类:类变量 / 实例变量、
__init__、self、方法(12.3)。- 继承:复用父类、
super()、方法重写(12.4)。- 封装:私有约定、
property属性(12.5)。- 接口:Python 里怎么表达"接口"——
pass/NotImplementedError/ 抽象基类abc(12.6)。- 进阶:类方法、静态方法、
dataclass、常用魔术方法(12.7)。- 迭代器与生成器(12.8 / 12.9)。
难度:★★★★☆ | 预计用时:80 分钟 | 前置知识:第 6 章(函数)、5.0 节
12.1 先理解"名字"和"对象"
a = [1, 2, 3]
b = a # b 是 a 的"别名",指向同一个对象
b.append(4)
print(a) # [1, 2, 3, 4] 因为是同一个东西
# 输出:
# [1, 2, 3, 4]Python 里"变量"更像是贴在对象上的标签,而不是装东西的盒子。
12.2 作用域与命名空间(简化版,详见 6.8)
x = 10 # 全局
def f():
y = 5 # 局部,出了函数就没了
print(x) # 能读外面的
f()
# print(y) # NameError:外面看不到函数里的 y
def g():
global count # 想在函数里改全局变量,要声明 global
count = 1
# 输出:
# 1012.3 定义类
语法
class 类名:
类变量 = 值 # 所有实例共享
def __init__(self, 参数): # 构造器:造对象时自动调用
self.实例变量 = 参数 # 每个对象自己一份
def 方法名(self, 参数): # 方法:第一个参数必须是 self
...
# (说明:这一段要连着上一段代码一起跑才有输出)class Dog:
kind = "犬科" # 类变量:所有狗共享
def __init__(self, name): # 构造器
self.name = name # 实例变量:每只狗自己有
def bark(self): # 方法
return f"{self.name}:汪汪!"
d1 = Dog("旺财") # 实例化:类名(参数)
d2 = Dog("小黑")
print(d1.bark()) # 旺财:汪汪!
print(d1.name, d2.name) # 旺财 小黑
print(d1.kind, Dog.kind)# 犬科 犬科
# 输出:
# 旺财:汪汪!
# 旺财 小黑
# 犬科 犬科
self就是"这个对象自己"。调用d1.bark()时,Python 实际执行Dog.bark(d1)。
类变量 vs 实例变量(重要区别)
| 类变量 | 实例变量 | |
|---|---|---|
| 定义位置 | 类里、方法外 | __init__ 里,带 self. |
| 归属 | 所有实例共享一份 | 每个对象各有一份 |
| 改的时候 | 类名.变量 = x(影响所有) | 对象.变量 = x(只影响这一个) |
class Dog:
count = 0 # 类变量:记录一共造了几只狗
def __init__(self, name):
self.name = name
Dog.count += 1 # 注意改类变量要用 类名.count,别写 self.count
Dog("旺财"); Dog("小黑")
print(Dog.count) # 2
# 输出:
# 2【坑】 用
self.类变量 = x赋值,只会给这个对象新建一个同名实例变量,不会改到共享的类变量。
__init__ 不是"构造函数":它在对象创建之后被调用(对象已存在,只是还没填数据)。真正创建对象的是 __new__(极少用到)。
给属性一个默认值,是《从入门到实践》里很实在的一招。有些属性不用每次都从外面传,比如新车里程一定是 0:
class Car:
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year
self.odometer = 0 # 默认值:造对象时自动有
def describe(self):
return f"{self.year} {self.make} {self.model},已跑 {self.odometer} 公里"
def set_odometer(self, km):
if km < self.odometer:
raise ValueError("里程不能往回调")
self.odometer = km
def add_km(self, km):
self.odometer += km
car = Car("byd", "seal", 2026)
print(car.describe()) # 2026 byd seal,已跑 0 公里
# 输出:
# 2026 byd seal,已跑 0 公里改一个对象身上的属性,其实有三种方式,区别挺重要:
car.odometer = 500 # ① 直接改:最省事,但谁都能改成 -1
car.set_odometer(600) # ② 通过方法改:顺手做了校验
car.add_km(50) # ③ 通过方法递增:不用自己算旧值
print(car.odometer) # 650
# 输出(需与上一段代码连着跑):
# 650为什么后两种更值得写?因为「什么值算合法」这条规则只放在一个地方。以后要加个日志、发个通知、改成从接口同步,也只改这一个方法,而不是满项目去找谁在直接赋值。这就是「封装」最朴素的含义——12.5 的 @property 是同一件事的 Python 式写法:让调用方还能写 car.odometer = 600,但背后照样走校验。
12.4 继承
class Animal:
def __init__(self, name):
self.name = name
def speak(self):
raise NotImplementedError # 留给子类实现
class Cat(Animal): # 继承 Animal
def speak(self):
return f"{self.name}:喵喵!"
class Dog(Animal):
def speak(self):
return f"{self.name}:汪汪!"
for a in [Cat("咪咪"), Dog("旺财")]:
print(a.speak())
# 咪咪:喵喵!
# 旺财:汪汪!
# 输出:
# 咪咪:喵喵!
# 旺财:汪汪!调用父类:用 super()
class Puppy(Dog):
def __init__(self, name, age):
super().__init__(name) # 先让父类初始化
self.age = age
# (说明:这一段要连着上一段代码一起跑才有输出)多重继承(
class C(A, B))了解即可,日常少用。
super().__init__() 为什么非写不可?子类一旦自己写了 __init__,父类的那个就不会自动执行了,父类负责填的那些属性根本不存在,后面一用就 AttributeError。super() 的意思是「按继承顺序找下一个该调用的类」,先让父类把公共部分初始化好,子类再补自己独有的部分。多重继承时它还会按一张固定的顺序表(MRO)去找,比手写 父类名.__init__(self) 更不容易乱。
类一多,就该按第 9 章的规矩分文件放了。导入类和导入函数是同一套写法:
# car.py 里放 class Car、class ElectricCar
from car import Car
from car import Car, ElectricCar
import car
my_car = Car("byd", "seal", 2026) # 直接写类名
your_car = car.ElectricCar("tesla", "3", 2026) # 带模块名前缀,冲突时更安全
# (说明:需要先装第三方库:pip install car)真实项目里一个文件放一个类(或一组关系很近的类)是常态,入口文件只负责把大家串起来。这也是为什么 9.4 强调「入口只有一个」。
12.5 私有变量与封装(property)
Python 没有真正的 private,靠"约定"和"改名"来表达"这是内部的,别碰":
class Bank:
def __init__(self):
self._internal = "内部用" # 单下划线:约定"别直接访问"(只是约定,语法上能访问)
self.__secret = "名字会被改写" # 双下划线:Python 会改名(name mangling)
b = Bank()
print(b._internal) # 能访问,但不建议
# print(b.__secret) # AttributeError
print(b._Bank__secret) # 改名后的真实名字(知道就行,别这么用)
# 输出:
# 内部用
# 名字会被改写| 写法 | 含义 | 能否从外面访问 |
|---|---|---|
name | 公开 | ✅ 随便访问 |
_name | "内部用的",约定上别碰 | ✅ 能,但不该 |
__name | 名字被改写成 _类名__name,避免被子类覆盖 | ❌ 直接访问会报错 |
property:把方法伪装成属性(既好读又能校验)
class Student:
def __init__(self, score):
self.score = score
s = Student(50)
s.score = -10 # ❌ 没人拦得住,成绩变成 -10 了class Student:
def __init__(self, score):
self._score = score
@property # 读:s.score
def score(self):
return self._score
@score.setter # 写:s.score = x
def score(self, value):
if not 0 <= value <= 100:
raise ValueError("成绩必须在 0~100 之间")
self._score = value
s = Student(50)
print(s.score) # 50 像属性一样读,其实是调用了方法
s.score = 85 # 走 setter,自动校验
# s.score = 200 # ValueError: 成绩必须在 0~100 之间
# 输出:
# 50为什么用
property:调用方写法完全不变(还是s.score),但你悄悄拿到了"读写时做校验/计算"的能力。 这就是"封装"——把数据保护起来,只暴露安全的入口。
12.6 接口:只规定"必须有什么方法"
接口是什么:一份方法清单的约定。它只说"实现类必须有这些方法",不关心你怎么实现。 好处:调用方只依赖接口,换成任何实现都不用改代码(这对后面写插件、写 MCP 工具、写 Agent 的 Tool 非常重要)。
Python 没有 interface 关键字,实际开发中有三种写法,按严格程度从低到高:
# ① pass 占位 —— 纯约定,子类忘了实现也不会报错(运行时才发现问题)
class DataLoader:
def load(self):
pass
# ② raise NotImplementedError —— 推荐,忘了实现会明确报错
class DataLoader:
def load(self):
raise NotImplementedError("子类必须实现 load()")
# ③ 抽象基类 abc —— 最严格:没实现完全部抽象方法,**根本不允许实例化**
from abc import ABC, abstractmethod
class DataLoader(ABC):
@abstractmethod
def load(self): ...
@abstractmethod
def save(self, data): ...
class CsvLoader(DataLoader):
def load(self):
return "读 CSV"
def save(self, data):
return "写 CSV"
# DataLoader() # ❌ TypeError:抽象类不能实例化
print(CsvLoader().load()) # 读 CSV
# 输出:
# 读 CSV三种写法怎么选
| 写法 | 严格程度 | 适用场景 |
|---|---|---|
pass | 最宽松 | 搭骨架、快速原型(见 5.4) |
raise NotImplementedError | 中等 | 日常首选:简单直观,忘了实现立刻报错 |
abc + @abstractmethod | 最严格 | 写框架 / 插件系统,要求"必须实现全部方法" |
鸭子类型(Python 的精髓)
def process(loader):
data = loader.load() # 不检查 loader 是什么类,只要有 load() 就能用
return len(data)
process(CsvLoader()) # ✅
process(JsonLoader()) # ✅
# (说明:这一段要连着上一段代码一起跑才有输出)"如果它走起来像鸭子、叫起来像鸭子,那它就是鸭子。" 不看你继承谁,只看你有没有这个方法。所以很多时候 Python 甚至不需要写接口类——写文档说明清楚就行。
12.7 类方法、静态方法与 dataclass
三种方法对比
| 类型 | 定义 | 第一个参数 | 能访问 | 典型用途 |
|---|---|---|---|---|
| 实例方法 | def f(self) | self(对象) | 实例 + 类 | 绝大多数方法 |
| 类方法 | @classmethod | cls(类) | 只能访问类变量 | 工厂方法、操作类变量 |
| 静态方法 | @staticmethod | 无 | 都不能(就是普通函数) | 和类相关但不依赖状态的辅助函数 |
class User:
total = 0 # 类变量
def __init__(self, name):
self.name = name
User.total += 1
@classmethod
def from_dict(cls, data): # 工厂方法:用字典造对象
return cls(data["name"])
@classmethod
def get_total(cls):
return cls.total # 用 cls,子类继承时指向子类自己
@staticmethod
def is_valid_name(name): # 和类有关,但不需要 self/cls
return len(name) >= 2
u = User.from_dict({"name": "小明"})
print(User.get_total()) # 1
print(User.is_valid_name("小")) # False
# 输出:
# 1
# Falsedataclass:自动生成样板代码(强烈推荐)
写"主要用来装数据"的类时,用 dataclass 自动生成 __init__、__repr__、__eq__:
from dataclasses import dataclass
@dataclass
class Point:
x: float
y: float
label: str = "原点" # 可以有默认值
p = Point(1.0, 2.0)
print(p) # Point(x=1.0, y=2.0, label='原点') ← 自带 __repr__
print(p == Point(1.0, 2.0)) # True ← 自带 __eq__
# 输出:
# Point(x=1.0, y=2.0, label='原点')
# True# 不用 dataclass 就得自己写这么多:
class Point:
def __init__(self, x, y, label="原点"):
self.x, self.y, self.label = x, y, label
def __repr__(self):
return f"Point(x={self.x}, y={self.y}, label={self.label!r})"
def __eq__(self, other):
return (self.x, self.y) == (other.x, other.y)常用魔术方法(双下划线方法)
| 方法 | 作用 | 触发时机 |
|---|---|---|
__init__(self, ...) | 初始化 | 类名() |
__str__(self) | 给用户看的字符串 | print(obj)、str(obj) |
__repr__(self) | 给程序员看的字符串(调试) | 交互模式直接输 obj |
__len__(self) | 长度 | len(obj) |
__eq__(self, other) | 相等比较 | obj == other |
__getitem__(self, key) | 下标访问 | obj[key] |
__iter__ / __next__ | 迭代 | for x in obj(见 12.8) |
__enter__ / __exit__ | 上下文管理 | with obj as x(见 10.2) |
class Bag:
def __init__(self, items):
self.items = items
def __str__(self):
return f"袋子里有 {len(self.items)} 样东西"
def __len__(self):
return len(self.items)
def __getitem__(self, i):
return self.items[i]
b = Bag(["苹果", "梨"])
print(b) # 袋子里有 2 样东西 ← 调用了 __str__
print(len(b)) # 2 ← 调用了 __len__
print(b[0]) # 苹果 ← 调用了 __getitem__
# 输出:
# 袋子里有 2 样东西
# 2
# 苹果
# (说明:耗时与机器性能有关,数值会不同)12.8 迭代器
nums = [1, 2, 3]
it = iter(nums) # 造一个迭代器
print(next(it)) # 1
print(next(it)) # 2
print(next(it)) # 3
# print(next(it)) # StopIteration:没有了
# 输出:
# 1
# 2
# 3
# (说明:耗时与机器性能有关,数值会不同)
for循环内部就是这么工作的:拿到迭代器 → 不断next()→ 遇到StopIteration停止。
自己写一个迭代器
class CountDown:
def __init__(self, start):
self.n = start
def __iter__(self):
return self
def __next__(self):
if self.n <= 0:
raise StopIteration
self.n -= 1
return self.n + 1
for x in CountDown(3):
print(x) # 3 2 1
# 输出:
# 3
# 2
# 112.9 生成器(yield)
def countdown(n):
while n > 0:
yield n # 产出后暂停,下次从这里继续
n -= 1
for x in countdown(3):
print(x) # 3 2 1
g = countdown(3)
print(next(g), next(g)) # 3 2
# 输出:
# 3
# 2
# 1
# 3 2生成器的好处:不一次性占用内存,要一个产一个。处理大文件、流式数据时必备。
生成器表达式(像列表推导式,但用小括号)
squares = (x*x for x in range(5)) # 几乎不占内存
print(sum(squares)) # 30
print(sum(x*x for x in range(5))) # 30 更简洁的写法
# 输出:
# 30
# 30列表推导式 vs 生成器表达式,到底用哪个?
| 对比 | 列表推导 [...] | 生成器 (...) |
|---|---|---|
| 内存占用 | 一次性算出全部,数据量大时很占内存 | 要一个产一个,几乎不占内存 |
| 能否反复遍历 | 能 | 不能(遍历一次就用完了) |
能否 len() / 下标 | 能 | 不能 |
| 速度 | 数据量小时更快 | 数据量大时更优(不用等全部算完) |
# 数据量小、后面还要用 → 用列表
small = [x*x for x in range(100)]
print(len(small), small[0]) # 100 0
# 数据量大、只用一次(比如求和/找最大)→ 用生成器
total = sum(x*x for x in range(10_000_000)) # 不会把 1000 万个数字都存下来
print(total)
# 输出:
# 100 0
# 333333283333335000000经验法则:要反复用 / 要数个数 → 列表;只遍历一次 / 数据很大 → 生成器。 处理大文件、流式响应(大模型逐字返回)时,生成器是标配。
12.10 【本章小结】
| 你学到了什么 | 关键记忆点 |
|---|---|
| 类与对象 | 类是模具/图纸,对象是成品;self 指"当前这个对象" |
| 三种变量 | 类变量(共享)、实例变量(独有)、私有 _x / __x(约定 / 改名) |
__init__ | 对象创建后自动调用,负责填数据 |
| 继承 | class B(A);super().__init__() 调父类;子类可重写方法 |
| 封装 | @property + @x.setter:像属性一样读写,背后能做校验 |
| 接口 | 三种写法:pass < NotImplementedError < abc 抽象基类;Python 讲鸭子类型 |
| 方法类型 | 实例方法(self)、@classmethod(cls)、@staticmethod(无) |
dataclass | 自动生成 __init__/__repr__/__eq__,装数据的类首选 |
| 迭代器 | 实现 __iter__ + __next__;for 循环的底层原理 |
| 生成器 | 函数里用 yield,要一个产一个,省内存;(x for x in ...) 是生成器表达式 |
第 13 章 标准库实用速查
【本章导览】 "不要重复造轮子"——这些模块 Python 自带,
import就能用:
os/os.path:文件和目录操作(13.1)sys:解释器与命令行参数(13.2)glob:通配符找文件(13.3)re:正则表达式(13.4)math/random:数学与随机(13.5)datetime:日期时间(13.6)logging:日志(上线必备,13.7)collections.deque:高效队列(13.8)time/pprint等一行速记(13.9)doctest/unittest:最简单的测试(13.10)难度:★★☆☆☆(工具章,用时再查) | 预计用时:30 分钟 | 前置知识:第 9 章
13.1 os —— 操作系统接口
import os
print(os.getcwd()) # 当前目录
os.chdir("/tmp") # 切换目录
print(os.listdir(".")) # 列出文件和目录
os.makedirs("a/b/c", exist_ok=True) # 递归建目录
os.system("echo hello") # 执行系统命令
print(os.path.join("a", "b.txt")) # a\b.txt 跨平台拼路径
print(os.path.exists("a.txt")) # 是否存在
print(os.path.getsize("a.txt")) # 文件大小(字节)
# (说明:需要先准备好这个文件:对应文件)13.2 sys —— 解释器相关
import sys
print(sys.argv) # 命令行参数列表,如 ['app.py', 'arg1']
print(sys.version) # Python 版本
sys.exit(0) # 退出程序
# 输出:
# ['C:\\Users\<你的用户名>\\AppData\\Local\\Temp\\<临时目录名>\\b225.py']
# 3.12.7 (tags/v3.12.7:0b05ead, Oct 1 2024, 03:06:41) [MSC v.1941 64 bit (AMD64)]
# (说明:路径、时间、目录内容随你自己的机器而变,你跑出来的会不一样)13.3 glob —— 文件通配符
import glob
print(glob.glob("*.py")) # 当前目录所有 .py 文件
print(glob.glob("**/*.txt", recursive=True)) # 递归查找
# 输出:
# ['an_runs.py', 'apply_blocks.py', 'apply_new3.py', 'apply_outputs.py', 'fix_outputs2.py', 'handle_fail.py', 'restore_kn.py', 'run_all.py', 'run_all_codes.py', 'run_new_codes.py', '_add_agent.py', '_add_rag.py']
# ['an_out.txt', 'demo.txt', 'engine.txt', 'lines.txt', 'note.txt', 'quiz_probe.txt', 'runs_utf8.txt', 'run_final.txt', 'run_new_codes.txt', 'run_new_codes2.txt', 'show2.txt', 'show_home.txt', 'data\\日记.txt', 'data\\2026\\report.txt']13.4 re —— 正则表达式(常用符号)
| 符号 | 含义 |
|---|---|
. | 任意字符 |
\d | 数字 |
\w | 字母数字下划线 |
+ | 一个或多个 |
* | 零个或多个 |
? | 零个或一个 |
^ $ | 开头 / 结尾 |
import re
print(re.findall(r"\d+", "abc123def456")) # ['123', '456']
print(re.search(r"\d+", "abc123").group()) # 123
print(re.sub(r"\d+", "N", "a1b2c3")) # aNbNcN
# 输出:
# ['123', '456']
# 123
# aNbNcN13.5 math / random
import math, random
print(math.sqrt(16), math.pi, math.ceil(3.2), math.floor(3.8))
print(random.randint(1, 10)) # 1~10 随机整数
print(random.choice(["a","b","c"])) # 随机选一个
print(random.sample(range(100), 5)) # 不重复抽 5 个
# 输出:
# 4.0 3.141592653589793 4 3
# 3
# a
# [80, 34, 14, 78, 13]
# (说明:含随机数,每次运行结果都会不一样)13.6 datetime —— 日期时间
from datetime import datetime, timedelta
now = datetime.now()
print(now.strftime("%Y-%m-%d %H:%M:%S")) # 2026-10-26 14:30:00
print(now + timedelta(days=7)) # 一周后
d = datetime.strptime("2026-01-01", "%Y-%m-%d") # 字符串转日期
print((datetime.now() - d).days) # 相差天数
# 输出:
# 2026-11-12 07:43:52
# 2026-11-19 07:43:52.200778
# 315
# (说明:路径、时间、目录内容随你自己的机器而变,你跑出来的会不一样)13.7 logging —— 日志(上线必备)
import logging
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
logging.debug("调试信息") # 默认不显示
logging.info("正常信息")
logging.warning("警告")
logging.error("错误")
# 输出:2026-10-26 14:30:00,123 INFO 正常信息13.8 collections.deque —— 高效队列
from collections import deque
q = deque(["a", "b", "c"])
q.append("d"); q.appendleft("z")
print(q.popleft()) # z
print(q) # deque(['a', 'b', 'c', 'd'])
# 输出:
# z
# deque(['a', 'b', 'c', 'd'])再补四个能让代码短一半的标准库工具
csv:表格数据别自己 split(",")。字段里只要出现逗号、引号或换行,手写就出错:
import csv
with open("users.csv", "w", encoding="utf-8", newline="") as f:
writer = csv.DictWriter(f, fieldnames=["name", "age"])
writer.writeheader()
writer.writerows([{"name": "小明", "age": 18}, {"name": "小红", "age": 20}])
with open("users.csv", encoding="utf-8", newline="") as f:
for row in csv.DictReader(f):
print(row["name"], row["age"]) # 小明 18 / 小红 20
# 输出:
# 小明 18
# 小红 20newline="" 是 Windows 上写 CSV 的固定搭配,少了它每行之间会多出空行。读出来每一行是字典,跟 7.4 的嵌套数据无缝接上。
itertools:循环里的瑞士军刀,全是「要一个给一个」的惰性工具:
from itertools import chain, islice, zip_longest
print(list(chain([1, 2], [3, 4]))) # [1, 2, 3, 4] 几段接成一段
print(list(islice(range(100), 3))) # [0, 1, 2] 只取前 3 个,不先造 100 个
print(list(zip_longest([1, 2, 3], ["a"], fillvalue="-")))
# [(1, 'a'), (2, '-'), (3, '-')] ← 补上 8.4 里 zip 会截断的短板
# 输出:
# [1, 2, 3, 4]
# [0, 1, 2]
# [(1, 'a'), (2, '-'), (3, '-')]functools.lru_cache:给函数加一份「记忆」。6.9 说递归版的斐波那契慢得跑不动,因为同一个 fib(20) 被反复算了几万次,一行装饰器就能救回来:
from functools import lru_cache
@lru_cache
def fib(n):
if n < 2:
return n
return fib(n - 1) + fib(n - 2)
print(fib(40)) # 102334155,几乎瞬间出结果
# 输出:
# 102334155它把「参数 → 结果」记在小本子上,第二次遇到同样的参数直接翻本子。这也是 6.14 装饰器最实用的一个例子。前提是被缓存的函数得同样输入永远给同样输出——读文件、请求接口这种会变的结果别缓存。
argparse:1.2 里用 sys.argv 手抠参数,参数一多就该交给它:
import argparse
parser = argparse.ArgumentParser(description="打招呼小工具")
parser.add_argument("name")
parser.add_argument("--times", type=int, default=1)
args = parser.parse_args()
print(args.name * args.times)
# (说明:这一段是在演示「测试失败」,故意让它报错)python .\tool.py 小明 --times 3
python .\tool.py --help小明小明小明类型校验、默认值、--help 说明全自动生成。写命令行小工具时,这是从「能跑」到「别人也会用」的一步。
13.9 其他一行速记
import time; time.sleep(1) # 暂停 1 秒
import timeit; timeit.timeit("x=sum(range(100))") # 测耗时
import pprint; pprint.pprint({"a": [1,2]}) # 漂亮打印
# 输出:
# {'a': [1, 2]}
# (说明:耗时与机器性能有关,数值会不同;集合是无序的,每次打印的顺序都可能不同)13.10 测试(doctest / unittest 极简)
def double(x):
"""把数字翻倍。
>>> double(3)
6
"""
return x * 2
if __name__ == "__main__":
import doctest
doctest.testmod() # 运行文档里的示例当测试import unittest
class TestDouble(unittest.TestCase):
def test_double(self):
self.assertEqual(double(3), 6)
if __name__ == "__main__":
unittest.main()
# (说明:这一段是在演示「测试失败」,故意让它报错)13.11 【本章小结】
| 模块 | 干什么 | 最常用的几个 |
|---|---|---|
os / os.path | 文件目录操作 | os.listdir、os.makedirs、os.path.join/exists/getsize |
sys | 解释器相关 | sys.argv(命令行参数)、sys.exit |
glob | 通配符查找文件 | glob.glob("*.py")、**/*.txt + recursive=True |
re | 正则 | findall、search().group()、sub |
math / random | 数学、随机 | sqrt/pi/ceil/floor;randint/choice/sample |
datetime | 时间 | now()、strftime、strptime、timedelta |
logging | 日志 | basicConfig + info/warning/error(替代 print 调试) |
collections.deque | 双端队列 | append / popleft |
time / pprint | 延时、美观打印 | time.sleep、pprint.pprint |
doctest / unittest | 测试 | 文档里的 >>> 示例、测试用例类 |
第 14 章 虚拟环境与包
【本章导览】 项目一多,依赖就会打架。虚拟环境是"每个项目一间独立房间":
- 虚拟环境是什么、为什么要建它。
- 创建 / 激活 / 退出 / 安装包的完整命令(Windows 与 macOS/Linux 都给)。
requirements.txt的作用与生成、安装方式。- 装不动时的国内镜像源。
难度:★☆☆☆☆(操作为主) | 预计用时:20 分钟
python -m venv .venv # 创建虚拟环境
.venv\Scripts\activate # 激活(Windows)
# source .venv/bin/activate # 激活(macOS / Linux)
pip install requests # 安装包
pip list # 看装了什么
pip freeze > requirements.txt # 导出依赖
pip install -r requirements.txt # 按文件安装
deactivate # 退出环境国内加速:
pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名
几个照着敲之前值得先知道的点。
用 python -m pip 比直接 pip 稳。电脑上装了多个 Python 时,pip 这个命令可能指向另一个解释器,包就装到别人家去了:
python -m pip install requests
python -m pip --version # 看清楚它到底属于哪个 Pythonpython -m 的意思是「用当前这个 python 去运行 pip 模块」,装到哪儿不会搞错。激活虚拟环境之后直接 pip install 也没问题,但排查「明明装了却 import 不到」时,上面的写法能一眼定位。
Windows / PowerShell 激活失败是很常见的一道题:
.venv\Scripts\activate
# 若报「无法加载文件 ... 因为在此系统上禁止运行脚本」
Set-ExecutionPolicy -Scope CurrentUser RemoteSigned原因是 PowerShell 默认不允许执行本地脚本,跟 Python 本身没关系。改「当前用户」这一级就够,不用动整台机器的策略。实在不想改,也可以不激活,直接用 .venv\Scripts\python.exe .\main.py 跑,效果一样。
requirements.txt 可以自己手写,不必全靠 pip freeze(它会把间接依赖也一股脑倒出来,小项目看着很乱):
requests==2.32.3
fastapi>=0.110,<1.0
uvicorn~=0.30.0== 锁死版本,保证别人装出来跟你一模一样;>= 给升级留空间;~= 只允许最后一段小版本更新。要「复现同样的环境」就锁死,要「持续拿新功能」就放宽,看项目需要。
最后记得在 .gitignore 里加上 .venv/、__pycache__/、*.pyc。虚拟环境动辄几百 MB,而且里面记的是你这台机器的绝对路径,换台电脑完全用不了;正确做法是只提交 requirements.txt,让别人自己建一个。
14.1 【本章小结】
| 你学到了什么 | 关键记忆点 |
|---|---|
| 虚拟环境是什么 | 每个项目独立的 Python 环境,装的包互不影响 |
| 创建 / 激活 | python -m venv .venv → Windows .venv\Scripts\activate;macOS/Linux source .venv/bin/activate |
| 装包 / 查看 | pip install 包名、pip list、pip show 包名 |
| 依赖记录 | pip freeze > requirements.txt(导出);pip install -r requirements.txt(还原) |
| 退出 | deactivate |
| 加速 | pip install -i https://pypi.tuna.tsinghua.edu.cn/simple 包名 |
第 15 章 给代码写测试(pytest)
【本章导览】 《从入门到实践》第 3 版专门用一章讲测试,用的是
pytest(第 2 版用的是标准库unittest)。这一章不追求写全,只把「改完代码怎么敢确定没改坏」这件事跑通:装 pytest、写第一个测试、一次测多组数据、用夹具准备现场、测异常,最后借测试做一次重构。难度:★★☆☆☆ | 预计用时:40 分钟 | 前置知识:第 6 章(函数)、第 11 章(异常)、第 14 章(装包)
15.1 为什么非要写测试
写过几段代码就会遇到这个场景:给函数加了一个功能,手动试了一下「好像没问题」,结果第二天发现老功能悄悄坏了。手动试只能覆盖你当场想到的那一两个输入,而且没人愿意每次改完都把整个流程点一遍。
测试就是把「我预期它这样」写进代码里,改完之后一键全部重跑。它还有个隐藏好处:为了能测,你会自然地把代码拆成输入输出明确的小函数(6.1 说的「便于测试」就是这个意思)。后面写接口、写 Agent 的工具函数时,一处改动可能影响整条链路,测试就是那份底气。
先在虚拟环境里装(第 14 章):
python -m pip install pytest
pytest --version15.2 第一个测试:三行代码
准备一个待测试的函数,放在 name_utils.py:
def get_full_name(first, last):
"""把姓和名拼成完整的名字。"""
return f"{first} {last}".title()再建一个 test_name_utils.py,两个文件放同一个目录:
from name_utils import get_full_name
def test_full_name():
assert get_full_name("li", "ming") == "Li Ming"
# (说明:需要先装第三方库:pip install name_utils)在这个目录下运行:
pytest -q. [100%]
1 passed in 0.02s三个约定记住就行:文件名以 test_ 开头、函数名以 test_ 开头、验证用 assert。pytest 会自动把它们找出来跑,不用注册、不用写 main()。
为什么这里能用 assert?11.6 说过断言不能用来校验用户输入,因为 python -O 会把它跳过;但测试文件是用 pytest 跑的,不走 -O,而且测试本来就该「条件不成立就立刻失败」。这正是断言的主场。pytest 还会把失败的两边展开给你看,比自己 print 排查快得多。
把函数故意改错(.title() 换成 .capitalize()),再看一次报错:
E AssertionError: assert 'Li ming' == 'Li Ming'
E - Li Ming
E + Li ming一眼就看出来是「只有首字母大写了」。
如果报
ModuleNotFoundError: No module named 'name_utils',多半是 pytest 的运行目录不对。改用python -m pytest -q,它会把当前目录加进模块搜索路径(9.3 的sys.path)。
15.3 一次测好几组输入
一个用例只验证了「英文小写姓名」。想覆盖更多情况,不用复制粘贴三份测试函数,用参数化:
import pytest
from name_utils import get_full_name
@pytest.mark.parametrize("first, last, expected", [
("li", "ming", "Li Ming"),
("wang", "fang", "Wang Fang"),
("zhang", "san", "Zhang San"),
])
def test_full_name(first, last, expected):
assert get_full_name(first, last) == expected
# (说明:需要先装第三方库:pip install pytest)3 passed in 0.02spytest 会把列表里每一行塞进函数跑一遍,任何一个不过都会单独列出来,告诉你是哪组数据出的问题。找边界情况的输入(空字符串、0、负数、超长文本)比多写几个差不多的用例有用得多。
15.4 用夹具准备「现场」
测试类的时候,每个测试都想要一个干干净净的新对象,否则上一个测试加进去的数据会污染下一个(回想 6.4 的「可变对象会被改」)。先看被测试的类,放在 survey.py:
class Survey:
def __init__(self, question):
self.question = question
self.responses = []
def add(self, answer):
self.responses.append(answer)测试文件:
import pytest
from survey import Survey
@pytest.fixture
def survey():
"""每个测试都拿到一个全新的问卷"""
return Survey("你最喜欢哪门语言?")
def test_starts_empty(survey):
assert survey.responses == []
def test_add_one(survey):
survey.add("Python")
assert survey.responses == ["Python"]
def test_add_two(survey):
survey.add("Python")
survey.add("Go")
assert len(survey.responses) == 2
# (说明:需要先装第三方库:pip install pytest)把「造对象」抽成 @pytest.fixture,测试函数的参数名写成夹具名,pytest 就会在每次测试前重新造一个注入进来。测试函数里只剩真正要验证的那一句,读起来像说明书。夹具还能做更重的事:建临时文件、连测试数据库、跑完自动清理——跟 10.2 的 with 是同一种「准备 / 收尾」思路。
15.5 测「应该报错」的情况
正常返回值要测,异常也要测。11.3 里主动 raise 的错误,用 pytest.raises 接住:
import pytest
def test_divide_by_zero():
with pytest.raises(ZeroDivisionError):
10 / 0
def test_bad_json():
import json
with pytest.raises(ValueError): # JSONDecodeError 是 ValueError 的子类
json.loads("{坏掉的")
# (说明:需要先装第三方库:pip install pytest)如果代码块里没有抛出预期的异常,这个测试就会失败。这样「以后有人不小心把校验删了」也会被立刻发现。自定义异常(11.4)同样能测。
15.6 借着测试做一次重构
现在要支持中间名。改之前先把新预期写出来:
def test_with_middle():
assert get_full_name("li", "ming", "xiao") == "Li Xiao Ming"这时跑 pytest 会失败(函数还不收第三个参数),这正是「先写预期再改代码」的节奏。然后改实现:
def get_full_name(first, last, middle=""):
parts = [first, middle, last]
return " ".join(p for p in parts if p).title()middle 给了默认值,所以老调用照样能用;join 把非空的部分拼起来(2.2 讲过为什么不用 + 一路加)。再跑一遍:
4 passed in 0.02s老用例全绿,说明这次改动没破坏原来的行为;新用例绿,说明新功能确实对了。所谓「重构」,就是改内部结构而不改外部行为——没有测试,你只能靠感觉判断有没有改坏。
15.7 【本章小结】
pytest靠命名约定找测试:文件test_*.py,函数test_*,里面用assert。- 失败信息会把两边的值直接展开,先看错误类型,再看自己文件里的那一行(11.1)。
@pytest.mark.parametrize一次跑多组数据;@pytest.fixture给每个测试准备独立现场。pytest.raises(...)用来验证「该报错时确实报错」。- 测试最大的价值不是抓 bug,是让你敢改代码;
doctest/unittest(13.10)是另外两套写法,pytest 是现在最主流的选择。
第 16 章 把知识点串起来:写一个能用的小程序
【本章导览】 前面 15 章都是「一个知识点配几行例子」。这一章换个写法:从零做一个命令行待办清单,边写边把变量、判断、循环、函数、字典、文件、JSON、异常、测试全用上。《从入门到实践》里的三个项目也是这个思路——先做能跑的最小版本,再一点点加东西。
难度:★★★☆☆ | 预计用时:60 分钟 | 前置知识:第 3、4、6、7、10、11 章
16.1 先想清楚数据长什么样
动手写界面之前,先定数据。一条待办有两件事要记:内容、做完没做完。所以一条就是一个字典,一堆待办就是一个列表:
todos = [
{"title": "看完第 6 章", "done": False},
{"title": "写一个小工具", "done": True},
]为什么不用纯字符串列表 ["看完第 6 章", ...]?因为「完成状态」没地方放。这个结构正好也是 7.4 讲的嵌套数据、10.3 讲的 JSON 结构——从内存到文件不用改形状,这一步选对了,后面全顺。
16.2 先把「显示」写出来
一个函数只干一件事:把清单打印给人看。
def show(todos):
if not todos: # 空列表是假(4.2)
print("(清单是空的)")
return # 提前 return(6.5)
for i, t in enumerate(todos, start=1):
mark = "x" if t["done"] else " "
print(f"{i}. [{mark}] {t['title']}")
show(todos)
# 输出(需与上一段代码连着跑):
# 1. [ ] 看完第 6 章
# 2. [x] 写一个小工具1. [ ] 看完第 6 章
2. [x] 写一个小工具enumerate(..., start=1) 让人看到的序号从 1 开始,交互时才自然(8.4)。mark 用了三元表达式(4.2),因为就是简单的二选一。
16.3 搭主循环:能跑就行
命令行程序基本都是「打印菜单 → 等输入 → 按选择做事 → 再来一轮」。不知道用户要点几轮,所以用 while True + break(4.3):
def main():
todos = []
while True:
print("\n1 查看 2 添加 3 标记完成 4 删除 0 退出")
cmd = input("选一个:").strip()
if cmd == "1":
show(todos)
elif cmd == "2":
title = input("要做什么:").strip()
if title: # 空输入不算一条待办
todos.append({"title": title, "done": False})
print("加好了")
elif cmd == "0":
print("下次见")
break
else:
print("没这个选项,再选一次")
if __name__ == "__main__":
main()
# 输出(输入示例:0):
# 1 查看 2 添加 3 标记完成 4 删除 0 退出
# 选一个:下次见if __name__ == "__main__": 这句(9.2)在这里特别有用:直接运行 python todo.py 会进交互,但后面用 import todo 做测试时不会突然弹出菜单。
16.4 让它下次启动还记得
现在一退出数据就没了。按 10.3 的办法,用 pathlib + json 落到文件里:
import json
from pathlib import Path
FILE = Path("todos.json")
def load():
if not FILE.exists(): # 第一次运行还没有存档
return []
try:
return json.loads(FILE.read_text(encoding="utf-8"))
except json.JSONDecodeError:
print("存档读不出来,先从空清单开始")
return []
def save(todos):
FILE.write_text(
json.dumps(todos, ensure_ascii=False, indent=2),
encoding="utf-8",
)try/except(第 11 章)不是为了好看:用户手滑把 todos.json 改坏了,程序应该提示一句继续用,而不是一启动就崩。indent=2 让人能直接打开文件检查内容。
主函数里把 todos = [] 换成 todos = load(),并在每轮循环末尾加一句 save(todos):
def main():
todos = load()
while True:
# ... 菜单和分支照旧 ...
save(todos) # 每轮都落盘,中途关掉窗口也不丢16.5 用户什么都会输:把校验单独包起来
「标记完成 / 删除」都要用户输入序号,而用户会输 abc、99、甚至直接回车。与其在每个分支里重复判断,不如写一个专门的函数,把「一段文字」变成「一个合法下标」,不合法就返回 None(6.5 的多 return、11.2 的 EAFP):
def to_index(text, todos):
try:
i = int(text) - 1 # 人看到的是 1 起,列表是 0 起
except ValueError:
return None
if 0 <= i < len(todos): # 链式比较(4.2)
return i
return None调用处就干净了:
elif cmd in ("3", "4"):
show(todos)
i = to_index(input("第几项:"), todos)
if i is None: # 判断 None 用 is(7.6)
print("序号不对")
elif cmd == "3":
todos[i]["done"] = True
print("标记完成")
else:
removed = todos.pop(i)
print("删掉了:", removed["title"])
# (说明:这一段需要外部环境(文件 / 网络 / 第三方服务)才能跑出结果)todos.pop(i) 会返回被删的那一项,正好拿来提示「删了什么」(3.2)。
16.6 完整代码(todo.py)
import json
from pathlib import Path
FILE = Path("todos.json")
def load():
if not FILE.exists():
return []
try:
return json.loads(FILE.read_text(encoding="utf-8"))
except json.JSONDecodeError:
print("存档读不出来,先从空清单开始")
return []
def save(todos):
FILE.write_text(
json.dumps(todos, ensure_ascii=False, indent=2),
encoding="utf-8",
)
def show(todos):
if not todos:
print("(清单是空的)")
return
for i, t in enumerate(todos, start=1):
mark = "x" if t["done"] else " "
print(f"{i}. [{mark}] {t['title']}")
def to_index(text, todos):
try:
i = int(text) - 1
except ValueError:
return None
if 0 <= i < len(todos):
return i
return None
def main():
todos = load()
while True:
print("\n1 查看 2 添加 3 标记完成 4 删除 0 退出")
cmd = input("选一个:").strip()
if cmd == "1":
show(todos)
elif cmd == "2":
title = input("要做什么:").strip()
if title:
todos.append({"title": title, "done": False})
print("加好了")
elif cmd in ("3", "4"):
show(todos)
i = to_index(input("第几项:"), todos)
if i is None:
print("序号不对")
elif cmd == "3":
todos[i]["done"] = True
print("标记完成")
else:
removed = todos.pop(i)
print("删掉了:", removed["title"])
elif cmd == "0":
save(todos)
print("已保存,下次见")
break
else:
print("没这个选项,再选一次")
save(todos)
if __name__ == "__main__":
main()
# 输出(输入示例:0):
# 1 查看 2 添加 3 标记完成 4 删除 0 退出
# 选一个:已保存,下次见16.7 跑一遍看看
python .\todo.py1 查看 2 添加 3 标记完成 4 删除 0 退出
选一个:2
要做什么:看完第 6 章
加好了
1 查看 2 添加 3 标记完成 4 删除 0 退出
选一个:1
1. [ ] 看完第 6 章
1 查看 2 添加 3 标记完成 4 删除 0 退出
选一个:0
已保存,下次见再跑一次,第一条还在。这时候打开 todos.json 会看到:
[
{
"title": "看完第 6 章",
"done": false
}
]注意 done 变成了小写的 false——JSON 的布尔值是 true/false,不是 Python 的 True/False(10.3 的类型对应表)。json.loads() 读回来时会自动变回 True/False,不用你操心。
16.8 从这里再往前走
这个小程序已经是个完整的「输入 → 处理 → 存储」闭环了,往上加东西都有明确落点:
- 加截止日期 →
datetime(13.6),显示时顺便算「还剩几天」; - 加命令行用法(
python todo.py list直接打印)→argparse(13.8 后面那几个工具)或sys.argv(1.2); - 给
to_index()写测试 →pytest(第 15 章),改代码时不再靠手点; - 把
save/load换成数据库,或者用 FastAPI 包成 HTTP 接口 → 数据结构和函数划分基本不用动,只换「存」和「进」两头。
最后一条是重点:先按「输入明确、输出明确」把函数拆好(6.1 / 6.4),后面换成网页、接口、Agent 工具时,中间那部分逻辑几乎可以原样搬过去。
16.9 【本章小结】
- 先定数据结构(列表套字典),再写显示、循环、存储,比一上来写完整程序稳得多。
while True+break管交互,if/elif管分发,一个函数只做一件事。pathlib+json负责「下次启动还在」;try/except负责「存档坏了也别崩」。- 用户输入一律当脏数据,把「文字 → 合法下标」单独包一个函数。
if __name__ == "__main__":让文件既能直接跑、又能被导入做测试。- 真实项目就是这样从「能跑的最小版本」一点点长出来的,不是一次写对的。
附录 A 新手必踩的坑
A1 浮点精度
print(0.1 + 0.2) # 0.30000000000000004
print(0.1 + 0.2 == 0.3) # False
print(round(0.1 + 0.2, 2)) # 0.3 用 round 救场
# 输出:
# 0.30000000000000004
# False
# 0.3计算机用二进制存小数,有些十进制小数存不精确。涉及金额请用
decimal。
A2 可变默认参数
def add_item(x, lst=[]): # ❌ 每次调用共用同一个列表
lst.append(x)
return lst
print(add_item(1)) # [1]
print(add_item(2)) # [1, 2] ← 不是 [2]!
# 输出:
# [1]
# [1, 2]正确写法见 6.6。
A3 is 与 ==
a = [1, 2]; b = [1, 2]
print(a == b) # True 值相等
print(a is b) # False 不是同一个对象
print(a is None) # 判断 None 必须用 is
# 输出:
# True
# False
# FalseA4 遍历时修改列表
nums = [1, 2, 3, 4]
for n in nums[:]: # ✅ 遍历副本
if n % 2 == 0:
nums.remove(n)A5 浅拷贝嵌套结构
a = [[1], [2]]
b = a.copy() # 只拷贝了外层
b[0].append(9)
print(a) # [[1, 9], [2]] 内层还是共享的
# 彻底拷贝用 copy.deepcopy(a)
# 输出:
# [[1, 9], [2]]A6 缩进混用 Tab 和空格
会报 TabError。统一用 4 个空格。
A7 中文乱码
读写文件必须指定编码:open("f.txt", encoding="utf-8")。
A8 缩进没错,但逻辑错了
for n in ["小明", "小红"]:
print(f"你好,{n}")
print("大家都在") # 少缩一格 → 只打一次
# 输出:
# 你好,小明
# 你好,小红
# 大家都在你好,小明
你好,小红
大家都在for n in ["小明", "小红"]:
print(f"你好,{n}")
print("大家都在") # 多缩一格 → 每人打一次
# 输出:
# 你好,小明
# 大家都在
# 你好,小红
# 大家都在你好,小明
大家都在
你好,小红
大家都在两段都不报错,因为缩进在语法上完全合法。这类 bug 比 IndentationError 难查得多——缩进决定「这行归谁管」,不只是排版。写完循环先扫一眼:哪些行该在循环里、哪些该在外面。
A9 变量名把内置函数覆盖了
list = [1, 2, 3]
# list("abc") # TypeError: 'list' object is not callablelist、str、sum、id、input 这些内置名字并不特殊,赋值就是把标签贴到别的东西上了(8.1)。换个名字(items、lst)最省事;已经覆盖了想救回来,用 del 把标签删掉,查找时又会回退到内置(7.7 的 LEGB 顺序):
del list
print(list("abc")) # ['a', 'b', 'c']
# 输出(需与上一段代码连着跑):
# ['a', 'b', 'c']附录 B 内置函数速查表
逐个详解见第 8 章(含关键字清单、使用技巧与常见坑)。这一页是"一页纸速查",忘了就翻这里。
| 函数 | 作用 | 示例 |
|---|---|---|
print() | 输出 | print("hi") |
len() | 长度 | len([1,2]) → 2 |
type() | 类型 | type(1) → int |
int/float/str/bool/list/tuple/set/dict | 类型转换 | int("5") → 5 |
range() | 数列 | range(3) → 0,1,2 |
sum/max/min/sorted/reversed | 聚合排序 | sum([1,2]) → 3 |
abs/round/divmod | 数学 | round(3.14159, 2) |
enumerate() | 带序号遍历 | enumerate(["a"]) |
zip() | 配对 | zip([1],["a"]) |
map/filter | 映射 / 过滤 | list(map(str, [1,2])) |
any/all | 任一 / 全部为真 | any([0, 1]) → True |
isinstance() | 类型判断 | isinstance(1, int) |
dir()/help() | 查看 | dir(str) |
open() | 打开文件 | open("f.txt") |
input() | 键盘输入 | input(">") |
id() | 对象标识 | id(a) |
repr()/eval() | 表达式形式 / 求值 | repr("a") → 'a' |
divmod(a, b) | 一次得商和余数 | divmod(10, 3) → (3, 1) |
pow(a, b) | 幂 | pow(2, 10) → 1024 |
format(x, 格式) | 格式化 | format(1234, ",") → '1,234' |
getattr/setattr/hasattr | 按名字取/设/查属性 | getattr(o, "x", 默认值) |
callable(x) | 能不能被调用 | callable(len) → True |
iter()/next() | 迭代器 | next(iter([1,2])) → 1 |
vars(x) | 对象的属性字典 | vars(obj) |
sorted(x, key=, reverse=) | 排序(不改原对象) | sorted(["bb","a"], key=len) |
本笔记以 Python 官方教程(docs.python.org/zh-cn/3/tutorial)为主线,对照《Python 编程:从入门到实践(第 3 版)》补齐实战与测试部分,并参考《流畅的 Python》《Effective Python》《Python Cookbook》补进日常最常用的一些套路。示例按 3.10 以上通用语法编写,均可直接运行;建议配合交互窗口动手练习。
搜索结果
zip、lambda、装饰器、encoding。点一条结果会跳到原文并高亮。实战篇 1 · 常用工具一次认全(zip / map / filter / lambda / is)
补 1.1 先分清三件事:配对、变形、筛选
写循环写久了,你会发现自己总在重复干三件事:把两份数据按位置对齐、把每个元素改一改、把不要的丢掉。Python 给这三件事各配了一个小工具,记住一句话就够:配对用 zip,变形用 map,筛选用 filter。
zip() 像拉拉链:两条拉链并排往上拉,一边出一个齿,配成一对。
names = ["小明", "小红", "小刚"]
scores = [88, 95, 70]
for name, score in zip(names, scores):
print(f"{name}:{score} 分")
# 输出:
# 小明:88 分
# 小红:95 分
# 小刚:70 分map() 像流水线上的喷漆工:来一个零件,按同一个动作处理一下,再送出去。filter() 像质检员:合格的留下,不合格的直接扔掉。
nums = [1, 2, 3, 4, 5, 6]
d = list(map(lambda x: x * x, nums)) # [1, 4, 9, 16, 25, 36]
e = list(filter(lambda x: x % 2 == 0, nums)) # [2, 4, 6]这里有个新手最容易愣住的点:map 和 filter 返回的是迭代器,不是列表。直接 print(map(...)) 只会看到一串内存地址。想看内容就得用 list() 接一下,或者直接拿去 for 循环。迭代器像一次性水杯,倒完就没了,遍历第二遍是空的。
zip 也一样是迭代器,而且长短不齐时按最短的那条停:
list(zip([1, 2, 3], ["a"])) # [(1, 'a')],后面的 2、3 直接丢掉想让长的那条也保留、缺的地方补个默认值,用 itertools.zip_longest:
from itertools import zip_longest
print(list(zip_longest([1, 2, 3], ["a"], fillvalue="-")))
# [(1, 'a'), (2, '-'), (3, '-')]
# 输出:
# [(1, 'a'), (2, '-'), (3, '-')]补 1.2 lambda:不想为三行代码专门起个名字
lambda 就是「一次性小函数」。它只能写一个表达式,算完直接是返回值,连 return 都不用写。
add = lambda a, b: a + b
print(add(2, 3)) # 5
# 输出:
# 5它最常见的用处,是给 sorted、map、filter 临时递一个规则:
words = ["banana", "fig", "apple"]
print(sorted(words, key=lambda w: len(w))) # ['fig', 'apple', 'banana']
# 输出:
# ['fig', 'apple', 'banana']key= 的意思是「按什么比」:上面这句不是按字母顺序排,而是按每个单词的长度排。
什么时候别用 lambda:只要逻辑超过一个表达式,或者要写 if 分支、要复用,就老老实实写 def 并起个能看懂的名字。把一堆逻辑塞进一行 lambda,过两天连自己都读不懂。
补 1.3 推导式 vs map / filter:日常更推荐前者
上面那两句,用列表推导式写更清爽:
nums = [1, 2, 3, 4, 5, 6]
d = [x * x for x in nums] # 变形,等价于 map
e = [x for x in nums if x % 2 == 0] # 筛选,等价于 filter
f = [x * x for x in nums if x % 2 == 0] # 变形 + 筛选一起做读法很简单:「对每个 x 做点什么,只要满足条件的那些」。推导式一眼能看出「结果是列表」,而且不用再套 list(),所以日常写 Python 优先用它。
map / filter 真正合适的地方是规则本身已经是一个现成函数时,比如 list(map(str, nums)) 把数字全转成字符串;或者数据很大、想一路惰性处理不落盘时。换成生成器表达式,把方括号改成圆括号,也一样省内存:
total = sum(x * x for x in range(1_000_000)) # 一个都不存,边算边加字典和集合也有推导式,写法只换个括号:
scores = {"小明": 88, "小红": 95}
passed = {k: v for k, v in scores.items() if v >= 90} # {'小红': 95}
lengths = {len(w) for w in ["a", "bb", "cc"]} # {1, 2}补 1.4 写循环时最常搭的几个小工具
enumerate(序列):一边拿位置一边拿值,别再自己数i += 1。any(...)/all(...):只要有一个为真 / 全部都为真。空容器时any([])是False,all([])是True。sorted(..., key=...):不改原对象,返回排好序的新列表;列表自己的.sort()才是原地改。reversed(序列):倒着遍历。sum / max / min:求和、最大、最小,也能带key=。
words = ["apple", "fig", "banana"]
for i, w in enumerate(words, start=1):
print(i, w)
print(any(len(w) > 5 for w in words)) # True
print(all(len(w) > 2 for w in words)) # True
print(max(words, key=len)) # banana
# 输出:
# 1 apple
# 2 fig
# 3 banana
# True
# True
# banana这些工具配合起来,能替掉绝大多数手写循环。先想「有没有现成的工具」,再想「怎么写 for」,代码会短一大截。
补 1.5 is 与 ==:一个查身份证,一个比长相
这是面试和实战里都最爱挖的坑,其实一句话就能记住:
==比的是值:两个东西内容一样就为真。is比的是身份:是不是同一个对象(同一块内存)才为真。
a = [1, 2]
b = [1, 2]
print(a == b) # True,内容一样
print(a is b) # False,是两个各自新建的列表
c = a
print(a is c) # True,c 只是 a 的又一个名字
# 输出:
# True
# False
# True所以判断「是不是 None」一律写 is None,不要写 == None。None 在整个程序里只有一份,用 is 又快又准。
顺便把另外两个常一起出现的词也钉死:可迭代对象(list、str、dict、range)能反复遍历;迭代器(map、zip、filter、生成器)只能消费一次,取完就没了。想反复用,就先 list() 存下来。
补 1.6 串起来:一份成绩表的小练习
把上面这些工具放在一段真能跑的代码里,感受一下「不手写循环」是什么味道:
students = [
{"name": "小明", "score": 88},
{"name": "小红", "score": 95},
{"name": "小刚", "score": 70},
{"name": "小丽", "score": 59},
]
passed = [s["name"] for s in students if s["score"] >= 60]
print("及格:", passed)
ranked = sorted(students, key=lambda s: s["score"], reverse=True)
for i, s in enumerate(ranked, 1):
print(f"第 {i} 名 {s['name']}:{s['score']}")
avg = sum(s["score"] for s in students) / len(students)
print("平均分:", round(avg, 1))
# 输出:
# 及格: ['小明', '小红', '小刚']
# 第 1 名 小红:95
# 第 2 名 小明:88
# 第 3 名 小刚:70
# 第 4 名 小丽:59
# 平均分: 78.0四件事:if 筛选、sorted 排序、enumerate 编号、生成器表达式求和。整段没有一个手写的 for 用来「攒列表」,这就是写得像 Python 的样子。
一句话收尾:
zip配对、map变形、filter筛选、lambda递规则、is查身份。日常优先推导式,规则现成时再用map/filter,数据太大就换生成器表达式。
实战篇 2 · 写出靠谱的代码(调试、类型注解、pathlib、CSV / JSON)
补 2.1 报错别慌,倒着读 Traceback
程序一崩,屏幕上哗啦一大片红字,新手第一反应是「完了」。其实有用的只有两处:最后一行告诉你出了什么错,从下往上找到自己文件里的那一行告诉你在哪儿炸的。
def divide(a, b):
return a / b
divide(10, 0)
# (说明:这一段是在演示「除以 0」会直接报错,所以故意不写输出)Traceback (most recent call last):
File "demo.py", line 5, in <module>
divide(10, 0)
File "demo.py", line 2, in divide
return a / b
ZeroDivisionError: division by zero最后一行是「错误类型 + 说明」,上面一串像面包屑,记录谁调用了谁。最靠下、属于你自己文件的那层,才是真正要改的地方。
几个高频错误类型,看到就能猜到去哪儿找:
| 报错 | 多半是 | 先去看 |
|---|---|---|
IndexError | 下标越界 | 列表长度、len() |
KeyError | 字典没这个键 | 键名拼写,或改用 get() |
TypeError | 类型对不上 | 是不是把字符串当数字用了 |
ValueError | 值不合法 | int("abc") 这类转换 |
FileNotFoundError | 路径不对 | 当前工作目录、文件名 |
AttributeError | 对象没这个方法 | 是不是把名字覆盖了 |
补 2.2 调试三板斧:打印、日志、断点
最土也最有效的办法,是在可疑的地方插一行 print,看看变量到底变成了什么:
print("这里 user =", user, "类型 =", type(user))
# (说明:这一段要连着上一段代码一起跑才有输出)问题一多,print 就满屏都是,上线前还得一条条删。这时候换 logging:
import logging
logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")
logging.info("开始处理 %s", filename)
logging.warning("第 %d 行格式不太对,先跳过", line_no)
logging.error("读文件失败", exc_info=True)
# (说明:这一段要连着上一段代码一起跑才有输出)logging 能分级别、能顺手写进文件、能统一开关,比 print 适合留在线上。第三板斧是编辑器里的断点调试:在行号左边点一下,程序跑到那儿会停住,你能一个一个看变量、单步往下走。真遇到「逻辑没错但结果不对」,断点比加十行 print 快得多。
补 2.3 类型注解:把「收什么、返回什么」写清楚
Python 不要求你声明类型,但给函数写上注解,别人(和三个月后的你)一眼就知道该怎么调用:
def greet(name: str, times: int = 1) -> str:
return (f"你好,{name}!" * times)
def total(items: list[int]) -> int:
return sum(items)list[str]、dict[str, int]、str | None(表示「要么是字符串,要么是 None」)都是常用写法。关键要明白:注解只是给人、给编辑器、给检查工具看的,Python 运行时不会替你校验类型。你传个字符串进 total(),它不会在函数门口拦你,只会在后面算的时候报错。
想真的做校验,要么自己写 if not isinstance(...): raise TypeError(...),要么用 Pydantic 这类库——FastAPI 的自动参数校验就是靠它。
补 2.4 pathlib:别再手拼路径字符串
Windows 用反斜杠、macOS / Linux 用正斜杠,手动拼 "data" + "/" + name" 迟早出事。pathlib 用 / 运算符帮你拼,还能顺手做「存在吗、建目录、找文件」:
from pathlib import Path
data_dir = Path("data")
data_dir.mkdir(parents=True, exist_ok=True)
f = data_dir / "日记.txt"
f.write_text("今天写了第一个脚本\n", encoding="utf-8")
print(f.read_text(encoding="utf-8"))
for py in Path(".").glob("*.py"):
print(py.name, py.stat().st_size)
# 输出:
# 今天写了第一个脚本
#
# an_runs.py 2134
# apply_blocks.py 1119
# apply_new3.py 3916
# apply_outputs.py 3743
# fix_outputs2.py 4109
# handle_fail.py 5511
# restore_kn.py 3868
# run_all.py 2600
# run_all_codes.py 2867
# run_new_codes.py 2690
# _add_agent.py 6487
# _add_rag.py 5799Path("data") / "日记.txt" 这个 / 不是除法,是「拼一节路径」。read_text / write_text 记得都带上 encoding="utf-8",中文才不会乱码。要遍历子目录,把 glob("*.py") 换成 rglob("*.py")。
补 2.5 argparse:让脚本能带参数跑
写死文件名的脚本,换份数据就得改代码。加几行 argparse,就能从命令行传进来:
# count.py
import argparse
from pathlib import Path
parser = argparse.ArgumentParser(description="统计文本文件行数")
parser.add_argument("file", help="要统计的文件路径")
parser.add_argument("--encoding", default="utf-8", help="文件编码,默认 utf-8")
args = parser.parse_args()
lines = Path(args.file).read_text(encoding=args.encoding).splitlines()
print(f"{args.file} 一共 {len(lines)} 行")
# (说明:这一段是在演示「测试失败」,故意让它报错)python count.py data\日记.txt
python count.py data\日记.txt --encoding gbk
python count.py --helpadd_argument 里不带横线的叫位置参数(必须给),带 -- 的叫可选参数(有默认值)。--help 是白送的,不用自己写。
补 2.6 CSV 与 JSON 批处理:读一堆、汇一份
真实工作里最常见的活儿:把一堆表格文件读进来,算个汇总,再写出去。csv 模块处理表格,json 处理配置和网络数据。
import csv
import json
from pathlib import Path
rows = []
for f in Path("data").glob("*.csv"):
with f.open(encoding="utf-8-sig", newline="") as fp:
rows.extend(csv.DictReader(fp))
print("一共读到", len(rows), "行")
with open("汇总.csv", "w", encoding="utf-8-sig", newline="") as fp:
w = csv.DictWriter(fp, fieldnames=["name", "score"])
w.writeheader()
w.writerows(rows)
config = {"source_dir": "data", "min_score": 60}
Path("config.json").write_text(
json.dumps(config, ensure_ascii=False, indent=2), encoding="utf-8"
)
# 输出:
# 一共读到 0 行三个容易漏的细节:newline="" 是写 CSV 的标配,不然 Windows 上会多出空行;utf-8-sig 能让 Excel 打开中文不乱码;ensure_ascii=False 让 JSON 里的中文保持原样,而不是变成 \u5c0f\u660e。
补 2.7 一个小项目该长什么样
不用一上来就学框架。把前面这些拼起来,一个能维护的小项目大概是这样:
mytool/
pyproject.toml 装什么依赖、怎么打包
requirements.txt pip install -r requirements.txt
README.md 怎么装、怎么跑
src/mytool/
__init__.py
__main__.py python -m mytool 的入口
cli.py argparse 收参数
core.py 真正干活的纯函数
storage.py pathlib + json / csv 读写
tests/
test_core.py pytest 测 core.py要点只有四条:干活的函数不碰输入输出(好测)、入口单独放(if __name__ == "__main__":)、路径和编码显式写、给最容易算错的函数配两三个 pytest。做到这四条,脚本就已经是「项目」了。
写到这儿,你已经能独立完成「读文件 → 清洗 → 计算 → 写结果 → 带参数运行 → 出错有日志 → 改完有测试」这条完整链路。剩下的不是学更多语法,而是多写几个真东西。
实战篇 3 · 再往前一步(async / await、API、FastAPI 与学习路线)
补 3.1 async / await:到底在等什么
前面写的代码都是「一步做完再做下一步」。如果一步是「等网络返回」,CPU 就干坐着浪费时间。async 的意思是:碰到要等的地方,先让出去干别的,等对方回话了再接着做。
import asyncio
async def fetch(name, seconds):
print(f"{name} 开始等")
await asyncio.sleep(seconds) # 模拟「等网络」,这里会让出控制权
print(f"{name} 等完了")
return name
async def main():
results = await asyncio.gather(fetch("A", 2), fetch("B", 1), fetch("C", 1))
print("都回来了:", results)
asyncio.run(main())
# 输出:
# A 开始等
# B 开始等
# C 开始等
# B 等完了
# C 等完了
# A 等完了
# 都回来了: ['A', 'B', 'C']三份任务一共约 2 秒,而不是 2+1+1 秒,因为等待时间重叠了。要记住三点:
async def定义的是协程,光调用它不会执行,得await或交给asyncio.run()。await只能在async def里面写,而且只对「可等待对象」用。- 协程擅长等 I/O(网络、磁盘、数据库)。如果是纯算数字,多线程也帮不上忙,得用多进程。
配套的库要用异步版(aiohttp、httpx.AsyncClient),普通 requests 是同步的,放进协程里照样会把整条线卡住。
补 3.2 调一个 API:请求、超时、异常、解析
Python 做 AI 应用、爬虫、对接服务,最常做的就是发个 HTTP 请求拿 JSON。标准库 urllib 能做,但第三方 requests 写起来舒服得多(pip install requests):
import requests
url = "https://httpbin.org/get"
try:
r = requests.get(url, params={"q": "python"}, timeout=5)
r.raise_for_status() # 4xx / 5xx 直接抛异常
data = r.json() # JSON → dict / list
print(data["args"])
except requests.Timeout:
print("对方太久没回话,别死等")
except requests.HTTPError as e:
print("服务返回了错误状态:", e)
except requests.RequestException as e:
print("网络这一层出问题了:", e)
# (说明:需要先装第三方库:pip install requests)一定要写 timeout。不写的话,对方不回应你的程序就会一直挂着。raise_for_status() 也别省,不然 404 的页面会被当成正常结果去解析。
调接口拿回来的 JSON,和 Python 的对应关系就这几条:object → dict、array → list、string → str、true/false → True/False、null → None。datetime、set 这些 json.dumps 不认识,要自己转成字符串或列表。
补 3.3 反过来:用 FastAPI 写个最小服务
前面都在「调别人」,自己提供一个接口也不难(先 pip install fastapi uvicorn):
# app.py
from fastapi import FastAPI
from pydantic import BaseModel
app = FastAPI()
class AddIn(BaseModel):
a: int
b: int
@app.get("/hello")
def hello(name: str = "世界"):
return {"message": f"你好,{name}"}
@app.post("/add")
def add(body: AddIn):
return {"result": body.a + body.b}
# (说明:需要先装第三方库:pip install fastapi)uvicorn app:app --reload浏览器打开 http://127.0.0.1:8000/docs,会自动看到一份可交互的接口文档。这里正好把前面的知识串起来了:
@app.get(...)是装饰器,在定义时把函数登记到路由表上;name: str = "世界"是类型注解 + 默认参数;AddIn这个类由 Pydantic 按注解做运行时校验,传错类型会自动返回 422;- 返回
dict,框架替你json.dumps成响应体。
所以看框架别觉得是另一门语言,底下就是函数、装饰器、类型注解、字典这几样。
补 3.4 标准库再补几个顺手的
不用全背,知道「有这么个东西」就够了,用到再查:
from collections import Counter, defaultdict
from itertools import chain, zip_longest
from functools import lru_cache
from dataclasses import dataclass
print(Counter("banana")) # Counter({'a': 3, 'n': 2, 'b': 1}),数次数神器
print(list(chain([1, 2], [3, 4]))) # [1, 2, 3, 4],把几段接成一段
@dataclass
class Point:
x: int
y: int
print(Point(1, 2)) # 自动生成 __init__ / __repr__ / __eq__
@lru_cache(maxsize=None)
def fib(n):
return n if n < 2 else fib(n - 1) + fib(n - 2)
# 输出:
# Counter({'a': 3, 'n': 2, 'b': 1})
# [1, 2, 3, 4]
# Point(x=1, y=2)
# (说明:集合是无序的,每次打印的顺序都可能不同)Counter 数词频、defaultdict 免去「键不存在先建空列表」、zip_longest 补全 zip 截断的短板、dataclass 少写一整个类、lru_cache 把算过的结果记住(递归瞬间不卡了)。这几个是「用过一次就离不开」的类型。
想看看代码慢在哪,别靠猜:timeit.timeit() 比小段代码,python -m cProfile 脚本.py 看整个程序每个函数耗了多久。
补 3.5 一份「我能写 Python 了」的自检清单
学完这份文档,拿下面这张清单对着做一遍。能独立写出前六条,就够应付绝大多数日常脚本了:
- [ ] 写一个脚本,从命令行收文件路径,读进来按行处理,把结果写到另一个文件
- [ ] 中间遇到坏数据不崩:用
try / except跳过并记一行logging.warning - [ ] 把「读文件」「算逻辑」「写结果」拆成三个函数,逻辑函数不碰
print - [ ] 用
pathlib管路径、显式encoding="utf-8"、用with或read_text关文件 - [ ] 用推导式 +
sorted(key=lambda ...)+enumerate替掉手写攒列表的循环 - [ ] 给最容易算错的函数写 2~3 个 pytest,改完代码跑一遍还是绿的
- [ ] 用
python -m venv .venv建环境,pip freeze > requirements.txt记依赖 - [ ] 遇到报错先倒着读 Traceback,能自己定位到是哪一行
补 3.6 接下来往哪儿走
到这一步,语法已经不是瓶颈了。按自己的目标挑一条路:
- 做网站 / API:接上 FastAPI 官方教程,补 SQL 数据库(SQLAlchemy 或直接用
sqlite3)、认证、部署。 - 做 AI 应用:把「调 API、解析 JSON、处理异常、写异步」这几节练熟,再去看 Agent 框架,会发现大半都是这些基础在组合。
- 做数据处理:
csv→pandas,再补一点 SQL 和画图。 - 想读框架源码:补装饰器进阶、描述符、
__init_subclass__、上下文管理器协议,以及dis看字节码。
别急着囤课程。挑一个自己真想做的小东西,写崩了、查明白、改好,比多看十章教程管用。配套的完整体系自测在侧栏「Python 知识体系在线自测 - 我的图片」,学完一批就去测一遍,看看哪块还虚。