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

文章目录

1. 变量是标签
2. 元组的相对不可变性
3. 默认浅复制
4. 函数的参数作为引用时
5. del 和垃圾回收
6. 弱引用
7. 一些可能的坑！！！

learn from 《流畅的python》

1. 变量是标签

>>> a = [1, 2, 3]
>>> b = a
>>> a.append(4)
>>> b
[1, 2, 3, 4]

对象的 id 在生命周期中是不变的
is 运算检查两者的 id 是否一致
== 检查两者内容（值）是否一样
is 运算符比 == 速度快，因为它不能重载，不用寻找并调用特殊方法

2. 元组的相对不可变性

元组的不可变性其实是指 tuple 数据结构的 物理内容（即保存的引用）不可变，与引用的对象无关

>>> t1 = (1, 2, [30, 40])
>>> t2 = (1, 2, [30, 40])
>>> t1 is t2
False
>>> t1 == t2
True
>>> id(t1[-1])
2633996005896
>>> t1[-1].append(100)
>>> t1
(1, 2, [30, 40, 100])
>>> id(t1[-1])
2633996005896
>>> t1 == t2
False

如果元组内部有 可变对象，那么元组就 不可散列了

3. 默认浅复制

>>> l1 = [3, [55, 44], (7, 8, 9)]
>>> l2 = list(l1) # 创建副本 或者 [:] ，浅复制
>>> l2
[3, [55, 44], (7, 8, 9)]
>>> l1 == l2
True
>>> l1 is l2
False

构造方法或 [:] 做的是浅复制（即复制了最外层容器，副本中的元素是源容器中元素的引用）。
如果所有元素都是不可变的，那么这样没有问题，还能节省内存。
但是，如果有可变的元素，可能就会导致 意想不到的问题。

>>> l1 = [3, [66, 55, 44], (7, 8, 9)]
>>> l2 = list(l1)  # 两者共享内部的 list tuple
>>> l1.append(100)
>>> l1[1].remove(55)
>>> print('l1:', l1)
l1: [3, [66, 44], (7, 8, 9), 100]
>>> print('l2:', l2)
l2: [3, [66, 44], (7, 8, 9)]
>>> l2[1] += [33, 22]   # list 变更，反映到 l1
>>> l2[2] += (10, 11)  # tuple 不可变，+= 生成新的 tuple ，不反映到 l1
>>> print('l1:', l1)
l1: [3, [66, 44, 33, 22], (7, 8, 9), 100]
>>> print('l2:', l2)
l2: [3, [66, 44, 33, 22], (7, 8, 9, 10, 11)]

copy 模块的 deepcopy()，copy() 实现深复制，浅复制

4. 函数的参数作为引用时

可变对象经过函数修改会传递出来（如果不希望修改原来的，可以创建副本）
不可变对象操作后，会生成新的对象
不要用可变对象作为函数默认值，如 def func(a = [])

>>> def func(a=[]):
...     a.append(5)
...     print(a)
...
>>> func()
[5]
>>> func()
[5, 5]
>>> func()
[5, 5, 5]

修改了可变的默认值，后续调用都会受到影响

5. del 和垃圾回收

del 语句删除名称，而不是对象
del 命令可能会导致对象被当作垃圾回收，但是仅当删除的变量保存的是对象的最后一个引用，或者无法得到对象时

6. 弱引用

正是因为有引用，对象才会在内存中存在。

当对象的引用数量归零后，垃圾回收程序会把对象销毁。

但是，有时需要引用对象，而不让对象 存在的时间超过所需时间。这经常用在缓存中。

弱引用不会增加对象的引用数量。
引用的目标对象称为所指对象（referent）。弱引用 不会妨碍 所指对象被当作垃圾回收。
弱引用在缓存应用中很有用，因为我们不想仅因为被缓存引用着而始终保存缓存对象

7. 一些可能的坑！！！

>>> a = None
>>> b = None
>>> a is b
True
>>> id(a)
140712131987472
>>> id(b)
140712131987472
>>> a = [1,2]
>>> b = [1,2]
>>> a is b
False
>>> a = (1,2)  # list , tuple 相同字面量，id 不同
>>> b = (1,2)
>>> a is b
False
>>> a = "haha"  # 相同的字面量字符串，id 一样！！
>>> b = "haha"
>>> a is b
True
>>> a = 5
>>> b = 5
>>> a is b
True

>>> a, b = 0 , 0
>>> a is b
True
>>> a = 5
>>> a
5
>>> b
0
>>> a = "ha"
>>> b = "ha"
>>> a is b
True
>>> a = "good"  # 但是也无须担心。。
>>> a
'good'
>>> b
'ha'

>>> a = [1,2]
>>> b = a[:]
>>> b
[1, 2]
>>> a is b
False
>>> a = (1,2)
>>> b = a[:]  # 不创建新的副本，而list会创建新的副本
>>> b
(1, 2)
>>> a is b
True
>>> b = tuple(a) # 不创建新的副本，而list会创建新的副本
>>> a is b
True

>>> a = [1,2]
>>> b = list(a) # list 创建副本
>>> b
[1, 2]
>>> a is b
False