同事把一段批量处理脚本交给我,说「跑是能跑,就是有些用户明明被禁用了,却还在收到消息」。脚本结构大致是这样:
for user in users:
if user.enabled:
if user.retry:
send(user)
else:
log_skip(user)
读起来像是「启用的走发送逻辑,没启用的记一条跳过日志」。实际运行的结果却是:enabled 为真的用户里,只有 retry 为真的那部分被发了消息;enabled 为假的人一条日志都没有。程序没有报错,退出码是 0,日志也很安静。
原因只有一句话:那个 else 属于离它最近的 if user.retry,不属于外层的 if user.enabled。Python 不靠括号划分代码块,靠缩进;缩进错了,代码的「从属关系」就变了,而且往往还是合法程序。这类问题比语法错误难查,因为它不吵不闹。
这篇从这种「不报错的错误」切入,把 Python 最基础的几件事讲清楚:缩进到底被解释器怎么读、变量究竟是什么、类型注解为什么写了也不拦运行、条件判断里哪些值会被当成假。这些是后面所有内容的地基,地基歪了,学再多库也是在歪的地基上加楼层。
缩进是语法,不是排版风格
大多数语言里,缩进只是给人看的,删掉换行和空格,程序结构不变。Python 不一样:解释器在词法分析阶段就会产生缩进和反缩进标记,和括号一样参与语法结构的构建。换句话说,你按 Tab 还是四个空格、缩进几层,直接决定代码属于哪个块。
解释器对缩进的容忍度其实不低:同一份文件里,只要同一个块内部保持一致,用两个空格、四个空格甚至一个 Tab 都能跑。它真正拒绝的是同一个块里混用两种缩进方式。我把一段代码的第二行改成 Tab、其余用空格,跑出来的报错是:
File "taberr.py", line 4
y = 2
^
TabError: inconsistent use of tabs and spaces in indentation
TabError 是 IndentationError 的子类,专门指出「同一个块里 Tab 和空格混着用了」。注意报错只给了一个尖号位置,不告诉你哪一行才是「对的」。修复方式不是猜,而是把整个文件统一:编辑器里打开「显示空白字符」,或者直接跑一次格式化工具,让全文件统一成四个空格。
实际项目里的建议很朴素:编辑器设置成「Tab 键插入 4 个空格」,保存时自动格式化,代码评审时不要让缩进风格成为讨论点。团队里只要有一个人坚持用 Tab,混用几乎是迟早的事。缩进宽度本身没有对错,一致才有意义。
「缩进参与语法」还有个副作用:复制粘贴代码时最容易出事。从网页、聊天工具、PDF 里拷来的代码,空格可能被替换成不换行空格,肉眼完全看不出来,解释器却会报 IndentationError 或更奇怪的 SyntaxError。遇到这种报错,先怀疑不可见字符,而不是逻辑写错。
变量是名字,不是盒子
初学时常把变量想成一个盒子,赋值就是把东西放进盒子。Python 里更准确的模型是「名字贴在对象上」:对象在内存里独立存在,赋值只是让某个名字指向它。这个差别在不可变类型上看不出来,在列表、字典这类可变对象上会立刻显形。
a = [1, 2]
b = a
b.append(3)
print(a)
print(a is b, id(a), id(b))
实际输出:
[1, 2, 3]
True 2317648593536 2317648593536
b = a 没有创建新列表,只是给同一个列表多贴了一个名字。所以改 b 就是改 a。is 判断的是「是不是同一个对象」,== 判断的是「值相不相等」。两个内容相同的列表,== 为真,is 通常是假。判断 None 时用 is None,因为 None 在进程里只有一个实例;判断数值、字符串内容时用 ==。
同一个坑还有一个更隐蔽的版本:函数默认参数只会在函数定义时求值一次。
def add(item, bucket=[]):
bucket.append(item)
return bucket
print(add(1))
print(add(2))
print(add.__defaults__)
输出是 [1] 然后是 [1, 2],第二次调用没有拿到「新列表」。因为默认值 [] 在 def 执行时就创建好了,所有没传 bucket 的调用共享同一个列表。正确写法是默认值用 None,函数体里再创建:
def add(item, bucket=None):
if bucket is None:
bucket = []
bucket.append(item)
return bucket
这条规则不只适用于列表,字典、集合、自定义对象都一样。判断标准很简单:默认值是不是可变对象。可变就改用 None 占位。
名字绑定还解释了另一个现象:函数内部给变量赋值,默认创建的是局部名字,不会改到外面的同名变量。要在函数里改模块级变量,得写 global;要改外层函数的变量,得写 nonlocal。这两种声明不是「提升权限」,而是在告诉解释器「这个名字去外层找,不要在本层新建」。
如果确实需要一份独立副本,还要分清浅复制和深复制。list.copy()、dict.copy()、切片 items[:] 都只复制最外层容器,里面的嵌套列表仍然共享。改「副本」里的子列表,原对象也会变。只有 copy.deepcopy() 会递归复制所有层级,代价是慢,而且遇到循环引用要靠内部记录表处理。二维表格、嵌套配置这类结构,复制前先想清楚要改哪一层,别默认复制就安全了。
类型注解是给人看的,运行时不管
Python 3 支持在参数和返回值上写类型。很多人第一次看到就以为它像 Java 一样会做检查,于是写出这种代码:
def f(x: int) -> str:
return x
print(f("abc"))
print(f.__annotations__)
实际输出是 abc 和 {'x': <class 'int'>, 'return': <class 'str'>}。函数收到了字符串,返回了字符串,解释器一句话都没说。类型注解在这里只是被存进 __annotations__ 字典的元数据,运行时不参与检查。
那它有什么用?三个用途是真实的:编辑器补全和跳转、静态检查工具(mypy、pyright)在提交前发现问题、以及给别人读代码时少猜。它是一份「意图声明」,不是「运行时合同」。想让注解真正拦住错误,得在 CI 里跑类型检查工具,把它当成代码评审的一部分。
注解写法本身也在演进。以前写 List[int]、Optional[str],需要从 typing 导入;现在可以直接写 list[int]、str | None,更短也更符合直觉。给变量标注用 count: int = 0,给函数标注写在签名上,复杂结构用类型别名拆开:
type UserId = int
def find_user(uid: UserId, cache: dict[str, str] | None = None) -> str | None:
if cache is None:
cache = {}
return cache.get(str(uid))
注意 type 语句是较新的语法,旧版本解释器不支持;跨版本项目里仍可写 UserId = int。注解的代价几乎为零,但静态检查是有成本的:团队要接受「类型检查报错就不能合并」,否则注解很快会退化成装饰。
x: int 却传了字符串还能跑,不是解释器有 bug,是注解本来就不负责这件事。真值判断:哪些值会被当成假
if、while、and、or、not 都会先把值转成布尔。Python 规定下面这些是假:False、None、数值零(0、0.0、0j)、空字符串、空列表、空元组、空字典、空集合,以及自定义了 __bool__ 或 __len__ 并返回假的对象。其余都是真。
最容易踩的是字符串:非空字符串永远为真,内容是什么不重要。
print(bool("False"), bool("0"), bool(" "), bool([]))
True True True False
从命令行、环境变量、JSON 配置里读到的「false」,类型是字符串,if value: 一定进得去。正确做法是先解析:value.lower() in ("1", "true", "yes"),或者干脆用 json.loads 让 JSON 自己给出布尔值。这个坑在配置读取里出现频率极高。
第二个常见写法是「有值就用,没有就用默认」:
count = int(input_value or 10)
当用户输入 0 时,0 是假,表达式会取 10。如果 0 是合法值,这就错了。要用 count = 10 if input_value is None else int(input_value),把「没提供」和「提供了零」区分开。这类 bug 不会抛异常,只会让统计数字悄悄不对。
自定义对象也能定义自己的真值。实现了 __bool__ 就按它的返回值算;只实现 __len__ 就按长度是否为 0 算。一个表示「查询结果」的类,如果不小心把 __len__ 定义成「总页数」,那么没有数据但页数非零时,对象仍然是真,if result: 就会误判。写这类方法时要问自己:这个对象的「空」到底指什么,别让两个语义混在一个方法里。
顺带说清 and 和 or 的返回值:它们不返回布尔,而是返回参与运算的那个对象本身。a and b 在 a 为假时返回 a,否则返回 b;a or b 在 a 为真时返回 a,否则返回 b。所以 x or "default" 能当默认值用,但也正是它把 0 换掉的原因。链式比较 0 < x < 10 是 Python 少有的「写法接近数学」的地方,等价于两次比较用 and 连接,中间的 x 只求值一次。
第三个是 is None 与 == None 的区别。None 是单例,is None 判断身份,永远准确且快;== None 会调用对象的相等比较,自定义类型如果实现了 __eq__,可能返回意料之外的结果。统一写 is None,团队里不要两种混用。
is None 区分「没有」和「是零」。"false" 非空为真,必须自己转布尔。if not items: 比 if len(items) == 0: 更直接,也兼容迭代器之外的空容器。数字、浮点与字符串的边界
Python 的整数没有固定位宽,理论上可以一直变大,不会像 C 那样溢出。代价是大整数运算比机器字长慢,超大数还会吃内存。除法有两个运算符:/ 永远返回浮点,// 是向下取整的整除。负数上这一点常被记错:
print(10 / 3)
print(10 // 3)
print(-10 // 3)
print(-10 % 3)
3.3333333333333335
3
-4
2
-10 // 3 是 -4,不是 -3,因为向下取整。取模结果 2 也跟「余数」的直觉相反,但满足 a == (a // b) * b + (a % b)。做分页、时间换算、坐标对齐时,如果涉及负数,要拿具体数字代进去验算,不要凭记忆。
浮点数遵循 IEEE 754 双精度,0.1 + 0.2 的实际输出是 0.30000000000000004。0.1 和 0.2 在二进制里都不能精确表示,相加后误差累积。判断浮点相等不要写 a == b,用 math.isclose(a, b),或者把金额换成「分」用整数算。这不是 Python 的缺陷,所有用双精度的语言都一样。
字符串是不可变对象,下标只能读不能写:
s = "abc"
s[0] = "z"
TypeError: 'str' object does not support item assignment
要改字符只能生成新字符串,比如切片拼接、str.replace、或者先转成列表改完再 join。这也意味着大量字符串拼接会产生大量中间对象,循环里拼长文本应改用列表收集再 "".join(parts)。f-string 是格式化首选:f"{name}: {count:,}",可读性和性能都比 % 与 format 好。
另外注意字符串的「长度」按字符算:len("中文") 是 2。但某些表情符号由多个码位组成,len 可能大于肉眼看到的字符数。做用户可见的截断时,不要直接用下标切,否则可能把组合字符切开,显示成半个表情。这类需求要么用专门的文本分段库,要么在业务上限定只处理普通文字。
现象对照
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
缩进看起来一样却报 IndentationError | 混入了不换行空格或全角空格 | 打开「显示空白字符」,或直接重新格式化整个文件 |
TabError: inconsistent use of tabs and spaces | 同一个块内 Tab 与空格混用 | 统一成四个空格,检查编辑器是否自动转换 |
| 程序不报错但分支走错 | else 绑定到了内层 if | 看缩进层级,必要时给内层块加注释或提前 return |
| 改一个列表,另一个列表也变了 | 两个名字指向同一个可变对象 | 打印 id(),需要独立副本时用 copy() 或切片 |
| 函数默认参数越调越多 | 默认值只在定义时创建一次 | 看 func.__defaults__,把可变默认值改成 None |
注解写了 int 却传进字符串还能跑 | 注解是元数据,运行时不校验 | 在 CI 里跑 mypy 或 pyright,不要指望解释器 |
bool("False") 是 True | 非空字符串一律为真 | 确认值的实际类型,字符串显式解析成布尔 |
| 用户输入 0 却被替换成默认值 | x or default 把 0 当成假 | 改成 None 判断,区分「缺失」与「零」 |
0.1 + 0.2 不等于 0.3 | 二进制无法精确表示这两个小数 | 用 math.isclose,金额改用整数分 |
边界与代价
动态类型带来的第一个代价是「错误发现得晚」。同样的拼写错误,在编译型语言里编译不过,在 Python 里可能跑到那行才抛 NameError,甚至永远不抛——如果那行在冷门分支里。缓解手段不是把 Python 写成像 Java,而是补两层:关键模块写类型注解并跑静态检查,关键路径写测试。注解负责「形状」,测试负责「行为」,两者不能互相替代。
第二个代价是重构时缺少编译器帮你找调用点。改一个函数参数名,只能靠搜索和类型检查工具。项目越大,注解和测试的投入越早回本。小脚本可以随意,长期维护的代码库不能靠「我记得」。
第三个代价是缩进敏感带来的工具依赖。代码评审里因为空格产生的 diff、复制粘贴带来的不可见字符、不同编辑器默认 Tab 宽度不一致,都是真实的时间损耗。用格式化工具统一,不要靠人自觉。
第四个代价是浮点和字符串的隐式行为。它们不是错误,而是语言按 IEEE 754 和 Unicode 的标准工作。知道边界在哪,比记住「不要用浮点」这种口号有用:金额用整数、比较用 isclose、文本截断考虑字素簇,按场景选工具。
最后要接受一件事:Python 的「简单」是把复杂度放到了运行时和开发者纪律上。语法几分钟能学完,但写出可维护的 Python,需要类型、测试、格式化和命名习惯一起到位。这篇只讲地基,下一篇开始讲 Python 真正有别于其他语言的那些特性。
还有一个常被忽略的细节:代码块的边界也影响变量的作用域。for、if、while 不会创建新的作用域,循环变量在循环结束后仍然存在;只有函数、类、模块和推导式会引入新的作用域。所以在一个长函数里反复用同一个循环变量名,很容易覆盖掉前面算好的值。把逻辑拆进小函数,比靠记忆变量生命周期可靠。
小结
缩进在 Python 里是语法的一部分,同一个块里混用 Tab 和空格会直接报 TabError;变量是贴在对象上的名字,赋值不复制可变对象,函数默认值只求值一次;类型注解是元数据,不拦运行,要靠静态检查工具;条件判断里非空字符串永远为真,or 会把 0 当成缺失。
把这四点记住,能避开入门阶段一半的「莫名其妙」。遇到不报错但结果不对的代码,先查缩进层级和数据是不是同一个对象,再查条件的实际类型,最后才怀疑算法。
当天可以自己验证的练习:
- 写一个带内外两层
if的循环,故意让else缩进到内层,打印每条记录走了哪个分支,再改正缩进对比结果。 - 把一段代码的缩进改成 Tab,运行看
TabError的完整报错,然后用格式化工具修好。 - 创建两个内容相同的列表,分别用
=和copy()赋值,修改其中一个,打印id和两者内容。 - 写一个可变默认参数的函数,连续调用三次并打印
__defaults__,再改成None写法验证。 - 从环境变量读一个
"false",用if os.environ.get(...)判断,观察它进入哪个分支,再写正确的解析。
下一篇讲生成器、装饰器、上下文管理器与鸭子类型。这些是 Python 里最像「魔法」的部分,但拆开看都不复杂:生成器是能暂停的函数,装饰器是接收函数的函数,上下文管理器负责进入和退出,鸭子类型则解释为什么 Python 不关心对象「是什么类型」,只关心它「能做什么」。