Python中的可变对象与不可变对象

在Python中，数据类型分为可变对象和不可变对象，它们在内存中的表现方式有所不同，特别是在进行数据修改时，是否会影响对象的内存地址。本文将通过Python中的六大标准数据类型（数字、字符串、列表、元组、集合、字典）来分析哪些属于可变对象，哪些属于不可变对象。

一、Python的六大标准数据类型

Python中有六大标准数据类型：

• 数字 (Number): int, float, bool, complex
• 字符串 (String): str
• 列表 (List): list
• 元组 (Tuple): tuple
• 集合 (Set): set
• 字典 (Dictionary): dict

1. 数字类型 (Number)

数字类型包括整数 int、浮点数 float、布尔值 bool 和复数 complex。这些类型的对象是不可变的。

2. 字符串 (String)

字符串类型 (str) 是不可变对象。这意味着字符串对象的内容一旦创建就不能改变。

3. 列表 (List)

列表类型 (list) 是可变对象。对列表的任何修改都会直接影响到原始列表对象。

4. 元组 (Tuple)

元组类型 (tuple) 是不可变对象。尽管元组本身是一个容器，它不能修改，但它可以包含可变类型的元素。

5. 集合 (Set)

集合类型 (set) 是可变对象。你可以在原有集合中添加或删除元素。

6. 字典 (Dictionary)

字典类型 (dict) 也是可变对象。你可以直接修改字典中的键值对。

二、可变对象与不可变对象的内存地址变化

1. 不可变对象的内存地址

不可变对象的内存地址在修改时会发生变化，每次修改都会创建新的对象，原始对象的内存地址保持不变。在实际应用中，尽量使用不可变对象。如tuple，是不可变对象，代码会安全。

2. 可变对象的内存地址

可变对象的内存地址不会改变，对对象内容的修改会直接影响原始对象。多个引用会指向同一个内存地址。

3. 示例代码

# 1. 数字类型（不可变）
a = 10
b = a
print("数字类型示例：")
print(f"初始值: a = {a}, b = {b}")
print(f"初始地址: id(a) = {id(a)}, id(b) = {id(b)}")  # 初始时a和b地址相同

# 对不可变对象进行变更操作
a += 5  # 改变a的值
print(f"\n修改后的值: a = {a}, b = {b}")
print(f"修改后的地址: id(a) = {id(a)}, id(b) = {id(b)}")  # a的地址发生变化，b的地址不变

# 2. 字符串类型（不可变）
s1 = "hello"
s2 = s1
print("\n字符串类型示例：")
print(f"初始值: s1 = {s1}, s2 = {s2}")
print(f"初始地址: id(s1) = {id(s1)}, id(s2) = {id(s2)}")  # 初始时s1和s2地址相同

# 对不可变对象进行变更操作
s1 = "world"  # 重新赋值
print(f"\n修改后的值: s1 = {s1}, s2 = {s2}")
print(f"修改后的地址: id(s1) = {id(s1)}, id(s2) = {id(s2)}")  # s1的地址发生变化，s2的地址不变

# 3. 列表类型（可变）
lst1 = [1, 2, 3]
lst2 = lst1
print("\n列表类型示例：")
print(f"初始值: lst1 = {lst1}, lst2 = {lst2}")
print(f"初始地址: id(lst1) = {id(lst1)}, id(lst2) = {id(lst2)}")  # 初始时lst1和lst2地址相同

# 对可变对象进行变更操作
lst1.append(4)  # 直接修改列表
print(f"\n修改后的值: lst1 = {lst1}, lst2 = {lst2}")
print(f"修改后的地址: id(lst1) = {id(lst1)}, id(lst2) = {id(lst2)}")  # 地址不变，因为它们共享同一个对象

# 4. 元组类型（不可变）
t1 = (1, 2, 3)
t2 = t1
print("\n元组类型示例：")
print(f"初始值: t1 = {t1}, t2 = {t2}")
print(f"初始地址: id(t1) = {id(t1)}, id(t2) = {id(t2)}")  # 初始时t1和t2地址相同

# 对不可变对象进行变更操作
t1 = (4, 5, 6)  # 重新赋值
print(f"\n修改后的值: t1 = {t1}, t2 = {t2}")
print(f"修改后的地址: id(t1) = {id(t1)}, id(t2) = {id(t2)}")  # t1的地址发生变化，t2的地址不变

# 5. 集合类型（可变）
s1 = {1, 2, 3}
s2 = s1
print("\n集合类型示例：")
print(f"初始值: s1 = {s1}, s2 = {s2}")
print(f"初始地址: id(s1) = {id(s1)}, id(s2) = {id(s2)}")  # 初始时s1和s2地址相同

# 对可变对象进行变更操作
s1.add(4)  # 修改集合
print(f"\n修改后的值: s1 = {s1}, s2 = {s2}")
print(f"修改后的地址: id(s1) = {id(s1)}, id(s2) = {id(s2)}")  # 地址不变，因为它们共享同一个集合对象

# 6. 字典类型（可变）
d1 = {"a": 1, "b": 2}
d2 = d1
print("\n字典类型示例：")
print(f"初始值: d1 = {d1}, d2 = {d2}")
print(f"初始地址: id(d1) = {id(d1)}, id(d2) = {id(d2)}")  # 初始时d1和d2地址相同

# 对可变对象进行变更操作
d1["c"] = 3  # 修改字典
print(f"\n修改后的值: d1 = {d1}, d2 = {d2}")
print(f"修改后的地址: id(d1) = {id(d1)}, id(d2) = {id(d2)}")  # 地址不变，因为它们共享同一个字典对象

输出示例：

数字类型示例：
初始值: a = 10, b = 10
初始地址: id(a) = 140732924626120, id(b) = 140732924626120

修改后的值: a = 15, b = 10
修改后的地址: id(a) = 140732924626280, id(b) = 140732924626120

字符串类型示例：
初始值: s1 = hello, s2 = hello
初始地址: id(s1) = 1593406727024, id(s2) = 1593406727024

修改后的值: s1 = world, s2 = hello
修改后的地址: id(s1) = 1593406727984, id(s2) = 1593406727024

列表类型示例：
初始值: lst1 = [1, 2, 3], lst2 = [1, 2, 3]
初始地址: id(lst1) = 1593403419712, id(lst2) = 1593403419712

修改后的值: lst1 = [1, 2, 3, 4], lst2 = [1, 2, 3, 4]
修改后的地址: id(lst1) = 1593403419712, id(lst2) = 1593403419712

元组类型示例：
初始值: t1 = (1, 2, 3), t2 = (1, 2, 3)
初始地址: id(t1) = 1593406881728, id(t2) = 1593406881728

修改后的值: t1 = (4, 5, 6), t2 = (1, 2, 3)
修改后的地址: id(t1) = 1593406305152, id(t2) = 1593406881728

集合类型示例：
初始值: s1 = {1, 2, 3}, s2 = {1, 2, 3}
初始地址: id(s1) = 1593404393728, id(s2) = 1593404393728

修改后的值: s1 = {1, 2, 3, 4}, s2 = {1, 2, 3, 4}
修改后的地址: id(s1) = 1593404393728, id(s2) = 1593404393728

字典类型示例：
初始值: d1 = {'a': 1, 'b': 2}, d2 = {'a': 1, 'b': 2}
初始地址: id(d1) = 1593404749504, id(d2) = 1593404749504

修改后的值: d1 = {'a': 1, 'b': 2, 'c': 3}, d2 = {'a': 1, 'b': 2, 'c': 3}
修改后的地址: id(d1) = 1593404749504, id(d2) = 1593404749504

三、总结

• 不可变对象: 数字类型（int、float、bool、complex）、字符串 (str)、元组 (tuple)
• 可变对象: 列表 (list)、集合 (set)、字典 (dict)

理解可变与不可变对象的区别对编写高效且没有bug的代码非常重要。在开发过程中，使用不可变对象可以避免意外修改数据，而使用可变对象则能够有效管理数据的动态变化。

希望本文对你理解Python中的对象变更和内存管理有所帮助。如果你有任何问题或补充，欢迎在评论区留言。