可变对象与不可变对象在 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

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

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

1. 明确意图：如果函数确实需要修改传入的可变对象，那就让这种意图非常明确，比如通过函数命名（

   update_config

   ）或文档字符串来告知使用者。

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

   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]

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

   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对象是可变还是不可变呢？这其实有几个方法可以尝试：

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

   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"

2. 使用

   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的内置类型，这个规则是相当可靠的。

3. 查阅官方文档：最权威、最准确的方法，当然是查阅Python的官方文档。文档会明确指出每种内置类型是可变的还是不可变的。

理解可变性与不可变性，不仅仅是掌握了Python的一个语言特性，更是深入理解Python内存管理、对象生命周期和程序行为的关键。它能帮助我们更好地设计数据结构，编写出更安全、更高效、更易于维护的代码。