对象引用、可变性和垃圾回收
变量不是盒子
变量不是盒子,而是便利贴,python是先创建对象然后再将变量赋值给对象,当创建对象之后,可以通过id
查看对象的内存地址。
例如:
class Gizmo:
def __init__(self):
print('Gizmo id: %d' % id(self))
if __name__ == '__main__':
x = Gizmo()
y = Gizmo() * 10
输出:
Gizmo id: 1561533021064
Gizmo id: 1561535251208
Traceback (most recent call last):
File "D:/learn/liuchangdepython/对象引用_可变性和垃圾回收/8_2.py", line 8, in <module>
y = Gizmo() * 10
TypeError: unsupported operand type(s) for *: 'Gizmo' and 'int'
分析:
控制台打印两个对象的id,当执行y = Gizmo() * 10
时,对象已经创建,但对象执行乘法操作时失败,无法将对象进行赋值。
标识、相等性和别名
标识:每一个变量都有标识、类型和值。对象一旦创建,它的标识绝不会变;你可以把标识理解为对象在内存中的地址。is
运算符比较两个对象的标识;id()
函数返回对象标识的整数标识。
在==和is之间选择
==运算符比较两个对象的值(对象中保存的数据),而is比较对象的标识
is运算符比速度快,因为它不能重载,所有Python不用寻找并调用特殊方法,而是直接比较两个整数ID。而ab是语法糖,等同于a.__eq__(b)
。继承自object的__eq__
方法比较对象的ID,结果与is一样。但是多数内置类型使用更有意义的方法覆盖了__eq__
方法,会考虑对象属性的值。
元组的相对不可变性
元组和多数Python集合(列表、字典、集合,等等)一样,保存的是对象的引用。如果引用的元素是可变的,即使元组本身不可变,元素依然可变。也就是说,元组的不可变性其实是指tuple数据结构的物理内容(即保存的引用)不可变,与引用的对象无关。
而str、bytes和array.array等单一类型序列是扁平的,它们保存的不是引用,而是在连续内存中保存对象本身(字符、字节和数字)
例子:
t1 = (1, 2, [30, 40])
t2 = (1, 2, [30, 40])
print(t1 == t2)
print(id(t1[-1]))
t1[-1].append(99)
print(t1)
print(id(t1[-1]))
print(t1 == t2)
输出:
True
2292492489288
(1, 2, [30, 40, 99])
2292492489288
False
分析:
元组本身是不可变类型,但它存放了一个是可变类型的元素(list),当修改了该元素的内容,但没有改变元素的标识(id)
元组的值会随着引用的可变对象的变化而变化。元素中不可变的是元素的标识
浅复制和深复制
复制列表(或多数内置的可变集合)最简单的方法是使用内置的类型构造方法。
l1 = [3, [66, 55, 44], (7, 8, 9)]
l2 = list(l1)
l1.append(100)
l1[1].remove(55)
print('l1', l1)
print('l2', l2)
l2[1] += [33, 12]
print("+=操作修改l2中列表")
print('l1', l1)
print('l2', l2)
l2[2] += (10, 11)
print("+=操作修改l2中的元组")
print('l1', l1)
print('l2', l2)
输出:
l1 [3, [66, 44], (7, 8, 9), 100]
l2 [3, [66, 44], (7, 8, 9)]
+=操作修改l2中列表
l1 [3, [66, 44, 33, 12], (7, 8, 9), 100]
l2 [3, [66, 44, 33, 12], (7, 8, 9)]
+=操作修改l2中的元组
l1 [3, [66, 44, 33, 12], (7, 8, 9), 100]
l2 [3, [66, 44, 33, 12], (7, 8, 9, 10, 11)]
分析:
浅复制是分享内部对象的引用。l2[1] += [33, 12]
修改了l1
和l2
中的list,证明l2
中的list是l1
中list的别名,
而l2[2] += (10, 11)
创建了一个新的元组,这样并没有修改l1
中的元组。
如果不想分享内部对象的引用可以使用copy.deepcopy(l1)
形参和实参
共享传参指函数的各个形式参数获得实参中各个引用的副本。 也就是说, 函数内部的形参
是实参的别名。
这种方案的结果是, 函数可能会修改作为参数传入的可变对象, 但是无法修改那些对象的
标识(即不能把一个对象替换成另一个对象)。
可变参数作为参数的问题
class HauntedBus:
"""备受幽灵乘客折磨的校车"""
def __init__(self, passengers=[]):
self.passengers = passengers
def pick(self, name):
self.passengers.append(name)
def drop(self, name):
self.passengers.remove(name)
if __name__ == '__main__':
bus2 = HauntedBus()
bus2.pick('Carrie')
print(bus2.passengers)
bus3 = HauntedBus()
print(bus3.passengers)
bus3.pick('Dave')
print(bus2.passengers)
print(bus2.passengers is bus3.passengers)
print(HauntedBus.__init__.__defaults__)
print(HauntedBus.__init__.__defaults__[0] is bus2.passengers)
输出:
['Carrie']
['Carrie', 'Dave']
True
(['Carrie', 'Dave'],)
True
分析:
通过上述可知,bus2.passengers
和bus3.passengers
是HauntedBus.__init__.__defaults__[0]
的别名,修改属性
self.passenger
会影响到其他对象,为了避免上述情况发生,需要防御可变参数,做如下修改:
def __init__(self, passengers=None):
if passengers is None:
self.passengers = []
else:
self.passengers = list(passengers)