可变对象与不可变对象在 Python 中的区别-Python教程-PHP中文网

可变对象创建后可修改内容而不改变内存地址，如列表、字典；不可变对象一旦创建内容不可变，任何修改都会生成新对象，如整数、字符串、元组。

可变对象与不可变对象在 python 中的区别

Python中的可变对象和不可变对象，核心区别在于对象创建后其内部状态是否可以被修改。简单来说，如果一个对象在内存中的值（或者说它引用的数据）可以在不改变其内存地址的情况下被改变，那它就是可变的；反之，如果一旦创建就无法修改，任何“修改”操作实际上都是创建了一个新对象，那它就是不可变的。理解这一点，对于写出健壮、高效的Python代码至关重要。

在Python的世界里，我们每天都在和各种对象打交道。这些对象，有些是“易容高手”，可以在原地变身，有些则是“一锤定型”，一旦诞生便无法更改。这种可变性（Mutability）和不可变性（Immutability）的区分，我觉得是Python设计哲学中一个非常精妙且实用的点。

当我们谈论可变对象，比如列表（list）、字典（dict）或集合（set），我的脑海里会浮现出这样一个场景：你有一个背包，里面可以随时添加、删除物品，或者把某个物品换成另一个，而背包本身还是那个背包。这意味着，即使背包里的东西变了，背包这个“实体”在内存中的位置（它的

id

登录后复制

）是不会变的。你可以对它进行

append()

登录后复制

、

pop()

登录后复制

、

update()

登录后复制

等操作，这些操作都是在原地修改对象。

而不可变对象，比如整数（int）、浮点数（float）、字符串（str）和元组（tuple），则更像是一张照片。照片一旦冲洗出来，上面的内容就固定了。如果你想“修改”照片，比如在上面加个边框，你实际上是制作了一张新照片，而不是改变了原有的那张。在Python中，当你对一个不可变对象进行“修改”操作时，比如字符串拼接，Python并不会在原字符串的基础上修改，而是会创建一个新的字符串对象，并将结果赋给变量（如果变量被重新赋值的话）。旧的字符串对象如果不再被引用，就会被垃圾回收。这种特性，在我看来，是Python在背后默默为我们做了很多内存管理和优化工作。

立即学习“Python免费学习笔记（深入）”；

Python中哪些是可变对象，哪些是不可变对象？为什么区分它们很重要？

在我日常的编码实践中，识别对象的类型是第一步。Python中常见的不可变对象包括：

数字类型：
```
int
```
登录后复制
,
```
float
```
登录后复制
,
```
complex
```
登录后复制
,
```
bool
```
登录后复制
。
字符串：
```
str
```
登录后复制
。
元组：
```
tuple
```
登录后复制
。
冻结集合：
```
frozenset
```
登录后复制
。
字节串：
```
bytes
```
登录后复制
。

而常见的可变对象则有：

列表：
```
list
```
登录后复制
。
字典：
```
dict
```
登录后复制
。
集合：
```
set
```
登录后复制
。
字节数组：
```
bytearray
```
登录后复制
。
自定义类的实例：通常情况下，如果你不特别处理，自定义类的实例是可变的，因为它们的属性可以被修改。

为什么要区分它们呢？我觉得这不仅仅是理论知识，更是编写健壮、可预测代码的关键。首先，安全性与可预测性。不可变对象一旦创建就不能改变，这意味着它们是“线程安全”的（至少在数据本身层面），并且在多处引用时，你不用担心某个地方的修改会意外影响到其他地方。这大大降低了程序中出现难以追踪的副作用（side effect）的风险。对于可变对象，如果多个变量引用了同一个可变对象，通过其中任何一个变量对对象进行的修改都会反映到所有引用上，这可能导致一些意想不到的行为。

其次，作为字典的键和集合的元素。这是非常实际的一个应用场景。Python要求字典的键和集合的元素必须是可哈希（hashable）的。可哈希的对象必须是不可变的，因为它们的哈希值在生命周期内必须保持不变。如果可变对象（比如列表）可以作为键，那么当列表内容改变时，它的哈希值也会变，这会导致字典无法找到对应的键值对，或者集合无法正确判断元素是否存在。所以，你不能用列表作为字典的键，但可以用元组。

再者，函数参数传递的语义。Python的参数传递是“传对象引用”（pass by object reference）。当一个可变对象作为参数传入函数时，函数内部对这个对象的修改会直接影响到函数外部的原始对象。而传入不可变对象时，函数内部虽然可以对变量进行重新赋值，但这只是让函数内部的局部变量指向了一个新的对象，并不会影响到函数外部的原始对象。理解这一点，能帮助我们避免很多潜在的bug。

可变对象作为函数参数传递时有哪些坑？如何规避？

这是我遇到过很多初学者，甚至是一些有经验的开发者都会踩的坑。当我们将一个可变对象（比如列表或字典）作为函数参数传递时，函数内部对这个对象的任何修改，都会直接影响到函数外部的原始对象。

举个例子：

def add_item_to_list(my_list, item):
    my_list.append(item)
    print(f"Inside function: {my_list}")

my_data = [1, 2, 3]
add_item_to_list(my_data, 4)
print(f"Outside function: {my_data}")
# 预期输出：
# Inside function: [1, 2, 3, 4]
# Outside function: [1, 2, 3, 4]

登录后复制

可以看到，

my_data

登录后复制

在函数外部也被修改了。这在某些情况下可能是你想要的行为，比如一个函数专门负责更新某个共享配置字典。但更多时候，这种“副作用”会让人头疼，因为它打破了函数的封装性，使得函数变得不那么纯粹和可预测。

更隐蔽的坑是默认参数：

标书对比王

标书对比王是一款标书查重工具，支持多份投标文件两两相互比对，重复内容高亮标记，可快速定位重复内容原文所在位置，并可导出比对报告。

查看详情

def process_data(data, cache=[]): # 这里的cache是可变对象
    cache.append(data)
    print(f"Current cache: {cache}")
    return cache

print(process_data(1)) # Current cache: [1]
print(process_data(2)) # Current cache: [1, 2]
print(process_data(3)) # Current cache: [1, 2, 3]

登录后复制

这里的

cache

登录后复制

列表作为默认参数，只在函数定义时被创建一次。每次调用

process_data

登录后复制

且不传入

cache

登录后复制

时，都会使用同一个列表实例。这显然不是我们通常期望的“每次调用都用一个空的缓存”的行为。

那么，如何规避这些坑呢？

明确意图：如果函数确实需要修改传入的可变对象，那就让这种意图非常明确，比如通过函数命名（
```
update_config
```
登录后复制
）或文档字符串来告知使用者。

创建副本：如果函数不应该修改原始对象，那么在函数内部对可变对象进行操作之前，先创建一个副本。对于列表，可以使用切片

my_list[:]

登录后复制

或

list(my_list)

登录后复制

；对于字典，可以使用

my_dict.copy()

登录后复制

或

dict(my_dict)

登录后复制

。对于包含可变对象的嵌套结构，可能需要使用

copy.deepcopy()

登录后复制

。

import copy

def add_item_to_list_safe(my_list, item):
    temp_list = list(my_list) # 创建一个副本
    temp_list.append(item)
    print(f"Inside function (modified copy): {temp_list}")
    return temp_list # 返回修改后的副本

my_data = [1, 2, 3]
new_data = add_item_to_list_safe(my_data, 4)
print(f"Outside function (original): {my_data}") # [1, 2, 3]
print(f"Outside function (new): {new_data}") # [1, 2, 3, 4]

登录后复制

正确使用默认参数：避免使用可变对象作为函数的默认参数。正确的做法是使用

None

登录后复制

作为默认值，然后在函数内部检查并创建新的可变对象。

def process_data_fixed(data, cache=None):
    if cache is None:
        cache = [] # 每次调用都会创建一个新的空列表
    cache.append(data)
    print(f"Current cache: {cache}")
    return cache

print(process_data_fixed(1)) # Current cache: [1]
print(process_data_fixed(2)) # Current cache: [2]
print(process_data_fixed(3)) # Current cache: [3]

登录后复制

不可变对象在Python设计哲学中扮演了什么角色？如何判断一个Python对象是可变还是不可变？

不可变对象在Python的设计哲学中扮演着一个非常重要的角色，我觉得它体现了Python对清晰性、可预测性和稳健性的追求。虽然Python不是一个纯粹的函数式编程语言，但不可变对象的存在，无疑为我们提供了编写更接近函数式风格代码的可能性。这使得函数更容易理解和测试，因为它们不会产生意外的副作用。在某些场景下，比如哈希表的实现（字典键、集合元素），不可变性更是其工作原理的基石。此外，不可变对象可以更容易地被缓存和共享，这对于性能优化也有潜在的好处。

那么，如何判断一个Python对象是可变还是不可变呢？这其实有几个方法可以尝试：

尝试原地修改：这是最直观的方法。如果你能找到一个方法（比如

append()

登录后复制

、

extend()

登录后复制

、

__setitem__

登录后复制

等）在不改变对象

id()

登录后复制

的情况下修改其内容，那么它就是可变的。如果所有“修改”操作都返回了一个新对象，而原始对象的

id()

登录后复制

和内容都没有变，那么它就是不可变的。

my_list = [1, 2]
print(f"List ID before: {id(my_list)}")
my_list.append(3) # 原地修改
print(f"List ID after append: {id(my_list)}") # ID不变
print(f"List content: {my_list}") # [1, 2, 3]

my_string = "hello"
print(f"String ID before: {id(my_string)}")
my_string += " world" # 实际上是创建了新字符串
print(f"String ID after concat: {id(my_string)}") # ID改变了
print(f"String content: {my_string}") # "hello world"

登录后复制

使用
```
hash()
```
登录后复制
函数：如果一个对象是可哈希的（hashable），那么它通常是不可变的。因为可哈希意味着它的哈希值在生命周期内是固定的，而只有不可变对象才能保证这一点。你可以尝试对对象调用内置的
```
hash()
```
登录后复制
函数。如果成功返回一个整数，那么它就是可哈希的，也基本可以认为是不可变的。如果抛出
```
TypeError
```
登录后复制
，那么它就是不可哈希的，通常是可变对象。
```
print(hash(10))        # 整数，可哈希
print(hash("python"))  # 字符串，可哈希
print(hash((1, 2)))    # 元组，可哈希

try:
    hash([1, 2])       # 列表，不可哈希，会抛出TypeError
except TypeError as e:
    print(f"Error hashing list: {e}")

try:
    hash({'a': 1})     # 字典，不可哈希，会抛出TypeError
except TypeError as e:
    print(f"Error hashing dict: {e}")
```
登录后复制
需要注意的是，并非所有不可哈希的对象都是可变的（例如，自定义类实例默认是可变的，但你可以通过实现
```
__hash__
```
登录后复制
和
```
__eq__
```
登录后复制
使其变得可哈希），但对于Python的内置类型，这个规则是相当可靠的。
查阅官方文档：最权威、最准确的方法，当然是查阅Python的官方文档。文档会明确指出每种内置类型是可变的还是不可变的。