可变对象创建后可修改内容而不改变内存地址，如列表、字典；不可变对象一旦创建内容不可变，任何修改都会生成新对象，如整数、字符串、元组。
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 cacheprint(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 copydef 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 cacheprint(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]) # 列表，不可哈希，会抛出TypeErrorexcept TypeError as e: print(f"Error hashing list: {e}")try: hash({'a': 1}) # 字典，不可哈希，会抛出TypeErrorexcept TypeError as e: print(f"Error hashing dict: {e}")
需要注意的是，并非所有不可哈希的对象都是可变的（例如，自定义类实例默认是可变的，但你可以通过实现
__hash__
和
__eq__
使其变得可哈希），但对于Python的内置类型，这个规则是相当可靠的。
查阅官方文档：最权威、最准确的方法，当然是查阅Python的官方文档。文档会明确指出每种内置类型是可变的还是不可变的。
理解可变性与不可变性，不仅仅是掌握了Python的一个语言特性，更是深入理解Python内存管理、对象生命周期和程序行为的关键。它能帮助我们更好地设计数据结构，编写出更安全、更高效、更易于维护的代码。
以上就是可变对象与不可变对象在 Python 中的区别的详细内容，更多请关注创想鸟其它相关文章！
版权声明：本文内容由互联网用户自发贡献，该文观点仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。
如发现本站有涉嫌抄袭侵权/违法违规的内容， 请发送邮件至 chuangxiangniao@163.com 举报，一经查实，本站将立刻删除。
发布者：程序猿，转转请注明出处：https://www.chuangxiangniao.com/p/1369716.html
微信扫一扫 
支付宝扫一扫 
