对象引用、可变性和垃圾回收

对象引用、可变性和垃圾回收

变量不是盒子

变量不是盒子，而是便利贴，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)