Python-可变类型（mutable）和不可变类型（immutable）

本文链接：https://blog.youkuaiyun.com/wlei1825928/article/details/143112773

在 Python 中，数据被分为各种数据类型，数据类型也可以分为可变类型（mutable）和不可变类型（immutable）。这种分类主要是基于对象在创建后是否可以修改。了解这一点有助于编写高效和正确的代码。

不可变类型（Immutable Types）

不可变类型是指一旦创建，它们的值就不能再改变。常见的不可变类型包括：

数字类型（如 int, float, complex）
字符串（str）
元组（tuple）
冻结集合（frozenset）
布尔类型（bool）

示例

# 数字类型
a = 10
b = a
a += 5
print(a)  # 输出 15
print(b)  # 输出 10（b 的值保持不变）

# 字符串
s = "hello"
t = s
s += " world"
print(s)  # 输出 "hello world"
print(t)  # 输出 "hello"（t 的值保持不变）

# 元组
tuple_a = (1, 2, 3)
tuple_b = tuple_a
tuple_a += (4, 5)
print(tuple_a)  # 输出 (1, 2, 3, 4, 5)
print(tuple_b)  # 输出 (1, 2, 3)（tuple_b 的值保持不变）

注意：虽然值不能改变，但你可以创建新的对象并修改变量引用。

可变类型（Mutable Types）

可变类型是指对象创建后可以修改其值。常见的可变类型包括：

列表（list）
字典（dict）
集合（set）
用户自定义对象（自定义类实例）

示例

# 列表
list_a = [1, 2, 3]
list_b = list_a
list_a.append(4)
print(list_a)  # 输出 [1, 2, 3, 4]
print(list_b)  # 输出 [1, 2, 3, 4]（list_b 也被修改，因为它是对同一对象的引用）

# 字典
dict_a = {'a': 1, 'b': 2}
dict_b = dict_a
dict_a['c'] = 3
print(dict_a)  # 输出 {'a': 1, 'b': 2, 'c': 3}
print(dict_b)  # 输出 {'a': 1, 'b': 2, 'c': 3}（dict_b 也被修改）

# 集合
set_a = {1, 2, 3}
set_b = set_a
set_a.add(4)
print(set_a)  # 输出 {1, 2, 3, 4}
print(set_b)  # 输出 {1, 2, 3, 4}（set_b 也被修改）

内存和效率

不可变类型：由于不可变对象不能被修改，Python 可以对这些对象进行一些优化，例如缓存和共享。比如，所有值为 10 的整数变量都指向同一个内存地址。
可变类型：可变对象允许在原地修改，因此每个对象都有自己独立的内存空间。这在某些情况下可能影响效率，但也提供了更大的灵活性。

共享和复制

当一个可变对象被复制时，通常是浅复制（shallow copy），这意味着新变量只是引用同一个对象。如果你需要一个独立的副本，通常需要使用深复制（deep copy）。

浅复制和深复制

import copy

# 浅复制
original_list = [1, 2, [3, 4]]
shallow_copy = original_list.copy()
shallow_copy[2][0] = 'a'
print(original_list)  # 输出 [1, 2, ['a', 4]]（嵌套对象被修改）
print(shallow_copy)   # 输出 [1, 2, ['a', 4]]

# 深复制
original_list = [1, 2, [3, 4]]
deep_copy = copy.deepcopy(original_list)
deep_copy[2][0] = 'a'
print(original_list)  # 输出 [1, 2, [3, 4]]（原始对象不变）
print(deep_copy)      # 输出 [1, 2, ['a', 4]]

函数参数传递

Python 中的参数传递机制与数据类型的可变性密切相关：

不可变类型：以值传递的方式传递，即函数接收到的是值的副本，修改不会影响原值。
可变类型：以引用传递的方式传递，即函数接收到的是原对象的引用，修改会影响原对象。

示例

def modify_immutable(x):
    x += 1
    print(f"Inside function: {x}")

a = 10
modify_immutable(a)
print(f"Outside function: {a}")  # 输出 10，不变

def modify_mutable(lst):
    lst.append(4)
    print(f"Inside function: {lst}")

list_a = [1, 2, 3]
modify_mutable(list_a)
print(f"Outside function: {list_a}")  # 输出 [1, 2, 3, 4]，被修改