Python中不可变数据类型是基础但容易混淆的概念。理解int、float、str、bool的不可变性，能帮助你写出更高效、更安全的代码，尤其在多线程、数据结构设计和调试场景下。本文从底层内存角度出发，结合代码实例，逐一拆解这些类型的特性，并延伸至可变类型对比、拷贝、id与is的区分，适合Python初中级开发者巩固基础。
一、不可变数据类型是什么？
不可变（Immutable）意味着对象一旦创建，其值或状态就无法原地修改。任何“修改”操作（如加、乘、调用方法）都会在内存中生成一个新对象，原对象保持不变。Python中常见的不可变类型有：int、float、str、bool、tuple、frozenset。本文重点讨论前四种最常用的基础类型。
二、整数int：小整数缓存与链式赋值
整数不可变，所有运算都创建新对象。看代码：
- a = 10
- print(id(a)) # 原始对象地址
- a = a + 5
- print(id(a)) # 地址改变，说明是新对象
Python对小整数（-5~256）做了缓存优化：相同值的整数可能共享同一内存地址。这与链式赋值密切相关：
- a = b = 4 # a和b指向同一个整数对象4
- print(id(a) == id(b)) # True
- b = 5 # b指向新对象5，a仍指向4
- print(id(a) == id(b)) # False
- print(id(a) == id(4)) # True，小整数4被缓存
大整数（如256以上）每次运算都会创建新对象，不会缓存。
三、浮点数float：精度问题与无缓存
浮点数同样不可变，但有两个关键区别：一是运算结果可能存在IEEE 754标准导致的精度误差（例如0.1+0.2!=0.3），二是Python不会缓存浮点数对象，相同值的浮点数也可能不同地址。
- x = 3.14
- print(id(x))
- x = x * 2
- print(id(x)) # 地址改变
- print(0.1 + 0.2 == 0.3) # False
- print(0.1 + 0.2) # 0.30000000000000004
对于需要精确小数计算的场景，建议使用decimal模块。
四、字符串str：所有方法返回新对象
字符串是最常用的不可变类型之一。字符串的upper()、replace()、strip()等方法都不会修改原字符串，而是返回新字符串。索引访问只读，不能赋值：
- s = "Hello"
- print(id(s))
- s = s + " World!"
- print(id(s)) # 地址改变
- text = "Python"
- upper_text = text.upper()
- print(text is upper_text) # False
- word = "immutable"
- try:
- word[0] = "I"
- except TypeError as e:
- print(e) # 'str' object does not support item assignment
大量字符串拼接时，使用join()比用+性能更好，因为join()预先分配内存，避免反复创建中间对象。
五、布尔值bool：单例与int子类
True和False是单例对象，全局仅有一个实例。布尔值是int的子类（True=1，False=0）。重新赋值只是让变量指向另一个单例：
- flag = True
- print(id(flag))
- flag = False
- print(id(flag)) # 指向False单例，地址不同
- print(True is True) # True
- print(False is False) # True
- print(isinstance(True, int)) # True
六、不可变性的优势与注意事项
优势包括：
- 线程安全：不可变对象可在多线程间自由共享，无需加锁。
- 哈希支持：不可变对象可哈希，可以作为字典的键或集合的元素（字典键必须是不可变类型）。
- 缓存友好：相同值的不可变对象可被重用，如小整数缓存、字符串驻留。
- 代码可预测：对象状态不会意外改变。
注意事项：
- 频繁修改不可变对象会创建大量新对象，带来内存开销。例如字符串拼接多用join()。
- 容器中存放不可变对象：列表中的不可变元素可以被替换（整个元素），但元素本身不能修改。
字典键必须使用不可变类型：
- valid_dict = {"name": "Alice", 42: "Answer", (1,2): "tuple", True: "Bool"}
- invalid_dict = {[1,2]: "list"} # 报错: unhashable type: 'list'
七、可变数据类型对比：list/dict/set
与不可变相反，可变类型修改内容时不会改变对象id：
- my_list = [1,2,3]
- print(id(my_list))
- my_list.append(4)
- my_list[0] = 100
- print(id(my_list)) # id不变
- my_dict = {"name":"Alice", "age":25}
- print(id(my_dict))
- my_dict["age"] = 26
- print(id(my_dict)) # id不变
- my_set = {1,2,3}
- print(id(my_set))
- my_set.add(4)
- print(id(my_set)) # id不变
八、浅拷贝与深拷贝：copy() vs deepcopy()
拷贝可变对象时，要区分层次：
- import copy
- original = [[1,2], [3,4]]
- shallow = copy.copy(original)
- print(shallow is original) # False，外层是新对象
- print(shallow[0] is original[0]) # True，内层是同一对象
- shallow[0].append(99)
- print(original) # [[1,2,99], [3,4]] 原对象被修改
- deep = copy.deepcopy(original)
- print(deep[0] is original[0]) # False，内层也是新对象
- deep[0].append(88)
- print(original) # [[1,2,99], [3,4]] 保持不变
选择原则：如果对象只包含不可变元素或需要共享内部引用，用shallow；如果需要完全独立副本（特别是嵌套可变对象），用deep。
九、id()函数：查看对象内存地址
id()返回对象的唯一标识（CPython中是内存地址）。
- a=100; b=100; c=200; d=200
- print(id(a), id(b)) # 相同（小整数缓存）
- print(a is b) # True
- print(id(c), id(d)) # 不同（大整数无缓存）
- print(c is d) # False
- list1 = [1,2,3]
- list2 = [1,2,3]
- list3 = list1
- print(list1 is list2) # False
- print(list1 is list3) # True
注意：id()的值在对象生命周期内唯一；两个对象id相同意味着它们是同一个对象。
十、is与==的区别：对象标识 vs 值相等
这是初学者容易混淆的地方：
- is 比较两个变量是否引用同一个对象（内存地址）。
- == 比较两个对象的内容是否相等。
- x=256; y=256
- print(x == y) # True
- print(x is y) # True（小整数缓存）
- a=1000; b=1000
- print(a == b) # True
- print(a is b) # False（大整数无缓存）
- listA=[1,2,3]; listB=[1,2,3]; listC=listA
- print(listA == listB) # True
- print(listA is listB) # False
- print(listA is listC) # True
- print(None is None) # True
- print(True == 1) # True（值相等）
- print(True is 1) # False（类型不同）
建议：值比较用==，判断None用is，检查对象同一性用is。is比==稍快（只比较地址）。
理解这些底层机制，能让你在日常编码中更自信地处理变量赋值、函数传参、数据结构设计等问题，避免因对象共享导致的隐蔽bug。 |
发表于 
发表于