文档首页
PYTHON · 在线知识文档
学习路线 第 1 / 6 步 · 模块 ①Python 语言与工程基础下一站 ② FastAPI 框架 →完整顺序:① Python → ② FastAPI → ③④ Prompt → ⑤⑥ Agent → ⑦ RAG → ⑧⑨ 框架与 MCP → ⑩ 多 Agent(回看)→ ⑪~⑭ 编写中 · 查看学习路线图 →

从第一行代码,到写出能用的小程序

左边点目录,右边看知识点;顶上「全文速览」能把 21 章一次铺开通读,左上角搜索能搜到正文和代码里的每个词。暗色护眼,代码、表格、提示都保留原样,每章末尾还有小测。

去做在线自测 → AI Agents 学习路线 →
21个章节
137个小节
105道章末小测
测
配套推荐
Python 知识体系在线自测 - 我的图片

按整套知识体系自己测一遍,适合学完几章之后查漏补缺。链接:https://myimage.cn/python/

打开在线自测 →
练
配套推荐
Python实战 - 我的图片

把学过的知识真正敲出来:36 个单元、190+ 动手任务,案例 → 任务 → 看答案,附 10 套考试,纯本地无需联网。链接:https://myimage.cn/python-practical/

打开 Python实战 →
典
配套推荐
Python 内置函数与模块 - 我的图片

70 章逐个学:list / str / dict / set 等数据结构,到常用标准库、语法机制,再到 requests / numpy / fastapi 第三方扩展。每章 demo + 6 个任务附多解法。链接:https://myimage.cn/python-modules/

打开内置函数与模块 →

全部章节

第 01 章

第 1 章 先把 Python 跑起来

1.1 Python 能干什么(官方"课前甜点"三句话)

  • 写几行代码就能完成别的语言几十行才能做的事;
  • 自带强大的数据结构(列表、字典等)和海量现成工具库;
  • 既适合写小脚本,也能开发大型应用和 AI 服务。

写过别的语言再来学 Python,先记住三个「不一样」,后面很多坑都跟它们有关。

第一,不用声明类型。别的语言要写 int age = 18;,Python 只写 age = 18。而且同一个名字随时能改成别的东西:

PYTHON
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 用缩进。看着只是排版,其实是语法的一部分:

PYTHON
score = 90
if score >= 60:
    print("及格")           # 缩进去的这行归 if 管
print("这句话不管及不及格都会打印")
# 输出:
#   及格
#   这句话不管及不及格都会打印
TEXT
及格
这句话不管及不及格都会打印

第三,常用的东西都自带。不用装任何依赖就能处理 JSON、拼路径、算日期:

PYTHON
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 回车,出现 >>> 提示符:

TEXT
>>> 1 + 2
3
>>> print("你好")
你好

输入 exit() 或按 Ctrl+Z 回车退出。 交互模式下,最后一次输出的结果会存在 _ 里:

TEXT
>>> 10 * 3
30
>>> _ + 5      # 相当于 30 + 5
35

方式二:脚本模式(写真正的程序)

新建 hello.py,内容:

PYTHON
print("你好,世界")
# 输出:
#   你好,世界

终端运行:python hello.py → 输出 你好,世界。

在 Windows 的 PowerShell 里,先把环境确认一下:

POWERSHELL
python --version        # Python 3.15.2
py --version            # 装了多个版本时,用 py 指定版本更稳
python .\hello.py       # 跑脚本

如果报「python 不是内部或外部命令」,多半是安装时没勾 Add Python to PATH;重跑安装包补上,或者先用 py 顶一下。VS Code 里按右上角那个三角形,本质也是在终端执行了上面这条命令,只是帮你把解释器和路径选好了。

交互模式真正好用的地方不是算数,而是查东西。忘了某个方法怎么用,直接问解释器:

TEXT
>>> help(str.split)
>>> dir([])             # 看看列表身上到底有哪些方法
>>> type(1 + 1.5)
<class 'float'>

写脚本时还能从命令行把参数传进去。sys.argv 是个列表,第 0 项是脚本自己的名字,真正传进来的从 1 开始:

PYTHON
# hello.py
import sys
name = sys.argv[1] if len(sys.argv) > 1 else "世界"
print(f"你好,{name}")
# 输出:
#   你好,世界
POWERSHELL
python .\hello.py 小明
TEXT
你好,小明

为什么要费这个事?因为脚本不是给人一行行敲的,它要能被别的程序、定时任务、批处理调用。参数从外面传进来,同一个 .py 文件才能处理不同的输入。

1.3 注释与编码

PYTHON
# 这是单行注释,Python 不会执行它

"""
这是多行注释(其实是多行字符串)
常用来写文件顶部的说明
"""

name = "小明"   # 也可以在代码后面写注释(前面至少两个空格)

中文编码:Python 3 默认就是 UTF-8,不需要像 Python 2 那样写 # -*- coding: utf-8 -*-。但读写文件时建议显式写 encoding="utf-8"(见第 10 章)。

顺手把两件容易混的事说清楚。

"""...""" 严格讲不是注释,是一个字符串。它之所以常被放在文件开头当说明,是因为 Python 会把「模块或函数里的第一句字符串」当成文档字符串存起来,之后能用 help() 或 __doc__ 查到:

PYTHON
"""这个模块用来演示文档字符串。"""

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,就会变成一堆问号或乱码。所以读写文件永远显式写上:

PYTHON
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 输出、输入、缩进

PYTHON
print("姓名:", "小明", "年龄:", 18)   # 逗号分隔,自动加空格
print("第一行\n第二行")                # \n 换行
print("不换行", end="")                 # 默认 print 会换行,end="" 取消

name = input("请输入你的名字:")        # 从键盘读,读到的永远是字符串
print("你好," + name)
# 输出(输入示例:小明):
#   姓名: 小明 年龄: 18
#   第一行
#   第二行
#   不换行请输入你的名字:你好,小明

缩进是语法的一部分!同一段代码必须对齐(推荐 4 个空格)。缩进错了会报 IndentationError。

print() 其实比你以为的能干。它默认把多个参数用空格隔开、结尾自动换行,这两个行为都能改:

PYTHON
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() 有个几乎人人踩过的坑:它永远返回字符串。想算数得自己转类型:

PYTHON
a = input("第一个数:")
b = input("第二个数:")
print("直接相加:", a + b)            # 输入 1 和 2 → 12
print("转成数字:", int(a) + int(b))  # 3
# (说明:这段要你自己输入内容才能继续,没有固定输出)
TEXT
第一个数:1
第二个数:2
直接相加: 12
转成数字: 3

为什么是 12 不是 3?因为 + 对字符串的意思是「接起来」,对数字才是「相加」。Python 不会替你猜,也不会像 JS 那样悄悄转换(1 + "2" 在 JS 里给 "12",在 Python 里直接报 TypeError)。所以从用户、文件、接口拿到的文字,动手算之前先 int() / float() 转一下,这是写 Python 的肌肉记忆。《从入门到实践》里凡是读用户输入的例子,都要走这一步,原因就在这。

顺带提前认识一下最常用的输出写法,{} 里可以直接放变量,甚至直接算:

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"
第 02 章

第 2 章 数字与文本(把 Python 当计算器)

2.1 数字

PYTHON
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
PYTHON
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 了。想要整数商,就明明白白写 //:

PYTHON
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:

PYTHON
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 起),纯粹为了人眼好读,解释器会忽略:

PYTHON
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... 永远写不完,只能截断。截断带来的那一点点误差,比较时就会冒出来:

PYTHON
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)

四种写法

PYTHON
a = '单引号'
b = "双引号"          # 和单引号等价
c = "里面有双引号 \" 需要转义"
d = """多行
字符串"""
e = r"C:\new\test"   # r 前缀 = 原始字符串,\n 不被当成换行

常用操作

PYTHON
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 才能放心地把它共享、缓存、拿去当字典的键。看个证据:

PYTHON
s = "abc"
before = id(s)          # id() 是对象的"身份证号"
s = s + "d"             # 看着像在 s 后面加了一个字符
print(s)                # abcd
print(id(s) == before)  # False   → 已经是另一个新对象了
# 输出:
#   abcd
#   False

代价是:循环里反复用 + 拼字符串,每一步都要把整段复制一遍,数据一大就明显变慢。所以拼很多段时统一用 join():它先算好总长度,一次拼完。

PYTHON
parts = ["2026", "01", "01"]
print("/".join(parts))                 # 2026/01/01
print("".join(["a", "b", "c"]))        # abc
# 输出:
#   2026/01/01
#   abc

还有个由此而来的高频 bug:所有字符串方法都不改原串,只返回新串,忘了接住返回值就等于白干。

PYTHON
s = "a-b-c"
print(s.replace("-", "/"))    # a/b/c
print(s)                      # a-b-c   原串一点没动
# 输出:
#   a/b/c
#   a-b-c

这也带来一个很好用的写法:因为每个方法都吐出一个新字符串,可以像流水线一样一路点下去。清洗用户输入、文件名、接口返回的文字时天天这么写:

PYTHON
raw = "  Hello, PYTHON  "
clean = raw.strip().lower().replace("python", "世界")
print(clean)                  # hello, 世界

name = "  小明  "
print(f"用户标识:{name.strip()}")     # 用户标识:小明
# 输出:
#   hello, 世界
#   用户标识:小明

顺序是有讲究的:先 strip() 去掉两头空白,再 lower() 统一大小写,最后才替换。要是先替换再 strip(),前后带空格的文本就可能匹配不上。

split() 不传参数是被低估的一个用法:它按「任意空白」切,还会自动丢掉多余的空格、制表符、换行,处理粘贴来的文本特别省事:

PYTHON
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,最推荐)

PYTHON
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,不用 + 拼?对比一下就知道:

PYTHON
name, age = "小明", 18
print("你好," + name + ",今年 " + str(age) + " 岁")   # 得自己把数字转成字符串
print(f"你好,{name},今年 {age} 岁")                   # 你好,小明,今年 18 岁
# 输出:
#   你好,小明,今年 18 岁
#   你好,小明,今年 18 岁

+ 只能拼字符串,混进数字就得手动 str(),还容易漏掉空格;f-string 自动把值变成「给人看的样子」,{} 里还可以直接算。调试时有个特别省事的写法(3.8 起):= 会把表达式本身一起打出来。

PYTHON
x = 10
print(f"{x=}")              # x=10
print(f"{x=}, {x * 2=}")    # x=10, x * 2=20
# 输出:
#   x=10
#   x=10, x * 2=20

再补几个处理文本时很顺手的方法:

PYTHON
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() 更省心:

PYTHON
s = "hello.py"
print("py" in s)        # True    直接给 True/False
print(s.find("py"))     # 6       要位置才用它
print(s.find("xxx"))    # -1      找不到返回 -1,忘了判断就会当成"在第 -1 位"
# 输出:
#   True
#   6
#   -1

index() 和 find() 做一样的事,区别是找不到时抛 ValueError 而不是返回 -1——有时候这正是你想要的:出错就立刻停,别让一个 -1 悄悄流到后面去。

转义字符与原始字符串。反斜杠是「后面这个字符要特殊理解」的开关,\n 是换行、\t 是制表符、\" 是一个普通双引号:

PYTHON
print("第一行\n第二行")     # 第一行(换行)第二行
print("他说 \"你好\"")      # 他说 "你好"
print(r"C:\new\test")      # C:\new\test
# 输出:
#   第一行
#   第二行
#   他说 "你好"
#   C:\new\test
#   (说明:路径、时间、目录内容随你自己的机器而变,你跑出来的会不一样)

Windows 路径里的 \n、\t 恰好都是转义序列,所以写路径要么加 r 前缀,要么用正斜杠 "C:/new/test",要么干脆交给 pathlib(第 10 章)。这三种写法你会在别人的代码里都见到。

三引号最实际的用途是存多行文本:一段 SQL、一封邮件模板、给大模型用的长提示词。

PYTHON
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:,}"
第 03 章

第 3 章 列表:第一个容器

【本章导览】 一个一个变量太慢了,容器让你"批量管理数据":

  1. 列表长什么样?索引、切片、长度怎么取。
  2. 列表"可变"带来哪些增删改操作。
  3. 用列表当栈和队列(以及为什么队列要用 deque)。
  4. 列表推导式:Python 最有代表性的语法糖,必须掌握。
  5. 拷贝的坑:b = a 为什么不是复制。

难度:★★☆☆☆ | 预计用时:40 分钟 | 前置知识:第 2 章

3.1 列表长什么样

PYTHON
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 里最省力的一把刀,入门书往往只给一行例子就过去了。写法是 [起点:终点:步长],起点和终点都能省:

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:] 严丝合缝拼回原列表:

PYTHON
i = 2
print(nums[:i], nums[i:])    # [10, 20] [30, 40, 50]
# 输出(需与上一段代码连着跑):
#   [10, 20] [30, 40, 50]

写分页、把数据切成前后两半、跑交叉验证时,这个性质省掉一堆 +1 / -1 的调试。

还有个细节:切片越界不报错,索引越界会报错。

PYTHON
print(nums[2:100])     # [30, 40, 50]   取到头自然停
# print(nums[100])     # IndexError: list index out of range
# 输出(需与上一段代码连着跑):
#   [30, 40, 50]

因为切片的语义是「取一段」,取到没东西就结束;索引是「精确指名要某一个」,没有就是你的逻辑错了。

切片还能整体替换一段,而且新的一段长度不必和原来一样:

PYTHON
words = ["a", "b", "c", "d"]
words[1:3] = ["X", "Y", "Z"]
print(words)           # ['a', 'X', 'Y', 'Z', 'd']
# 输出:
#   ['a', 'X', 'Y', 'Z', 'd']

最后记住:切片不是列表专属,字符串、元组这些序列都能切,规则完全一样:

PYTHON
print("Python-3.15"[:6])     # Python
print((1, 2, 3)[::-1])       # (3, 2, 1)
# 输出:
#   Python
#   (3, 2, 1)

3.2 列表是"可变的"

PYTHON
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(列表) 不改原列表而是返回新列表。

三个「加元素」的方法,新手经常分不清该用哪个:

PYTHON
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() 只删第一个匹配的值,找到了就收工:

PYTHON
nums = [1, 2, 1, 2, 1]
nums.remove(1)
print(nums)          # [2, 1, 2, 1]   后面两个 1 还在
# 输出:
#   [2, 1, 2, 1]
#   (说明:耗时与机器性能有关,数值会不同)

想删干净,《从入门到实践》里给的套路是配 while,因为「还有没有」这件事可以一直问:

PYTHON
while 2 in nums:
    nums.remove(2)
print(nums)          # [1, 1, 1]
# 输出(需与上一段代码连着跑):
#   [1, 1]

更推荐的是干脆不改动原列表,用推导式造一个新的(5.1 会讲为什么遍历时改列表会漏元素):

PYTHON
nums = [n for n in nums if n != 2]
# (说明:这一段要连着上一段代码一起跑才有输出)

几乎所有「就地修改」的方法都返回 None,这是个很常见的坑:

PYTHON
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 不知道一个元组里哪个字段该当大小,你得告诉它:

PYTHON
students = [("小明", 18), ("小红", 20), ("小李", 19)]
print(sorted(students, key=lambda s: s[1]))
# [('小明', 18), ('小李', 19), ('小红', 20)]
# 输出:
#   [('小明', 18), ('小李', 19), ('小红', 20)]

key 会对每个元素算出一个「用来比较的值」,然后按这个值排,元素本身原样保留。注意传的是函数本身(key=len 不带括号),不是调用结果。

3.3 用列表当"栈"和"队列"

PYTHON
# 栈:后进先出(像叠盘子)
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 的特色,务必掌握)

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 条件]。

把上一行展开成普通循环,就明白它到底省了什么:

PYTHON
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 放在两个不同位置,意思完全不一样,这里最容易搞混:

PYTHON
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 是过滤条件,决定「留不留」,结果会变短。想写「筛完再变形」,两个可以一起用:

PYTHON
print([x * x for x in nums if x % 2 == 0])     # [4, 16]
# 输出(需与上一段代码连着跑):
#   [4, 16]

把方括号换成花括号或圆括号,就得到另外三种推导式,语法是一套:

PYTHON
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 解包(把列表拆给多个变量)

PYTHON
a, b, c = [1, 2, 3]
first, *rest = [1, 2, 3, 4]     # first=1, rest=[2,3,4]
x, y = y, x                      # 交换两个变量(经典写法)
# (说明:这一段要连着上一段代码一起跑才有输出)

3.6 拷贝的坑(重要)

PYTHON
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() 只复制了外面一层。列表里还装着列表时,里面那层仍然是共用的:

PYTHON
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)
第 04 章

第 4 章 走向编程第一步:变量、if 与 while

【本章导览】 从这一章开始,代码不再是从上到下走到底,而是会"做判断、会重复":

  1. 变量:怎么起名字、怎么赋值、Python 的变量和别的语言有什么不同。
  2. if 分支:完整的语法结构、什么值算"真 / 假"、三元表达式。
  3. while 循环:执行流程、为什么必须有"推进条件"、三种常用循环套路。
  4. break / continue / 循环的 else 怎么用。

难度:★★☆☆☆ | 预计用时:40 分钟 | 前置知识:第 1~3 章

4.1 变量与赋值

变量是什么:变量就是给数据起的一个名字。写下 age = 18,意思是"让 age 这个名字指向数字 18",后面用 age 就等价于用 18。

Python 的变量更像贴在对象上的一张标签,而不是一个装东西的盒子。所以 a = 18 之后 a = "abc" 完全合法——标签撕下来贴到别的东西上就行了(这就是"动态类型")。

PYTHON
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 是条件分支语句。它的意思是——如果某个条件成立,就执行某段代码;否则执行另一段(或不执行)。

完整语法结构

PYTHON
if 条件1:
    条件1 成立时执行的代码      # 必须缩进(4 个空格)
elif 条件2:
    条件1 不成立、但条件2 成立时执行
elif 条件3:
    ...                        # elif 可以有任意多个,也可以没有
else:
    上面都不成立时执行           # else 最多一个,也可以省略
# (说明:这一段需要外部环境(文件 / 网络 / 第三方服务)才能跑出结果)

四个要点:

  1. 条件后面必须有冒号 : —— 忘了冒号是最常见的新手错误。
  2. 冒号下面的代码块必须缩进,缩进决定"这段代码归谁管"。
  3. elif 是 "else if" 的缩写,可以有 0 个或多个。
  4. else 可选,表示"其他所有情况"。
PYTHON
age = 20
if age < 18:
    print("未成年")
elif age < 60:
    print("成年人")
else:
    print("老年人")
# 输出:
#   成年人

多个 if 是挨个都判断一遍;if / elif / else 是只走第一个成立的分支,判断完就跳过其余的。

if 支持嵌套(一层套一层,注意别套太深)

PYTHON
score = 85
if score >= 60:
    if score >= 90:
        print("优秀")
    else:
        print("及格")
else:
    print("不及格")
# 输出:
#   及格

什么算"真",什么算"假"(非常重要)

if 后面不一定非要是比较表达式,任何值都能当条件。Python 里以下这些值被判定为假(False),其余都是真(True):

假值说明
False布尔假
None空值
0、0.0数字零
""空字符串
[]、()、{}、set()空容器
PYTHON
name = input("请输入姓名:")
if name:                      # 直接把字符串当条件:非空就是真
    print("你好," + name)
else:
    print("你没输入名字")

nums = []
if not nums:                  # 推荐这种写法判断"列表为空"
    print("列表是空的")
# 输出(输入示例:小明):
#   请输入姓名:你好,小明
#   列表是空的

比较运算符与逻辑运算符

PYTHON
# 比较:==  !=  >  <  >=  <
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)

PYTHON
# 其他语言:条件 ? 值1 : 值2
# Python:值1 if 条件 else 值2
level = "及格" if score >= 60 else "不及格"
tip = "成年" if age >= 18 else "未成年"
# (说明:这一段要连着上一段代码一起跑才有输出)

只适合简单的二选一。逻辑一复杂就老老实实写 if/else,可读性优先。

短路求值还有个很 Python 的用法:给个默认值。

PYTHON
name = input("名字(直接回车就用默认的):") or "匿名"
print(f"你好,{name}")
# 输出(输入示例:小明):
#   名字(直接回车就用默认的):你好,小明

为什么能这么写?因为 Python 的 and / or 返回的不是 True / False,而是参与运算的某个值本身:

PYTHON
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 是条件循环语句。意思是——只要条件还成立,就反复执行下面这段代码,直到条件不成立为止。

语法

PYTHON
while 条件:
    条件成立时反复执行的代码      # 同样要缩进
# (说明:这一段要连着上一段代码一起跑才有输出)

执行流程(理解这个就不会写出死循环):

TEXT
① 判断条件 → ② 成立就执行循环体 → ③ 回到 ① 再判断 → …… → 条件不成立 → 退出循环
PYTHON
# 打印 1 到 5
i = 1
while i <= 5:
    print(i)
    i += 1          # ← 关键:让条件一步步走向不成立。忘了这行就是死循环!
# 输出:
#   1
#   2
#   3
#   4
#   5

【坑】死循环:循环体里没有任何让条件变化的代码,程序就永远出不来(只能 Ctrl+C 中断)。 写 while 时先问自己一句:"这个循环靠什么停下来?"

三种最常用的循环套路

套路一:计数器循环(知道要跑几次)

PYTHON
# 打印斐波那契数列前 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(不知道要跑几次,"满足条件就跳出")

PYTHON
# 让用户反复输入,直到输入 quit
while True:                # 故意写成恒真
    cmd = input("请输入命令(quit 退出):")
    if cmd == "quit":
        break              # 直接跳出整个循环
    print("你输入了:", cmd)
# 输出(输入示例:quit):
#   请输入命令(quit 退出):

套路三:输入校验(错了就重来,直到输入合法)

PYTHON
while True:
    text = input("请输入整数:")
    if text.lstrip("-").isdigit():
        num = int(text)
        break
    print("输入不合法,请重来")
print("收到:", num)
# 输出(输入示例:3):
#   请输入整数:收到: 3

break / continue / 循环的 else

PYTHON
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
PYTHON
# 循环的 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,不如立一个标志变量:

PYTHON
active = True
while active:
    msg = input("说点什么(q 退出):")
    if msg == "q":
        active = False       # 只在这一处决定"要不要继续"
    else:
        print("回声:", msg)
# (说明:这段要你自己输入内容才能继续,没有固定输出)

读代码的人只看 active 在哪儿被改,就知道循环什么时候结束。退出条件越多,这个写法越清爽。

用 while 把数据从一个列表搬到另一个。这是处理「待办 → 已完成」这类队列的标准写法:

PYTHON
unconfirmed = ["小明", "小红", "小李"]
confirmed = []

while unconfirmed:              # 列表空了就是假,循环自动停
    person = unconfirmed.pop()  # 一边取、一边从原列表删掉
    print("已验证:", person)
    confirmed.append(person)

print("未验证:", unconfirmed)   # []
print("已验证:", confirmed)     # ['小李', '小红', '小明']
# 输出:
#   已验证: 小李
#   已验证: 小红
#   已验证: 小明
#   未验证: []
#   已验证: ['小李', '小红', '小明']

妙处在于不用自己管下标、也不用数还剩几个:pop() 顺手把元素摘走了,while 列表 又天然知道什么时候收工。注意顺序是倒的(因为从末尾弹),想保持原顺序可以用 deque.popleft()(见 3.3)。

边问边往字典里存。input() + while + 字典,几乎就是所有「信息登记表」的雏形:

PYTHON
answers = {}
while True:
    name = input("姓名(直接回车结束):").strip()
    if not name:
        break
    answers[name] = input("想去哪座城市?")

print(answers)
# (说明:这段要你自己输入内容才能继续,没有固定输出)
TEXT
姓名(直接回车结束):小明
想去哪座城市?杭州
姓名(直接回车结束):小红
想去哪座城市?成都
姓名(直接回车结束):
{'小明': '杭州', '小红': '成都'}

为什么用字典?因为「一个名字对应一份回答」正是键值对要解决的问题,接口返回的 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 时执行
第 05 章

第 5 章 控制流工具

【本章导览】 这一章把"重复"和"选择"讲完,顺便认识 Python 的两个特色语法:

  1. for 循环:和 while 有什么区别?range()、enumerate() 怎么用。
  2. break / continue / 循环的 else。
  3. pass:什么都不做的占位语句,为什么它很重要。
  4. match(3.10+):不止是 switch,而是"按数据的形状拆开它"。
  5. 5.0 节先补一个类与接口的速览——因为本章示例会用到 class,而类在第 12 章才正式讲。

难度:★★★☆☆ | 预计用时:50 分钟 | 前置知识:第 4 章

5.0 先修速览:类、对象和接口(看懂后面示例就够了)

为什么插这一节:本章 5.4 会用到 class,第 11 章的自定义异常也会用到。 这里只讲"够看懂示例"的最小知识,系统讲解在第 12 章。

① 类 = 图纸,对象 = 按图纸造出来的东西

PYTHON
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)

② 继承:在别人的图纸上改

PYTHON
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 里"接口"是一种约定,常见三种写法,从宽松到严格:

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): ...
PYTHON
# 子类按约定去实现,调用方只管调 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。

④ 记住三句话就够了

  1. class 类名: 定义图纸,类名() 造对象;
  2. self 指"当前这个对象",方法第一个参数必须是它;
  3. "接口"就是一份方法清单的约定,谁实现谁就能被当成它来用。

5.1 for 循环

什么是 for:for 是遍历循环——把一组数据里的元素一个一个取出来处理。 和 while 的区别:while 关心"条件还成立吗",for 关心"还有没有下一个"。

PYTHON
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() 都可以。

PYTHON
for ch in "Python":        # 字符串:逐个字符
    print(ch)
for k in {"a": 1}:         # 字典:默认遍历"键"
    print(k)
# 输出:
#   P
#   y
#   t
#   h
#   o
#   n
#   a
PYTHON
words = ["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() 也顺带说个反直觉的事实:它不会真的造出一串数字。

PYTHON
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
#   8000056

range 只记住起点、终点、步长,你要第几个它临时算一个。所以 for i in range(10**9): 不会撑爆内存(当然它也跑不完)。真正把一百万个数字一次性造出来的是 list(range(...)) 和列表推导式——这就是 12.9 要讲生成器的原因。

还有个从别的语言过来容易懵的点:循环变量在循环结束后还在。

PYTHON
for w in ["a", "b"]:
    pass
print(w)        # b
# 输出:
#   b

因为 Python 没有「块级作用域」,只有函数作用域和模块作用域(6.8 的 LEGB)。for、if、with 都不会开辟新的作用域,里面起的名字外面照样看得见,所以别在循环里随手用了外面已经有的变量名。

为什么遍历时不能改这个列表? 光记结论容易忘,看一遍过程就明白了:

PYTHON
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']
TEXT
这一轮拿到: 0 cat
这一轮拿到: 1 bird
这一轮拿到: 2 bee
最后: ['dog', 'bird']

dog 从头到尾没被检查过。原因是 for 背后那个迭代器只记「下一个该给第几个」,删掉 cat 之后,dog 往前挪到了第 0 位,迭代器却已经走到第 1 位了——于是直接跨过它。索引在动、列表也在动,两边对不上。

zip() 和 enumerate() 之所以好用,也是同一个思路:让 Python 去管「配对」和「数数」,你只管处理拿到的值。它们返回的是迭代器(要一个给一个),所以数据很长时也不会先把结果全存下来。

遍历时不要直接改原列表(会漏元素),遍历副本或推导式生成新列表:

PYTHON
for w in words[:]:          # 遍历切片副本
    if len(w) == 3:
        words.remove(w)
# (说明:这一段要连着上一段代码一起跑才有输出)

5.2 range()

PYTHON
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
#   4

5.3 break / continue / 循环的 else

PYTHON
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 * 3
PYTHON
for 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 靠缩进界定代码块。下面这样写会直接报错:

PYTHON
def todo():
# ❌ IndentationError: expected an indented block(期望一个缩进的代码块)
# (说明:这一段需要外部环境(文件 / 网络 / 第三方服务)才能跑出结果)

因为函数体是空的,Python 不知道这个函数到哪儿结束。pass 就是一句"这里暂时什么都不做,但语法要合法"的占位语句——它执行时真的什么都不发生,唯一的作用是让代码能跑起来。

用法 1:先搭骨架,后填实现(最常用,强烈推荐这个习惯)

PYTHON
def load_data():
    pass          # 明天再写

def train_model():
    pass          # 后天再写

def save_result():
    pass

# 现在整个程序可以先跑通流程、先测试调用顺序
# 再逐个把 pass 换成真正的实现

就像盖房子先砌出房间格局,之后再装修。写项目时强烈建议这样"先骨架后实现",避免一开始就被细节卡住。

用法 2:明确表示"这个分支我故意什么都不做"

PYTHON
for name in ["a.txt", ".hidden", "b.txt"]:
    if name.startswith("."):
        pass                    # 跳过隐藏文件,这里确实不需要做什么
    else:
        print("处理", name)
# 输出:
#   处理 a.txt
#   处理 b.txt
PYTHON
import os
try:
    os.remove("temp.txt")
except FileNotFoundError:
    pass        # 文件本来就不存在,正好是我们想要的结果,忽略即可

【坑 · 很重要】 千万不要用 except: pass 把错误默默"吞掉"——一旦出问题你将完全查不到原因,这是最难调试的 bug 来源。至少记录一行日志:

PYTHON
except ValueError:
    logging.warning("解析失败,已跳过")   # 比裸 pass 好一万倍
# (说明:这一段需要外部环境(文件 / 网络 / 第三方服务)才能跑出结果)

用法 3:定义"接口"——只规定名字,实现交给子类

如果你还没看过 5.0 节的类与接口速览,建议先回去看一眼再往下读。 接口的三种写法(pass / NotImplementedError / abc 抽象基类)详见 12.6。

PYTHON
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:当一个"空容器"来装配置项

PYTHON
class Config:
    pass          # 什么都不定义,就是想要一个能挂属性的东西

config = Config()
config.debug = True
config.model = "doubao-pro"
print(config.model)      # doubao-pro
# 输出:
#   doubao-pro

pass 的四个"亲戚",别搞混

写法含义能用在
pass什么都不做,继续往下执行任何需要占位的地方
continue跳过本轮,进入下一轮循环只能用在循环里
break直接结束整个循环只能用在循环里
return结束函数并返回(或返回 None)只能用在函数里

另外:函数体里只写一个字符串(文档字符串)也能通过语法检查,效果类似 pass。但语义上它是"说明文档",不是占位,别混用。

5.5 match:不只是 switch,是"按数据的形状拆开它"

match 是 Python 3.10 才加入的新语法。如果只是判断一个值等于几,用 if/elif 更合适;match 真正的本事是:判断"这个数据长什么样",并顺手把里面的内容取出来。

① 最基础:等值匹配(就是 switch)

PYTHON
status = 404
match status:
    case 200:
        print("成功")
    case 404:
        print("找不到页面")
    case 500:
        print("服务器出错")
    case _:                  # _ 是通配符,表示"其他所有情况"
        print("未知状态")
# 输出:
#   找不到页面

② 用 | 表示"或",把同类情况合并

PYTHON
match status:
    case 200 | 201 | 204:
        print("成功")
    case 400 | 401 | 403:
        print("客户端的问题")
    case 500 | 502 | 503:
        print("服务器的问题")
    case _:
        print("未知")
# 输出(需与上一段代码连着跑):
#   未知

③ 匹配"结构"并拆出变量(这是它最有用的地方)

PYTHON
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]。

④ 匹配列表,支持"剩余项"

PYTHON
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

⑤ 匹配字典,直接按键取值

PYTHON
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 守卫(更精细的条件)

PYTHON
match point:
    case (x, y) if x == y:
        print("这个点在对角线上")
    case (x, y):
        print(f"坐标是 ({x}, {y})")
# 输出(需与上一段代码连着跑):
#   坐标是 (3, 5)

真实场景:处理 Agent / 大模型返回的不同"动作"

PYTHON
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 守卫、_ 通配符
第 06 章

第 6 章 函数

【本章导览】 函数是"把代码打包复用"的第一步,也是后面写类、写装饰器的地基。这一章按顺序回答:

  1. 函数是什么、为什么要写函数(6.1)
  2. 怎么定义:def 语句逐行拆解、命名规则、函数体、文档字符串(6.2)
  3. 怎么调用:执行流程、形参 vs 实参、返回值怎么用(6.3)
  4. 参数是怎么传进去的:为什么列表会被函数改掉、数字不会(6.4)
  5. 返回值:None、多个返回值、提前 return(6.5)
  6. 参数的各种写法、解包传参、作用域、递归、闭包、lambda、注解、装饰器(6.6~6.14)

难度:★★★★☆(本章是全笔记最重要的一章) | 预计用时:90 分钟 | 前置知识:第 4~5 章

6.1 函数是什么?为什么要写函数?

定义:函数是一段有名字的、可以重复调用的代码块,用来完成一件确定的事。

你已经用过很多别人写好的函数了——print()、len()、input()、sum() 都是函数。写函数就是自己做一把工具给别人(和以后的自己)用。

四个必须写函数的理由

理由说明
复用(DRY 原则)同样的代码只写一遍,用 100 次;要改也只改一处
拆分复杂度一个大问题拆成若干小函数,每个函数只做一件事
便于测试和维护函数有明确的输入/输出,可以单独调试
自解释calc_tax(price) 这个名字本身就是注释,比 10 行代码好读

用"榨汁机"理解函数的三要素

TEXT
        参数(输入)                    返回值(输出)
苹果 ──▶ [  函数名(榨汁机)  ] ──▶ 苹果汁
         内部怎么处理,调用者不用管(黑盒)
PYTHON
def make_juice(fruit):        # fruit 是参数(输入)
    return f"{fruit}汁"       # 返回值(输出)

print(make_juice("苹果"))      # 苹果汁
print(make_juice("橙子"))      # 橙子汁
# 输出:
#   苹果汁
#   橙子汁

一句话记住:函数 = 名字 + 输入(参数)+ 加工过程(函数体)+ 输出(返回值)。 调用者只关心"传什么进去、拿什么出来",不关心里面怎么做的(这叫"封装")。

6.2 怎么定义函数:def 语句逐行拆解

语法模板

PYTHON
def 函数名(参数1, 参数2, ...):      # ① def  ② 函数名  ③ 括号参数  ④ 冒号
    """文档字符串(可选,强烈建议写)"""
    函数体代码                      # ⑤ 必须缩进(4 个空格)
    ...
    return 返回值                   # ⑥ 可选
# (说明:这一段需要外部环境(文件 / 网络 / 第三方服务)才能跑出结果)

逐项说明:

组成部分作用注意
① def 关键字define 的缩写,告诉 Python"下面要定义函数了"必须小写
② 函数名后面靠它调用小写 + 下划线,建议动词开头:get_age / calc_sum / is_valid
③ 参数列表函数要处理的输入,写在括号里可以没有参数:def hello():
④ 冒号 :表示"下面缩进的是函数体"忘了冒号是最常见的新手错误
⑤ 函数体真正干活的代码必须整体缩进,缩进结束 = 函数结束
⑥ return把结果交还给调用者可以省略(见 6.5)
PYTHON
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() 才是"执行它"。

调用时的执行流程(理解这个,调试时心里有数):

TEXT
① 程序执行到 greet("小明")
② 跳进 greet 函数,把实参 "小明" 绑给形参 name
③ 从上到下执行函数体
④ 遇到 return(或函数体走完)→ 带着结果跳回调用处
⑤ 继续往下执行
PYTHON
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 实参(面试爱问,其实很简单)

PYTHON
def greet(name):   # name 是"形参"(parameter):定义时占位的名字
    ...
greet("小明")       # "小明" 是"实参"(argument):调用时真正传进去的值

函数里可以调用别的函数(甚至可以调自己,见 6.9 递归)

PYTHON
def area(w, h):
    return w * h

def describe(w, h):
    return f"面积是 {area(w, h)}"      # 直接调用上面那个函数

print(describe(3, 4))                 # 面积是 12
# 输出:
#   面积是 12

6.4 参数是怎么传进去的(重点,也很容易踩坑)

一句话结论:Python 传的是"对象的引用"(可以理解为把标签复制了一份给你)。 所以——在函数里"改对象的内容"会影响外面;"重新赋值"不会影响外面。

情况 A:传入不可变对象(数字、字符串、元组)→ 外面不受影响

PYTHON
def add_ten(n):
    n = n + 10          # 这是"重新赋值":让 n 指向一个新数字
    print("函数内:", n)

x = 5
add_ten(x)              # 函数内:15
print("函数外:", x)     # 5   ← x 没变
# 输出:
#   函数内: 15
#   函数外: 5

情况 B:传入可变对象(列表、字典、集合)→ 改内容会影响外面!

PYTHON
def add_item(lst):
    lst.append("新元素")    # 这是"修改对象内容",改的是同一个列表

my_list = ["a"]
add_item(my_list)
print(my_list)              # ['a', '新元素']   ← 外面的列表真的被改了!
# 输出:
#   ['a', '新元素']

不想被改怎么办?传一份副本进去

PYTHON
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 越少越好调试。

《从入门到实践》里给了个很实用的中间方案:调用时传一份副本。比如「把待打印的模型清单交给打印函数,打印完原清单还要留着」:

PYTHON
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']
TEXT
打印: phone
打印: case
打印: charger
原清单还在: ['phone', 'case', 'charger']

一个 [:] 就把「这份数据后面还有用」写在了脸上。代价是复制了一份,但列表不大时几乎感觉不到。反过来,如果函数本来就该改这份数据(比如往购物车里加东西),那就大大方方地改,并在函数名和文档里说清楚。真正难维护的是「看不出会不会改」的那种函数。

6.5 返回值:return 的各种情况

PYTHON
# ① 不写 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 参数的各种写法(重点)

PYTHON
# ① 默认值参数
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
#   (说明:耗时与机器性能有关,数值会不同)

【坑】默认参数不要用可变对象:

PYTHON
def 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

特殊参数(读框架源码会遇到)

PYTHON
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:写"转发型"函数——我不知道别人会传什么,原样交给下一个函数

PYTHON
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:做通用工具,参数个数随意

PYTHON
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 解包传参

PYTHON
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
#   6

6.8 变量的作用域:函数里能看见哪些变量

定义:作用域(scope)就是"一个变量名能被看见、能被使用的范围"。

Python 查找一个名字时,按 LEGB 顺序依次找,找到就停:

缩写范围例子
L Local函数内部函数里定义的变量、参数
E Enclosing外层嵌套函数闭包里外层函数的变量(见 6.10)
G Global模块(文件)顶层文件开头定义的变量
B Built-inPython 内置print、len、sum
PYTHON
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 声明

PYTHON
count = 0

def increase():
    global count       # 声明:我要改的是外面那个 count,不是新建局部的
    count += 1

increase()
print(count)           # 1
# 输出:
#   1

只读不写不需要 global:函数里 print(x) 读全局变量没问题;一旦写了 x = ...,Python 就认为你在定义局部变量,此时先读后写会报 UnboundLocalError。

嵌套函数里改外层变量 → 用 nonlocal

PYTHON
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 递归:函数自己调用自己

定义:递归就是函数在内部调用自己,把一个大问题拆成"更小的同类问题"。

写递归只要抓住两个要素:

  1. 基线条件(什么时候停):问题小到可以直接给出答案,不再递归——忘了它就是无限递归。
  2. 递归条件(怎么变小):把原问题变成规模更小的同类问题。
PYTHON
# 阶乘: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
PYTHON
# 斐波那契数列(递归写法很直观,但效率低,实战用循环或缓存)
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 函数是"一等对象":可以当变量传来传去

什么叫一等对象:函数和其他数据(数字、字符串)一样,可以——

PYTHON
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):一个内层函数,记住了外层函数的变量,即使外层函数已经执行完。

PYTHON
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)和很多框架回调写法的底层原理。

闭包的一个经典坑:循环里创建闭包

PYTHON
# ❌ 想要 [×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 匿名函数

PYTHON
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 最常见的三个搭档

PYTHON
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 文档字符串与注解

PYTHON
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'>}
#   (说明:集合是无序的,每次打印的顺序都可能不同)

注解到底有没有用? 先说清最容易误解的一点:它不会做类型检查,写错了照样跑。

PYTHON
def greet(name: str, times: int = 1) -> str:
    return "\n".join([f"你好,{name}"] * times)

print(greet("小明", 2))     # 你好,小明(两行)
print(greet(123))           # 你好,123   ← 传了 int 也不报错
# 输出:
#   你好,小明
#   你好,小明
#   你好,123

name: str 只是贴在名字上的一张便签,给人和工具看的。Python 自己不读它,编辑器靠它补全、提示类型不对,mypy / pyright 这类工具靠它做静态检查。那为什么现代 Python 代码里几乎人人都在写?因为框架会读它:

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 装饰器(官方教程未涵盖,但你必须会)

为什么要有装饰器:想给一个函数加上"计时 / 记日志 / 鉴权"这类通用功能,但不想改动函数内部的代码。装饰器就是干这个的。

先看效果

PYTHON
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 到底做了什么

PYTHON
@timer
def slow(): ...

# 上面这两行,完全等价于:
def slow(): ...
slow = timer(slow)        # 把原函数交给 timer,拿回一个新函数,再挂回同名变量
# (说明:这一段要连着上一段代码一起跑才有输出)

所以装饰器本质上就是一个"接收函数、返回函数"的函数。@ 只是让这行代码更好看的语法糖。

带参数的装饰器(进阶,认识写法即可)

PYTHON
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),用来"不改原函数"地加功能
第 07 章

第 7 章 数据结构(核心章)

【本章导览】 列表只是开始,Python 还有三种常用容器,用对了能少写一半代码:

  1. 四种容器横向对比:什么时候用 list / tuple / dict / set。
  2. 元组:不可变、能当字典键、单元素必须加逗号。
  3. 集合:自动去重、in 判断极快、交并差运算。
  4. 字典:键值对、增删改查、get()、遍历方式、推导式。
  5. 循环技巧:enumerate / zip / items() / sorted / reversed。
  6. 条件与比较:链式比较、in、is、del 的三种删除方式对比。

难度:★★★☆☆ | 预计用时:60 分钟 | 前置知识:第 3 章(列表)

7.1 四种容器全景对比

容器写法有序可变元素可重复能当字典键
list 列表[1, 2]有能是不能
tuple 元组(1, 2)有不能是能
dict 字典{"a": 1}有(插入序)能键不可重复不能
set 集合{1, 2}无能(增删)自动去重不能

7.2 元组 tuple

PYTHON
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 3

tuple 的"不可变"是浅层的:里面装了 list 时,list 内部仍可改。

PYTHON
t = ([1, 2], "a")
t[0].append(3)     # 可以!→ ([1, 2, 3], 'a')

7.3 集合 set

【先看这一句】集合是无序的,下面示例注释里写出的元素顺序只是某一次运行的结果;你自己跑出来顺序不一样是正常的。判断两个集合是否相等请用 == 或集合运算,不要去比对打印出来的顺序。

PYTHON
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

PYTHON
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

遍历字典的四种姿势。默认给你的是键,想要值、想要键值对都得明说:

PYTHON
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() 返回的不是列表,是视图。这词听着玄,其实就一扇窗:

PYTHON
v = user.values()
user["age"] = 19
print(list(v))               # ['小明', 19, '杭州']   ← 窗外的字典变了,看到的内容跟着变
# 输出(需与上一段代码连着跑):
#   ['小明', 19, '杭州']

为什么这么设计?因为没必要为了遍历一次就把所有值复制一份,字典有几万条时省得很明显。想真的存一份下来,用 list(...) 包一下就行。

值的去重也是常见需求,set() 一行搞定:

PYTHON
favorites = {"小明": "Python", "小红": "Go", "小李": "Python"}
print(set(favorites.values()))                  # {'Go', 'Python'}(顺序不保证)
for lang in sorted(set(favorites.values())):    # 去重后再排序
    print("有人喜欢", lang)
# 输出:
#   {'Python', 'Go'}
#   有人喜欢 Go
#   有人喜欢 Python
#   (说明:集合是无序的,每次打印的顺序都可能不同)

为什么字典查得快、又为什么列表不能当键? 打个比方:列表找东西像从第一个抽屉翻起,字典则给每个键算一个「柜子编号」,直接去那个柜子拿,跟柜子里有多少东西基本无关。代价是键必须能算出稳定不变的编号(这叫「可哈希」):

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} 这种玩具,可实际从接口、数据库、配置文件里拿来的数据几乎都长这样:

PYTHON
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
TEXT
小明(18 岁)会 Python, SQL
小红(20 岁)会 FastAPI, Git

能看懂这个结构,读 API 文档就不慌了。常见的套法就三种:

PYTHON
# ① 列表里放字典:一堆记录,相当于表格的行(上面的 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 索引」时给字典,两种都很常见。

改嵌套数据的方式是「一层一层点进去」:

PYTHON
for u in users:
    u["skills"].append("Docker")
print(users[0]["skills"])      # ['Python', 'SQL', 'Docker']
# 输出(需与上一段代码连着跑):
#   ['Python', 'SQL', 'Docker']

留个心眼:这改的是里面那个列表对象。3.6 说过浅拷贝只复制外层,所以复制这种嵌套数据时要用 copy.deepcopy()。

7.5 循环技巧(必会)

PYTHON
# 字典: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() 就省了:

PYTHON
pairs = [("小明", "A"), ("小红", "B"), ("小李", "A")]
groups = {}
for name, team in pairs:
    groups.setdefault(team, []).append(name)
print(groups)          # {'A': ['小明', '小李'], 'B': ['小红']}
# 输出:
#   {'A': ['小明', '小李'], 'B': ['小红']}
#   (说明:集合是无序的,每次打印的顺序都可能不同)

setdefault(team, []) 的意思是「有就取出来,没有就先放个空列表再取出来」,所以拿到的一定是个能 append 的列表。标准库里还有个更省事的:

PYTHON
from collections import defaultdict

groups = defaultdict(list)
for name, team in pairs:
    groups[team].append(name)      # 键不存在?自动帮你造个空列表
print(dict(groups))               # {'A': ['小明', '小李'], 'B': ['小红']}
# 输出(需与上一段代码连着跑):
#   {'A': ['小明', '小李'], 'B': ['小红']}

这里正好能看清 get() 的边界:它只管「取」,不管「存」。

PYTHON
d = {}
d.get("tags", []).append("a")     # 默认值是临时造出来的,没人把它放回字典
print(d)                          # {}   ← 白加了
# 输出:
#   {}

想「取不到就创建」,用 setdefault() 或 defaultdict,别指望 get()。

第二件是计数。手动统计词频时,一般要写 counter[w] = counter.get(w, 0) + 1,标准库给了一行版:

PYTHON
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
#   (说明:集合是无序的,每次打印的顺序都可能不同)

统计词频、统计接口返回的状态码、算购物清单数量,都是同一件事。

第三件是合并和按值排序:

PYTHON
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 就是对「每个键」取出它的分数,再按分数给键排队——想拿「人 + 分数」就再遍历一次:

PYTHON
for name in sorted(scores, key=scores.get, reverse=True):
    print(name, scores[name])
# 输出(需与上一段代码连着跑):
#   小红 95
#   小明 88
#   小李 72
TEXT
小红 95
小明 88
小李 72

7.6 条件控制与比较

if / while 的完整语法见 第 4 章,这一节是在容器上的应用与 Python 特色写法。

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 语句

PYTHON
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 仍能改)
setin 判断比列表快得多;- 差集、| 并集、& 交集、^ 对称差
dictd[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
第 08 章

第 8 章 常用内置函数与关键字(保留字)

【本章导览】 前面章节零散用到的 len()、range()、enumerate() 到底都是些什么?这一章一次讲清:

  1. 内置函数和关键字分别是什么,怎么区分它们和普通函数。
  2. 35 个关键字总览:每个单词什么意思、在哪一章学的。
  3. 常用内置函数按用途逐个详解(输入输出 / 类型转换 / 数学 / 序列迭代 / 判断 / 函数式 / 对象)。
  4. 高频内置函数的参数技巧与常见坑(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()
PYTHON
len("abc")        # ✅ 内置函数:直接能用
# math.sqrt(4)    # ❌ NameError:要先 import math

# if = 3          # ❌ SyntaxError:关键字不能当变量名
# len = 3         # ⚠️ 能赋值,但会把内置 len 覆盖掉,千万别这么干

遇到不会的函数怎么办?三个自带"说明书"

PYTHON
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条件分支;也用于循环的 else4.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 输入、输出与文件

PYTHON
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 类型查看与转换

PYTHON
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 数学相关

PYTHON
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 序列与迭代(最常用的一组)

PYTHON
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]   反向
PYTHON
# iter / next:for 循环的底层原理(见 12.8 迭代器)
it = iter([1, 2, 3])
print(next(it), next(it))       # 1 2
# 输出:
#   1 2

8.3.5 真假判断

PYTHON
any([False, 1, 0])        # True    只要有一个为真就是 True
all([True, 1, "a"])       # True    全部为真才是 True
any([])                   # False   空序列是 False
all([])                   # True    空序列反而是 True("没有反例")

8.3.6 函数式工具(map / filter)

PYTHON
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 对象相关

PYTHON
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 怎么快速查到你想要的函数

PYTHON
# ① 忘了叫什么:列出内置名字
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
第 09 章

第 9 章 模块与包

【本章导览】 代码变多之后,必须学会"分文件管理":

  1. import 的四种写法及各自适用场景。
  2. 自己写一个模块,并理解 import 时会发生什么。
  3. if __name__ == "__main__": 这句"咒语"到底干什么用。
  4. 模块搜索路径、dir() / help() 查文档。
  5. 包(package)与相对导入。

难度:★★☆☆☆ | 预计用时:25 分钟 | 前置知识:第 8 章

9.1 import 的各种写法

PYTHON
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 就是干这个的)。

而且同一个模块只会执行一次:

PYTHON
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:

PYTHON
"""我的工具模块"""

def double(x):
    return x * 2

PI = 3.14159

print("模块被加载了")             # 被 import 时会执行
# 输出:
#   模块被加载了

使用:

PYTHON
import mytools
print(mytools.double(5))   # 10
print(mytools.PI)          # 3.14159
# (说明:需要先装第三方库:pip install mytools)

__name__ 的惯用法(让文件既能被导入、又能直接运行):

PYTHON
def double(x):
    return x * 2

if __name__ == "__main__":
    # 只有"直接运行这个文件"时才执行
    print(double(10))
# 输出:
#   20

9.3 模块搜索路径与 dir()

PYTHON
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 的文件夹:

TEXT
mypkg/
    __init__.py
    utils.py
    models.py
PYTHON
from 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 起没有它也能当「命名空间包」,但自己写项目还是老老实实加上,编辑器、测试工具、打包工具都认这个约定,少踩坑。

相对导入有个几乎人人撞过一次的报错:

TEXT
ImportError: attempted relative import with no known parent package

原因不是路径写错,而是你直接运行了包里面的那个文件(比如 python mypkg/utils.py)。这时 Python 把它当成一个独立脚本,压根不知道它属于 mypkg,. 也就无从谈起。两种解法:在项目根目录用 python -m mypkg.utils 运行(-m 会保留包身份),或者在包外面的入口文件里 from mypkg.utils import ...。

所以一个稍微像样的项目,目录通常长这样:

TEXT
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 章

第 10 章 输入与输出

【本章导览】 程序不能只在屏幕上打几个字,它得会"说话"和"记事":

  1. 格式化输出:f-string / str.format() / 旧式 % 三种写法及其取舍。
  2. 文件读写:with open(...)、打开模式、常用方法、为什么必须写 encoding="utf-8"。
  3. JSON(AI 开发重中之重):Python 对象 ↔ JSON 字符串 ↔ JSON 文件,以及类型对应关系。

难度:★★★☆☆ | 预计用时:40 分钟 | 前置知识:第 7 章

10.1 格式化输出

PYTHON
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():

PYTHON
template = "{name} 同学,你的成绩是 {score} 分"     # 假设这行是从配置读来的
print(template.format(name="小明", score=95))
# 小明 同学,你的成绩是 95 分
# 输出:
#   小明 同学,你的成绩是 95 分

% 只需看懂,不用再写:老项目、一些 logging 配置里还能见到。另外 f-string 里 {} 是要填东西的,想输出字面量花括号得写成 {{ 和 }}:

PYTHON
print(f"{{'name': '{name}'}}")     # {'name': '小明'}
# (说明:这一段要连着上一段代码一起跑才有输出)

10.2 读写文件

PYTHON
# 写(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 的写法就明白了:

PYTHON
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。

PYTHON
from pathlib import Path
print(Path.cwd())            # 当前工作目录,看一眼就知道自己在哪儿
# 输出:
#   C:\Users\<你的用户名>\Desktop\Biu Work\_imgtest\_gen
#   (说明:路径、时间、目录内容随你自己的机器而变,你跑出来的会不一样)

想让路径跟脚本位置绑定,用 __file__:

PYTHON
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 版整章都改用它了:

PYTHON
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 22

read_text() / write_text() 内部帮你把打开和关闭都做完了,splitlines() 比 readlines() 干净:它自动去掉每行末尾的 \n,交给你的是纯字符串列表。为什么推荐 pathlib 而不是 os.path?因为路径在这里是一个对象,能做的事都挂在它身上(.exists()、.glob()、.suffix),不用记 join / basename / splitext 一堆散装函数,还天然跨平台。第 13 章的 os / glob 在老代码里依然满地都是,两套都得认识。

逐行读大文件时别用 read() 或 readlines()(会把整个文件搬进内存),直接遍历文件对象,它一行一行地给:

PYTHON
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() 不会帮你加换行符,名字听着像会自动加,其实不会。

PYTHON
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 开发的重中之重)

PYTHON
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"
#     ]
#   }
#   小明

类型对应关系

PythonJSON
dictobject
list / tuplearray
strstring
int / floatnumber
True / Falsetrue / false
Nonenull

ensure_ascii=False 让中文正常显示(否则会变成 \u5c0f\u660e)。

把 JSON 真正用起来:让数据下次启动还在。程序里的变量一关掉就没了,想「记住」只能落到文件里。JSON 是首选,因为它是纯文本、人也能读、几乎所有语言和接口都认。《从入门到实践》里那个「记住用户名」的例子,完整跑一遍是这样:

PYTHON
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 讲过的嵌套结构,取的时候一层层点进去:

PYTHON
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
# 输出(需与上一段代码连着跑):
#   Python

indent=2 只是让人看着舒服,接口传输时别加,白白多送一堆空格和换行。

JSON 只认上面那张表里的几种基本类型。日期、自定义对象直接塞进去会报错:

PYTHON
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,别让程序因为一个手滑改坏的配置文件直接崩掉:

PYTHON
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 章

第 11 章 错误和异常

【本章导览】 程序出错不可怕,可怕的是出错后直接崩掉:

  1. 语法错误和异常有什么本质区别?常见的异常类型有哪些?
  2. try / except / else / finally 四个子句各自什么时候执行(尤其是 else 为什么有用)。
  3. 用 raise 主动抛异常,用自定义异常表达业务错误。
  4. with 为什么能自动清理资源。
  5. 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」会直接报错,所以故意不写输出)

先学会看懂报错。新手最容易被一长串红字吓住,其实有用的只有两处:最后一行告诉你出了什么错,倒着往上找告诉你是在自己代码的哪一行炸的。

PYTHON
def divide(a, b):
    return a / b

def run():
    return divide(10, 0)

run()
# (说明:这一段是在演示「除以 0」会直接报错,所以故意不写输出)
TEXT
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

PYTHON
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 更习惯「先做,出错再说」。检查一个字典键存在不存在,两种写法:

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 要解决的问题。

重新抛出时,把原因带上:

PYTHON
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(程序想退出)都一起抓了,出问题时连中断都停不下来。至少要写清类型:

PYTHON
except Exception as e:
    logging.warning("处理失败:%s", e)   # 至少留下一条线索
# (说明:这一段需要外部环境(文件 / 网络 / 第三方服务)才能跑出结果)

至于 except: pass,5.4 已经说过:那是最难查的一类 bug,错误被无声吞掉,等发现时数据早就不对了。

11.3 主动抛出异常

PYTHON
def check_age(age):
    if age < 0:
        raise ValueError("年龄不能是负数")
    return age

# check_age(-1)   → ValueError: 年龄不能是负数

11.4 自定义异常

这里用到了"类"和"继承":语法看 5.0,继承详解看 12.4。

PYTHON
class MyError(Exception):          # 继承 Python 自带的 Exception
    """自定义异常:继承 Exception 即可"""
    pass                            # 不需要额外代码,pass 占位(见 5.4)

try:
    raise MyError("出事了")
except MyError as e:
    print("捕获到:", e)
# 输出:
#   捕获到: 出事了

11.5 with 做清理

PYTHON
# with 会自动调用清理逻辑(关闭文件、释放锁)
with open("a.txt") as f:
    data = f.read()
# 出了 with 块,文件自动关闭,即使里面出异常
# (说明:需要先准备好这个文件:a.txt)

11.6 assert 断言:给自己看的"保险丝"

定义:assert 条件, "提示信息" 的意思是——"我敢打赌这个条件一定成立",不成立就立刻抛 AssertionError 并带上提示。

PYTHON
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(见下方警告)
PYTHON
# ✅ 正确:外部输入用 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 章

第 12 章 类、对象与接口

【本章导览】 从"写函数"升级到"写类",是组织大型程序的关键一步(5.0 节已经先修过一遍,这里是完整版):

  1. 名字与对象:为什么 Python 的变量像"标签"而不是"盒子"(12.1)。
  2. 定义类:类变量 / 实例变量、__init__、self、方法(12.3)。
  3. 继承:复用父类、super()、方法重写(12.4)。
  4. 封装:私有约定、property 属性(12.5)。
  5. 接口:Python 里怎么表达"接口"——pass / NotImplementedError / 抽象基类 abc(12.6)。
  6. 进阶:类方法、静态方法、dataclass、常用魔术方法(12.7)。
  7. 迭代器与生成器(12.8 / 12.9)。

难度:★★★★☆ | 预计用时:80 分钟 | 前置知识:第 6 章(函数)、5.0 节

12.1 先理解"名字"和"对象"

PYTHON
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)

PYTHON
x = 10          # 全局

def f():
    y = 5       # 局部,出了函数就没了
    print(x)    # 能读外面的

f()
# print(y)     # NameError:外面看不到函数里的 y

def g():
    global count      # 想在函数里改全局变量,要声明 global
    count = 1
# 输出:
#   10

12.3 定义类

语法

PYTHON
class 类名:
    类变量 = 值              # 所有实例共享

    def __init__(self, 参数):   # 构造器:造对象时自动调用
        self.实例变量 = 参数     # 每个对象自己一份

    def 方法名(self, 参数):     # 方法:第一个参数必须是 self
        ...
# (说明:这一段要连着上一段代码一起跑才有输出)
PYTHON
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(只影响这一个)
PYTHON
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:

PYTHON
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 公里

改一个对象身上的属性,其实有三种方式,区别挺重要:

PYTHON
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 继承

PYTHON
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()

PYTHON
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 章的规矩分文件放了。导入类和导入函数是同一套写法:

PYTHON
# 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,靠"约定"和"改名"来表达"这是内部的,别碰":

PYTHON
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:把方法伪装成属性(既好读又能校验)

PYTHON
class Student:
    def __init__(self, score):
        self.score = score

s = Student(50)
s.score = -10        # ❌ 没人拦得住,成绩变成 -10 了
PYTHON
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 关键字,实际开发中有三种写法,按严格程度从低到高:

PYTHON
# ① 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 的精髓)

PYTHON
def process(loader):
    data = loader.load()      # 不检查 loader 是什么类,只要有 load() 就能用
    return len(data)

process(CsvLoader())          # ✅
process(JsonLoader())         # ✅
# (说明:这一段要连着上一段代码一起跑才有输出)

"如果它走起来像鸭子、叫起来像鸭子,那它就是鸭子。" 不看你继承谁,只看你有没有这个方法。所以很多时候 Python 甚至不需要写接口类——写文档说明清楚就行。

12.7 类方法、静态方法与 dataclass

三种方法对比

类型定义第一个参数能访问典型用途
实例方法def f(self)self(对象)实例 + 类绝大多数方法
类方法@classmethodcls(类)只能访问类变量工厂方法、操作类变量
静态方法@staticmethod无都不能(就是普通函数)和类相关但不依赖状态的辅助函数
PYTHON
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
#   False

dataclass:自动生成样板代码(强烈推荐)

写"主要用来装数据"的类时,用 dataclass 自动生成 __init__、__repr__、__eq__:

PYTHON
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
PYTHON
# 不用 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)
PYTHON
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 迭代器

PYTHON
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 停止。

自己写一个迭代器

PYTHON
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
#   1

12.9 生成器(yield)

PYTHON
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

生成器的好处:不一次性占用内存,要一个产一个。处理大文件、流式数据时必备。

生成器表达式(像列表推导式,但用小括号)

PYTHON
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() / 下标能不能
速度数据量小时更快数据量大时更优(不用等全部算完)
PYTHON
# 数据量小、后面还要用 → 用列表
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 章

第 13 章 标准库实用速查

【本章导览】 "不要重复造轮子"——这些模块 Python 自带,import 就能用:

  1. os / os.path:文件和目录操作(13.1)
  2. sys:解释器与命令行参数(13.2)
  3. glob:通配符找文件(13.3)
  4. re:正则表达式(13.4)
  5. math / random:数学与随机(13.5)
  6. datetime:日期时间(13.6)
  7. logging:日志(上线必备,13.7)
  8. collections.deque:高效队列(13.8)
  9. time / pprint 等一行速记(13.9)
  10. doctest / unittest:最简单的测试(13.10)

难度:★★☆☆☆(工具章,用时再查) | 预计用时:30 分钟 | 前置知识:第 9 章

13.1 os —— 操作系统接口

PYTHON
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 —— 解释器相关

PYTHON
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 —— 文件通配符

PYTHON
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字母数字下划线
+一个或多个
*零个或多个
?零个或一个
^ $开头 / 结尾
PYTHON
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
#   aNbNcN

13.5 math / random

PYTHON
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 —— 日期时间

PYTHON
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 —— 日志(上线必备)

PYTHON
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 —— 高效队列

PYTHON
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(",")。字段里只要出现逗号、引号或换行,手写就出错:

PYTHON
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
#   小红 20

newline="" 是 Windows 上写 CSV 的固定搭配,少了它每行之间会多出空行。读出来每一行是字典,跟 7.4 的嵌套数据无缝接上。

itertools:循环里的瑞士军刀,全是「要一个给一个」的惰性工具:

PYTHON
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) 被反复算了几万次,一行装饰器就能救回来:

PYTHON
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 手抠参数,参数一多就该交给它:

PYTHON
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)
# (说明:这一段是在演示「测试失败」,故意让它报错)
POWERSHELL
python .\tool.py 小明 --times 3
python .\tool.py --help
TEXT
小明小明小明

类型校验、默认值、--help 说明全自动生成。写命令行小工具时,这是从「能跑」到「别人也会用」的一步。

13.9 其他一行速记

PYTHON
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 极简)

PYTHON
def double(x):
    """把数字翻倍。

    >>> double(3)
    6
    """
    return x * 2

if __name__ == "__main__":
    import doctest
    doctest.testmod()      # 运行文档里的示例当测试
PYTHON
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 章

第 14 章 虚拟环境与包

【本章导览】 项目一多,依赖就会打架。虚拟环境是"每个项目一间独立房间":

  1. 虚拟环境是什么、为什么要建它。
  2. 创建 / 激活 / 退出 / 安装包的完整命令(Windows 与 macOS/Linux 都给)。
  3. requirements.txt 的作用与生成、安装方式。
  4. 装不动时的国内镜像源。

难度:★☆☆☆☆(操作为主) | 预计用时:20 分钟

BASH
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 这个命令可能指向另一个解释器,包就装到别人家去了:

POWERSHELL
python -m pip install requests
python -m pip --version      # 看清楚它到底属于哪个 Python

python -m 的意思是「用当前这个 python 去运行 pip 模块」,装到哪儿不会搞错。激活虚拟环境之后直接 pip install 也没问题,但排查「明明装了却 import 不到」时,上面的写法能一眼定位。

Windows / PowerShell 激活失败是很常见的一道题:

POWERSHELL
.venv\Scripts\activate
# 若报「无法加载文件 ... 因为在此系统上禁止运行脚本」
Set-ExecutionPolicy -Scope CurrentUser RemoteSigned

原因是 PowerShell 默认不允许执行本地脚本,跟 Python 本身没关系。改「当前用户」这一级就够,不用动整台机器的策略。实在不想改,也可以不激活,直接用 .venv\Scripts\python.exe .\main.py 跑,效果一样。

requirements.txt 可以自己手写,不必全靠 pip freeze(它会把间接依赖也一股脑倒出来,小项目看着很乱):

TEXT
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 章

第 15 章 给代码写测试(pytest)

【本章导览】 《从入门到实践》第 3 版专门用一章讲测试,用的是 pytest(第 2 版用的是标准库 unittest)。这一章不追求写全,只把「改完代码怎么敢确定没改坏」这件事跑通:装 pytest、写第一个测试、一次测多组数据、用夹具准备现场、测异常,最后借测试做一次重构。

难度:★★☆☆☆ | 预计用时:40 分钟 | 前置知识:第 6 章(函数)、第 11 章(异常)、第 14 章(装包)

15.1 为什么非要写测试

写过几段代码就会遇到这个场景:给函数加了一个功能,手动试了一下「好像没问题」,结果第二天发现老功能悄悄坏了。手动试只能覆盖你当场想到的那一两个输入,而且没人愿意每次改完都把整个流程点一遍。

测试就是把「我预期它这样」写进代码里,改完之后一键全部重跑。它还有个隐藏好处:为了能测,你会自然地把代码拆成输入输出明确的小函数(6.1 说的「便于测试」就是这个意思)。后面写接口、写 Agent 的工具函数时,一处改动可能影响整条链路,测试就是那份底气。

先在虚拟环境里装(第 14 章):

POWERSHELL
python -m pip install pytest
pytest --version

15.2 第一个测试:三行代码

准备一个待测试的函数,放在 name_utils.py:

PYTHON
def get_full_name(first, last):
    """把姓和名拼成完整的名字。"""
    return f"{first} {last}".title()

再建一个 test_name_utils.py,两个文件放同一个目录:

PYTHON
from name_utils import get_full_name

def test_full_name():
    assert get_full_name("li", "ming") == "Li Ming"
# (说明:需要先装第三方库:pip install name_utils)

在这个目录下运行:

POWERSHELL
pytest -q
TEXT
.                                                                    [100%]
1 passed in 0.02s

三个约定记住就行:文件名以 test_ 开头、函数名以 test_ 开头、验证用 assert。pytest 会自动把它们找出来跑,不用注册、不用写 main()。

为什么这里能用 assert?11.6 说过断言不能用来校验用户输入,因为 python -O 会把它跳过;但测试文件是用 pytest 跑的,不走 -O,而且测试本来就该「条件不成立就立刻失败」。这正是断言的主场。pytest 还会把失败的两边展开给你看,比自己 print 排查快得多。

把函数故意改错(.title() 换成 .capitalize()),再看一次报错:

TEXT
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 一次测好几组输入

一个用例只验证了「英文小写姓名」。想覆盖更多情况,不用复制粘贴三份测试函数,用参数化:

PYTHON
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)
TEXT
3 passed in 0.02s

pytest 会把列表里每一行塞进函数跑一遍,任何一个不过都会单独列出来,告诉你是哪组数据出的问题。找边界情况的输入(空字符串、0、负数、超长文本)比多写几个差不多的用例有用得多。

15.4 用夹具准备「现场」

测试类的时候,每个测试都想要一个干干净净的新对象,否则上一个测试加进去的数据会污染下一个(回想 6.4 的「可变对象会被改」)。先看被测试的类,放在 survey.py:

PYTHON
class Survey:
    def __init__(self, question):
        self.question = question
        self.responses = []

    def add(self, answer):
        self.responses.append(answer)

测试文件:

PYTHON
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 接住:

PYTHON
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 借着测试做一次重构

现在要支持中间名。改之前先把新预期写出来:

PYTHON
def test_with_middle():
    assert get_full_name("li", "ming", "xiao") == "Li Xiao Ming"

这时跑 pytest 会失败(函数还不收第三个参数),这正是「先写预期再改代码」的节奏。然后改实现:

PYTHON
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 讲过为什么不用 + 一路加)。再跑一遍:

TEXT
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 章

第 16 章 把知识点串起来:写一个能用的小程序

【本章导览】 前面 15 章都是「一个知识点配几行例子」。这一章换个写法:从零做一个命令行待办清单,边写边把变量、判断、循环、函数、字典、文件、JSON、异常、测试全用上。《从入门到实践》里的三个项目也是这个思路——先做能跑的最小版本,再一点点加东西。

难度:★★★☆☆ | 预计用时:60 分钟 | 前置知识:第 3、4、6、7、10、11 章

16.1 先想清楚数据长什么样

动手写界面之前,先定数据。一条待办有两件事要记:内容、做完没做完。所以一条就是一个字典,一堆待办就是一个列表:

PYTHON
todos = [
    {"title": "看完第 6 章", "done": False},
    {"title": "写一个小工具", "done": True},
]

为什么不用纯字符串列表 ["看完第 6 章", ...]?因为「完成状态」没地方放。这个结构正好也是 7.4 讲的嵌套数据、10.3 讲的 JSON 结构——从内存到文件不用改形状,这一步选对了,后面全顺。

16.2 先把「显示」写出来

一个函数只干一件事:把清单打印给人看。

PYTHON
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] 写一个小工具
TEXT
1. [ ] 看完第 6 章
2. [x] 写一个小工具

enumerate(..., start=1) 让人看到的序号从 1 开始,交互时才自然(8.4)。mark 用了三元表达式(4.2),因为就是简单的二选一。

16.3 搭主循环:能跑就行

命令行程序基本都是「打印菜单 → 等输入 → 按选择做事 → 再来一轮」。不知道用户要点几轮,所以用 while True + break(4.3):

PYTHON
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 落到文件里:

PYTHON
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):

PYTHON
def main():
    todos = load()
    while True:
        # ... 菜单和分支照旧 ...
        save(todos)                      # 每轮都落盘,中途关掉窗口也不丢

16.5 用户什么都会输:把校验单独包起来

「标记完成 / 删除」都要用户输入序号,而用户会输 abc、99、甚至直接回车。与其在每个分支里重复判断,不如写一个专门的函数,把「一段文字」变成「一个合法下标」,不合法就返回 None(6.5 的多 return、11.2 的 EAFP):

PYTHON
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

调用处就干净了:

PYTHON
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)

PYTHON
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 跑一遍看看

POWERSHELL
python .\todo.py
TEXT
1 查看   2 添加   3 标记完成   4 删除   0 退出
选一个:2
要做什么:看完第 6 章
加好了

1 查看   2 添加   3 标记完成   4 删除   0 退出
选一个:1
1. [ ] 看完第 6 章

1 查看   2 添加   3 标记完成   4 删除   0 退出
选一个:0
已保存,下次见

再跑一次,第一条还在。这时候打开 todos.json 会看到:

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

附录 A 新手必踩的坑

A1 浮点精度

PYTHON
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 可变默认参数

PYTHON
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 与 ==

PYTHON
a = [1, 2]; b = [1, 2]
print(a == b)        # True   值相等
print(a is b)        # False  不是同一个对象
print(a is None)     # 判断 None 必须用 is
# 输出:
#   True
#   False
#   False

A4 遍历时修改列表

PYTHON
nums = [1, 2, 3, 4]
for n in nums[:]:              # ✅ 遍历副本
    if n % 2 == 0:
        nums.remove(n)

A5 浅拷贝嵌套结构

PYTHON
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 缩进没错,但逻辑错了

PYTHON
for n in ["小明", "小红"]:
    print(f"你好,{n}")
print("大家都在")        # 少缩一格 → 只打一次
# 输出:
#   你好,小明
#   你好,小红
#   大家都在
TEXT
你好,小明
你好,小红
大家都在
PYTHON
for n in ["小明", "小红"]:
    print(f"你好,{n}")
    print("大家都在")    # 多缩一格 → 每人打一次
# 输出:
#   你好,小明
#   大家都在
#   你好,小红
#   大家都在
TEXT
你好,小明
大家都在
你好,小红
大家都在

两段都不报错,因为缩进在语法上完全合法。这类 bug 比 IndentationError 难查得多——缩进决定「这行归谁管」,不只是排版。写完循环先扫一眼:哪些行该在循环里、哪些该在外面。

A9 变量名把内置函数覆盖了

PYTHON
list = [1, 2, 3]
# list("abc")     # TypeError: 'list' object is not callable

list、str、sum、id、input 这些内置名字并不特殊,赋值就是把标签贴到别的东西上了(8.1)。换个名字(items、lst)最省事;已经覆盖了想救回来,用 del 把标签删掉,查找时又会回退到内置(7.7 的 LEGB 顺序):

PYTHON
del list
print(list("abc"))       # ['a', 'b', 'c']
# 输出(需与上一段代码连着跑):
#   ['a', 'b', 'c']
附录 B

附录 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 以上通用语法编写,均可直接运行;建议配合交互窗口动手练习。

实战篇 1

实战篇 1 · 常用工具一次认全(zip / map / filter / lambda / is)

补 1.1 先分清三件事:配对、变形、筛选

写循环写久了,你会发现自己总在重复干三件事:把两份数据按位置对齐、把每个元素改一改、把不要的丢掉。Python 给这三件事各配了一个小工具,记住一句话就够:配对用 zip,变形用 map,筛选用 filter。

zip() 像拉拉链:两条拉链并排往上拉,一边出一个齿,配成一对。

PYTHON
names = ["小明", "小红", "小刚"]
scores = [88, 95, 70]

for name, score in zip(names, scores):
    print(f"{name}:{score} 分")
# 输出:
#   小明:88 分
#   小红:95 分
#   小刚:70 分

map() 像流水线上的喷漆工:来一个零件,按同一个动作处理一下,再送出去。filter() 像质检员:合格的留下,不合格的直接扔掉。

PYTHON
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 也一样是迭代器,而且长短不齐时按最短的那条停:

PYTHON
list(zip([1, 2, 3], ["a"]))   # [(1, 'a')],后面的 2、3 直接丢掉

想让长的那条也保留、缺的地方补个默认值,用 itertools.zip_longest:

PYTHON
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 都不用写。

PYTHON
add = lambda a, b: a + b
print(add(2, 3))     # 5
# 输出:
#   5

它最常见的用处,是给 sorted、map、filter 临时递一个规则:

PYTHON
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:日常更推荐前者

上面那两句,用列表推导式写更清爽:

PYTHON
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)) 把数字全转成字符串;或者数据很大、想一路惰性处理不落盘时。换成生成器表达式,把方括号改成圆括号,也一样省内存:

PYTHON
total = sum(x * x for x in range(1_000_000))   # 一个都不存,边算边加

字典和集合也有推导式,写法只换个括号:

PYTHON
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=。
PYTHON
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 比的是身份:是不是同一个对象(同一块内存)才为真。
PYTHON
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 串起来:一份成绩表的小练习

把上面这些工具放在一段真能跑的代码里,感受一下「不手写循环」是什么味道:

PYTHON
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

实战篇 2 · 写出靠谱的代码(调试、类型注解、pathlib、CSV / JSON)

补 2.1 报错别慌,倒着读 Traceback

程序一崩,屏幕上哗啦一大片红字,新手第一反应是「完了」。其实有用的只有两处:最后一行告诉你出了什么错,从下往上找到自己文件里的那一行告诉你在哪儿炸的。

PYTHON
def divide(a, b):
    return a / b

divide(10, 0)
# (说明:这一段是在演示「除以 0」会直接报错,所以故意不写输出)
TEXT
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,看看变量到底变成了什么:

PYTHON
print("这里 user =", user, "类型 =", type(user))
# (说明:这一段要连着上一段代码一起跑才有输出)

问题一多,print 就满屏都是,上线前还得一条条删。这时候换 logging:

PYTHON
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 不要求你声明类型,但给函数写上注解,别人(和三个月后的你)一眼就知道该怎么调用:

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 用 / 运算符帮你拼,还能顺手做「存在吗、建目录、找文件」:

PYTHON
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 5799

Path("data") / "日记.txt" 这个 / 不是除法,是「拼一节路径」。read_text / write_text 记得都带上 encoding="utf-8",中文才不会乱码。要遍历子目录,把 glob("*.py") 换成 rglob("*.py")。

补 2.5 argparse:让脚本能带参数跑

写死文件名的脚本,换份数据就得改代码。加几行 argparse,就能从命令行传进来:

PYTHON
# 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)} 行")
# (说明:这一段是在演示「测试失败」,故意让它报错)
POWERSHELL
python count.py data\日记.txt
python count.py data\日记.txt --encoding gbk
python count.py --help

add_argument 里不带横线的叫位置参数(必须给),带 -- 的叫可选参数(有默认值)。--help 是白送的,不用自己写。

补 2.6 CSV 与 JSON 批处理:读一堆、汇一份

真实工作里最常见的活儿:把一堆表格文件读进来,算个汇总,再写出去。csv 模块处理表格,json 处理配置和网络数据。

PYTHON
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 一个小项目该长什么样

不用一上来就学框架。把前面这些拼起来,一个能维护的小项目大概是这样:

TEXT
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

实战篇 3 · 再往前一步(async / await、API、FastAPI 与学习路线)

补 3.1 async / await:到底在等什么

前面写的代码都是「一步做完再做下一步」。如果一步是「等网络返回」,CPU 就干坐着浪费时间。async 的意思是:碰到要等的地方,先让出去干别的,等对方回话了再接着做。

PYTHON
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):

PYTHON
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):

PYTHON
# 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)
POWERSHELL
uvicorn app:app --reload

浏览器打开 http://127.0.0.1:8000/docs,会自动看到一份可交互的接口文档。这里正好把前面的知识串起来了:

  • @app.get(...) 是装饰器,在定义时把函数登记到路由表上;
  • name: str = "世界" 是类型注解 + 默认参数;
  • AddIn 这个类由 Pydantic 按注解做运行时校验,传错类型会自动返回 422;
  • 返回 dict,框架替你 json.dumps 成响应体。

所以看框架别觉得是另一门语言,底下就是函数、装饰器、类型注解、字典这几样。

补 3.4 标准库再补几个顺手的

不用全背,知道「有这么个东西」就够了,用到再查:

PYTHON
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 知识体系在线自测 - 我的图片」,学完一批就去测一遍,看看哪块还虚。