深入解析Python可变与不可变对象：内存机制与实战案例
本文深入解析Python中可变与不可变对象的内存管理机制。通过对比int、str、tuple与list、dict、set的内存分配差异，阐明is与==的区别、引用传递原理及原地修改行为。结合代码示例，详细讲解函数传参、列表切片拷贝及+=运算符在可变与不可变类型中的不同表现，帮助开发者避免常见的内存引用陷阱。
可变对象与不可变对象的概念辨析
所谓不可变对象，是指该对象在内存中存储的值无法被修改。当对变量进行重新赋值时，由于原值不可更改，系统会复制原值并创建一个新的内存地址，变量随后指向这个新地址。
可变对象则允许直接修改其内存中的值。当修改变量时，实际上是在原内存地址上直接更改数据，不涉及复制行为，也不开辟新的内存空间，即所谓的“原地修改”。
在Python中，数值类型（包括int和float）、字符串（str）以及元组（tuple）均属于不可变类型。相反，列表（list）、字典（dict）和集合（set）则属于可变类型。
通过代码示例可以直观地理解这一概念，首先观察不可变对象的行为。
不可变对象的具体示例分析
需要明确的是，is运算符用于判断两个对象的内存ID是否相同，而==运算符用于判断两个对象的内容是否相等。
a = 2 b = 2 c = a + 0 c += 0 print(id(a), id(b), id(2)) # id都相同 print(c is b) #True
接下来观察字符串类型的表现。
astr = 'good'
bstr = 'good'
cstr = astr + ''
print(cstr is bstr) # True
print(id(astr), id(bstr), id('good')) # 三个id相同
其结果与数值类型一致。但如果变量发生修改，情况将有所不同。
astr = 'good' print(id(astr)) astr += 'aa' print(id(astr)) # id和上面的不一样
由于字符串是不可变对象，其对应的内存值不允许直接更改。当变量尝试修改时，系统实际上是将原值复制一份后生成新值，并开辟新的内存地址，变量指向该新地址（因此修改前后的ID不同）。原字符串因失去引用而被垃圾回收机制处理。这一机制同样适用于int和float类型。
随后观察元组（tuple）的情况。
add = (1, 2, 3) aee = (1, 2, 3) print(id(add), id(aee), id((1, 2, 3))) # id各不相同 aee = (1, 2, 3) print(id(aee)) aee += () # 加空元组 print(id(aee)) # id变了！ print(aee) #（1 ，2，3）
虽然显示为(1, 2, 3)，看似与前述情况一致，但这是否意味着它是可变对象？需进一步验证。
add = (1, 2, 3) aee = add print(id(aee), id(add)) # 这两个id一样 aee += (4, 5, 6) print(id(aee)) # aee的id变了！ print(add) # add还是(1, 2, 3)没有变
结果再次与数值类型和字符串类型保持一致。如果aee和add指向同一地址（ID相同），这仅是同一对象的不同引用吗？并非如此。如果是同一对象的不同引用，修改aee应导致add同步变化，但在元组中并非如此。因此，元组是不可变对象，但与str和数值类型略有区别。通常所说的“元组不可变”是指其内部存放的值不能被直接修改（特殊情况如元组内包含列表时，可修改列表元素，但元组本身的引用并未改变）。
对于str、int和float，只要类型相同且值相同，它们的ID通常相同（强调类型相同的原因如下）。
a = 2.0 b = 2 print(a is b) # False, 一个int一个float，类型都不同
例如，2和2.0位于不同的内存地址。
可变对象的具体示例分析
lis = [1, 2, 3] lis2 = [1, 2, 3] # 虽然它们的内容一样，但是它们指向的是不同的内存地址 print(lis is lis2) print(id(lis), id(lis2), id([1, 2, 3])) # 三个id都不同
在赋值操作下的表现。
alist = [1, 2, 3] # alist实际上是对对象的引用，blist = alist即引用的传递，现在两个引用都指向了同一个对象（地址） blist = alist print(id(alist), id(blist)) # id一样 # 所以其中一个变化，会影响到另外一个 blist.append(4) print(alist) # 改变blist, alist也变成了[1 ,2 ,3 4] print(id(alist), id(blist)) # id一样，和上面值没有改变时候的id也一样
执行blist = alist时，alist作为对象的引用被传递给blist，此时两个引用指向同一个对象（内存地址）。因此，对其中一个对象的修改会影响另一个对象。
接着观察集合（set）的情况。
abb = {1, 2, 3}
acc = abb
print(id(abb), id(acc))
acc.add(4)
print(abb) # {1, 2, 3, 4}
print(id(abb), id(acc)) # 相等
其表现与列表示例一致。
由于可变对象允许直接修改所指对象，因此无需复制即可原地修改，不会开辟新的内存空间，修改前后的ID保持不变。
不可变对象则遵循不同的逻辑，可与此进行对比。
abc = 3 dd = abc dd = 43 print(abc) # 3，并不随dd的改变而改变
然而，如果是执行拷贝操作，则仅复制内容而不传递引用。这在需要获取列表值但不希望修改原列表的场景中非常有用。
blist = alist[:] # or alist.copy() print(alist is blist) # False blist.append(4) print(alist) # 还是[1，2 ，3]没有变化
作为函数参数时的行为。
在函数传参时，规则相同：可变类型传递的是引用，不可变类型传递的是值（内容）。
test_list = [1, 2, 3, 4] test_str = 'HAHA' def change(alist): alist.append(5) def not_change(astr): astr.lower() change(test_list) not_change(test_str) print(test_list) # 改变了原来的值 print(test_str) # 没有变
当然，若不希望改变原列表的值，可以在传入参数时使用列表的切片拷贝，例如alist[:]。
一个有趣的边界案例。
再看一个有趣的现象，我们知道列表可以使用+号添加元素。
a1 = [1, 2, 3] a2 = a1 print(id(a1), id(a2)) # 实际上是a2指向了新的对象，id已经改变。 # 所以现在a2、a1并不是同一对象的两个引用了，a2变化a1不会改变 a2 = a2 + [4] # 这个等式中，右边的a2还是和a1的id一样的，一旦赋值成功，a2就指向新的对象 print(id(1), id(a2)) # 不等，a2的id变化了 print(a1) # [1, 2, 3]没有变
如果采用以下写法：
a1 = [1, 2, 3] a2 = a1 print(id(a1), id(a2)) a2 += [4] # 相当于调用了a2.extend([4]),原地改变并没有新的对象产生 print(id(1), id(a2)) # 相等，a2的id没有变化 print(a1)
关键区别在于a2 += [4]，该语句相当于调用a2.extend([4])，属于原地修改操作，并未产生新的对象。
以上关于Python中可变与不可变对象的解析即为全部内容，希望能为读者提供参考，并欢迎大家支持本站。
本站声明
本文内容仅供参考，不代表本站观点。转载或引用请注明出处。如发现内容问题，请通过联系我们页面反馈。
