Python中不可变数据类型int, float, str, bool详解

# 示例 1：整数不可变验证
a = 10
print(f"a 的 id: {id(a)}")  # 输出 a 的内存地址

# 尝试“修改”a
a = a + 5
print(f"修改后 a 的值: {a}")
print(f"修改后 a 的 id: {id(a)}")  # id 已改变，说明是新对象

# 示例 2：小整数缓存（Python 优化）
b = 10
c = 10
print(f"b 的 id: {id(b)}")
print(f"c 的 id: {id(c)}")
print(f"b 和 c 是同一个对象吗？{b is c}")  # 通常为 True（-5 到 256 范围内）

a = b = 4 # a 和 b 都指向同一个整数对象 4
print(f"初始状态: a={a}, b={b}“)
print(f"a is b: {a is b}”) # True，指向同一对象
print(f"id(a): {id(a)}, id(b): {id(b)}")

b = 5 # 为 b 创建新的整数对象 5，a 仍然指向 4
print(f"\n修改 b 后: a={a}, b={b}“)
print(f"a is b: {a is b}”) # False，指向不同对象
print(f"id(a): {id(a)}, id(b): {id(b)}“)
print(f"id(4): {id(4)}, id(5): {id(5)}”)

c = 4
print(f"\nc = 4, id©: {id©}“)
print(f"a is c: {a is c}”) # True，因为 4 在小整数缓存范围内

# 示例 1：浮点数不可变验证
x = 3.14
print(f"初始 x 的 id: {id(x)}")

x = x * 2
print(f"计算后 x 的值: {x}")
print(f"计算后 x 的 id: {id(x)}")  # id 改变，新对象

# 示例 2：浮点数精度问题（与不可变性无关但重要）
print(0.1 + 0.2 == 0.3)  # False，浮点数精度问题
print(f"0.1 + 0.2 = {0.1 + 0.2}")  # 0.30000000000000004

# 示例 1：字符串不可变验证
s = "Hello"
print(f"初始 s 的 id: {id(s)}")

# 尝试修改字符串（实际创建新对象）
s = s + " World!"
print(f"修改后 s: {s}")
print(f"修改后 s 的 id: {id(s)}")  # id 改变

# 示例 2：字符串方法返回新对象
text = "Python"
upper_text = text.upper()
print(f"原字符串: {text}, id: {id(text)}")
print(f"大写后: {upper_text}, id: {id(upper_text)}")
print(f"是同一个对象吗？{text is upper_text}")  # False

# 示例 3：字符串索引访问（只读）
word = "immutable"
try:
    word[0] = "I"  # 尝试修改第一个字符
except TypeError as e:
    print(f"错误: {e}")  # 'str' object does not support item assignment

# 示例 1：布尔值不可变验证
flag = True
print(f"初始 flag 的 id: {id(flag)}")

# 布尔值本身不可变，但可以重新赋值
flag = False
print(f"重新赋值后 flag: {flag}")
print(f"重新赋值后 flag 的 id: {id(flag)}")  # id 改变，指向 False 单例

# 示例 2：布尔值是单例对象
a = True
b = True
c = False
d = False

print(f"a is b: {a is b}")  # True，同一对象
print(f"c is d: {c is d}")  # True，同一对象
print(f"id(True): {id(True)}")
print(f"id(False): {id(False)}")

# 有效：使用不可变类型作为键
valid_dict = {
    "name": "Alice",      # str 键
    42: "Answer",         # int 键
    (1, 2): "tuple key",  # tuple 键（不可变）
    True: "Boolean key"   # bool 键
}

# 无效：尝试使用可变类型作为键
try:
    invalid_dict = {[1, 2]: "list key"}  # 列表不可哈希
except TypeError as e:
    print(f"错误: {e}")  # unhashable type: 'list'

my_list = [1, 2, 3]
print(f"初始 id: {id(my_list)}")  # 初始内存地址

# 修改列表内容
my_list.append(4)
my_list[0] = 100
print(f"修改后列表: {my_list}")
print(f"修改后 id: {id(my_list)}")  # id 不变，说明是同一个对象

my_dict = {"name": "Alice", "age": 25}
print(f"初始 id: {id(my_dict)}")

# 修改字典
my_dict["age"] = 26
my_dict["city"] = "Beijing"
print(f"修改后字典: {my_dict}")
print(f"修改后 id: {id(my_dict)}")  # id 不变

my_set = {1, 2, 3}
print(f"初始 id: {id(my_set)}")

# 修改集合
my_set.add(4)
my_set.remove(2)
print(f"修改后集合: {my_set}")
print(f"修改后 id: {id(my_set)}")  # id 不变

import copy

original = [[1, 2], [3, 4]]
shallow = copy.copy(original)

print(f"original id: {id(original)}")
print(f"shallow id: {id(shallow)}")  # 外层列表是新对象
print(f"original[0] is shallow[0]: {original[0] is shallow[0]}")  # True，内层列表是同一对象

# 修改浅拷贝的内层列表会影响原对象
shallow[0].append(99)
print(f"修改后 original: {original}")  # [[1, 2, 99], [3, 4]]
print(f"修改后 shallow: {shallow}")    # [[1, 2, 99], [3, 4]]

import copy

original = [[1, 2], [3, 4]]
deep = copy.deepcopy(original)

print(f"original id: {id(original)}")
print(f"deep id: {id(deep)}")  # 外层列表是新对象
print(f"original[0] is deep[0]: {original[0] is deep[0]}")  # False，内层列表也是新对象

# 修改深拷贝不会影响原对象
deep[0].append(99)
print(f"修改后 original: {original}")  # [[1, 2], [3, 4]]，保持不变
print(f"修改后 deep: {deep}")          # [[1, 2, 99], [3, 4]]

# 不可变对象示例
a = 100
b = 100
c = 200
d = 200

print(f"id(a): {id(a)}, id(b): {id(b)}")
print(f"a is b: {a is b}")  # True（小整数缓存）
print(f"id(c): {id(c)}, id(d): {id(d)}")
print(f"c is d: {c is d}")  # False（大整数无缓存）

# 可变对象示例
list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = list1

print(f"\nid(list1): {id(list1)}")
print(f"id(list2): {id(list2)}")
print(f"id(list3): {id(list3)}")
print(f"list1 is list2: {list1 is list2}")  # False，内容相同但不是同一对象
print(f"list1 is list3: {list1 is list3}")  # True，指向同一对象

# 示例 1：不可变对象（小整数）
x = 256
y = 256
print(f"x == y: {x == y}")  # True，值相等
print(f"x is y: {x is y}")  # True，小整数缓存指向同一对象

# 示例 2：不可变对象（大整数）
a = 1000
b = 1000
print(f"\na == b: {a == b}")  # True，值相等
print(f"a is b: {a is b}")    # False，大整数无缓存，不同对象

# 示例 3：可变对象
list1 = [1, 2, 3]
list2 = [1, 2, 3]
list3 = list1

print(f"\nlist1 == list2: {list1 == list2}")  # True，内容相同
print(f"list1 is list2: {list1 is list2}")    # False，不同对象
print(f"list1 is list3: {list1 is list3}")    # True，同一对象

# 示例 4：特殊值
print(f"\nNone == None: {None == None}")      # True
print(f"None is None: {None is None}")        # True，None 是单例

print(f"True == 1: {True == 1}")              # True，值相等
print(f"True is 1: {True is 1}")              # False，不同类型