“为什么 256 是同一个对象而 257 不是？”——Python 中 is 比较字符串/整数的陷阱与彻底纠正

文章目录

• “为什么 256 是同一个对象而 257 不是？”——Python 中 `is` 比较字符串/整数的陷阱与彻底纠正
• • 一、问题复现：昨天还好好的，今天怎么就不行了？
  • • 案例 1：整数比较的诡异反差
    • 案例 2：字符串比较的“幽灵”副作用
    • 案例 3：错误的配置比较导致功能失效
  • 二、底层原理：`is` 与 `==` 的根本分工
  • • 1. `is` 判断对象身份（内存地址）
    • 2. `==` 判断值相等
    • 3. 为什么小整数会“共享”？
    • 4. 字符串的“驻留”机制
  • 三、正确使用 `is` 的唯一场景：与单例比较
  • 四、常见陷阱与隐蔽表现
  • • 陷阱 1：交互环境 vs 脚本文件
    • 陷阱 2：跨模块传递字符串
    • 陷阱 3：`float` 的 `is` 比较
    • 陷阱 4：`NaN` 的特殊性
    • 陷阱 5：`id()` 的直接比较
  • 五、调试与静态检查
  • • 1. 识别问题：`is` 与字面量比较
    • 2. Lint 规则
    • 3. 单元测试
    • 4. 何时可以接受 `is`？
  • 六、最佳实践与纠错指南
  • 七、深入理解：为什么 CPython 要搞这些缓存？
  • 八、结语

“为什么 256 是同一个对象而 257 不是？”——Python 中 is 比较字符串/整数的陷阱与彻底纠正

Python 中有两个非常相似却截然不同的运算符：== 和 is。一个是值相等性判断，一个是对象身份判断。正是这种相似性，让无数开发者——尤其是从 C/Java 等语言转过来的工程师——习惯性地写出 if x is 100 或 if name is "Alice" 这样的代码。这种写法在很多时候碰巧能工作，但会在某些时刻突然崩坏，产生难以追踪的诡异逻辑错误。

本文将深入解析 is 与 == 的本质区别，揭开整数缓存与字符串驻留的神秘面纱，用实例展现何时该用 is（几乎只有单例），何时必须用 ==，并提供从 Lint 到代码审查的完整防护体系。

一、问题复现：昨天还好好的，今天怎么就不行了？

案例 1：整数比较的诡异反差

a = 256
b = 256
print(a is b) # True

c = 257
d = 257
print(c is d) # False（在交互环境中或脚本文件中可能出现）

明明是同样的写法，仅仅数值从 256 变成 257，is 的结果就天差地别。更令人迷惑的是，在同一个脚本中定义函数：

def test():
a = 257
b = 257
return a is b

print(test()) # True（因为同一代码块中的常量被合并）

同是 257，在不同位置的表现截然相反。

案例 2：字符串比较的“幽灵”副作用

name1 = "python"
name2 = "python"
print(name1 is name2) # True

long_name1 = "python is great!"
long_name2 = "python is great!"
print(long_name1 is long_name2) # 可能是 False，也可能 True？

短字符串有时相等，长字符串却不等，或者在同一函数内相等，跨模块却不相等。

案例 3：错误的配置比较导致功能失效

def check_permission(user):
# 期望管理员为 'admin'
if user is 'admin': # 错误！
return True
return False

print(check_permission('admin')) # 可能是 True，但也可能是 False

该权限检查在生产环境中可能偶发失效，原因仅仅是因为 is 的行为不受保障。

二、底层原理：is 与 == 的根本分工

1. is 判断对象身份（内存地址）

a is b 等价于 id(a) == id(b)，即判断两个引用是否指向内存中的同一个对象。它是身份比较，与值无关。

2. == 判断值相等

a == b 调用 a.__eq__(b)，比较两个对象的内容是否相同。对于整数和字符串，它比较的就是数值或字符序列。

3. 为什么小整数会“共享”？

CPython 出于性能考虑，在解释器启动时预先创建了 -5 到 256 范围内的所有整数对象并缓存。任何在这个范围内的整数字面量或运算结果，都会被直接复用缓存的对象，因此 a is b 返回 True。

但 257 超出了缓存范围。每次执行 c = 257，CPython 都会创建一个新的整数对象，因此 c is d 为 False（除非同一代码块的常量合并优化介入）。

缓存范围是 CPython 的实现细节，不同 Python 解释器（PyPy、Jython）可能有不同的范围甚至不缓存。依赖此行为编写 is 比较，代码将不可移植。

4. 字符串的“驻留”机制

字符串也存在类似优化——字符串驻留。CPython 会自动驻留一些看起来像标识符的字符串（只包含字母、数字、下划线），以及某些编译时常量。当你写下 "python"，CPython 可能将其驻留，导致多个相同字符串字面量引用同一对象。

但是，驻留规则非常复杂且不能依赖：长度、字符集、创建方式（str() vs 字面量）都会影响是否驻留。而且，即使运行中 a is b 为 True，也不保证换台机器或换个 Python 版本依然如此。

三、正确使用 is 的唯一场景：与单例比较

Python 中保证全局唯一的对象称为单例，最典型的就是 None、True、False。这些对象在整个解释器生命周期内只有一个实例，因此必须用 is 来检查它们。

if x is None: # 正确
if x is not None: # 正确
if flag is True: # 可以，但通常直接用 if flag
if flag is False: # 可以

为什么不能用 ==？因为某些对象可能重载了 __eq__ 方法，使得 obj == None 返回 True（虽然极罕见且不推荐），但 obj is None 绝对是可靠的。

其他单例：Ellipsis（…）、NotImplemented、模块本身等，也可用 is 比较。

除了这些，对于任何数值、字符串、列表、元组、字典等容器，永远只用 == 比较值，不用 is。

四、常见陷阱与隐蔽表现

陷阱 1：交互环境 vs 脚本文件

在交互式解释器中，每行代码是一个独立的编译单元，因此 a = 257; b = 257; a is b 很可能为 False。但在脚本文件（.py）或函数内部，编译器会合并同一代码块中的相同常量，此时 a is b 可能为 True。这种不一致性正是陷阱的根源。

陷阱 2：跨模块传递字符串

# module_a.py
def get_name():
return "Alice"

# module_b.py
import module_a
name = module_a.get_name()
print(name is "Alice") # 可能为 False，因为模块间的字符串对象可能不共享

即使两个模块中字面量相同，也不保证驻留生效。

陷阱 3：float 的 is 比较

float 没有小整数那样的缓存，但编译器可能会对相同常量做合并。永远不要对浮点数使用 is。

陷阱 4：NaN 的特殊性

import math
a = math.nan
print(a is math.nan) # True（因为是同一个单例对象）
print(a == math.nan) # False（NaN 不等于任何值，包括自身）

这是一个特例：is 可以检测是否是同一个 NaN 对象，但判断一个值是否为 NaN 应该用 math.isnan(x)。

陷阱 5：id() 的直接比较

有人试图用 id(a) == id(b) 来模拟 is，但若两个对象生命周期不重叠，id() 的值可能被回收重用，导致虚假的相等。应直接用 is。

五、调试与静态检查

1. 识别问题：is 与字面量比较

PyCharm 等 IDE 会在你写出 if x is 100 时给出警告：“Comparison with literal performed with is”。

2. Lint 规则

• flake8 规则 F632：检测 is/is not 与字符串或数字字面量的比较。
• pylint 规则 C0121：禁止用 is 与字面量比较（除了 None, True, False）。
• ruff 规则 F632 / E711 / E712：全面覆盖不当身份比较。

在 CI 中配置这些规则，可以从源头阻断隐患。

3. 单元测试

如果有旧代码依赖了整数/字符串的 is 比较，编写测试在不同条件下验证，很可能会暴露错误。例如用 Python 的 -O 选项或不同环境变量测试。

4. 何时可以接受 is？

如果代码就是判断“这个参数是不是传进来的那个特定对象”（例如一个哨兵值 SENTINEL = object()），那么必须用 is。因为这里需要的就是身份比较。

六、最佳实践与纠错指南

修正步骤：

一劳永逸的准则：如果你关心的是变量的内容，就用 ==；如果你关心的是变量是否指向同一个对象（几乎只有单例和哨兵），就用 is。

七、深入理解：为什么 CPython 要搞这些缓存？

小整数缓存和字符串驻留是解释器的性能优化，减少内存分配和对象创建开销。它们对人类是透明的——除非你错误地使用了 is。这也印证了 Python 设计哲学中的“实现细节不应被依赖”。通过 is 比较值，就是把实现细节暴露到了业务逻辑中。

八、结语

is 比较整数/字符串之所以危险，不是因为它本身有问题，而是因为它被滥用在需要值比较的场合。当 256 is 256 返回 True 而 257 is 257 返回 False，这并非 Python 的 bug，而是程序员对工具理解偏差的表现。把 is 留给单例，把 == 留给值——记住这条简单规则，你将在无数个深夜调试中拯救自己和他人的睡眠。

从现在开始，在代码库中搜索 is 100、 is "abc" 这样的模式，并将它们全部纠正为 ==；同时配置好你的 Lint 工具，让这类问题永远不再出现。这不仅仅是一个语法的切换，更是从“依赖巧合”到“稳健设计”的思维升级。