python 学习笔记二（对象引用、可变性和垃圾回收）

===========小结=================

# 简单的赋值不创建副本。

# 对 += 或 *= 所做的增量赋值来说，如果左边的变量绑定的是不可变对象，会创建新对象；如果是可变对象，会就地修改。

# 为现有的变量赋予新值，不会修改之前绑定的变量。这叫重新绑定：现在变量绑定了其他对象。如果变量是之前那个对象的最后一个引用，对象会被当作垃圾回收。

# 函数/类 的参数以别名的形式传递，这意味着，函数可能会修改通过参数传入的可变对象。这一行为无法避免，除非在本地创建副本，或者使用不可变对象（例如，传入元组，而不传入列表）。

# 使用可变类型作为 函数/类 参数的默认值有危险，因为如果就地修改了参数，默认值也就变了，这会影响以后使用默认值的调用。

=================================

 

** 变量是一个引用，示例如下

 

 ==========可变性===============

**每个变量都有标识、类型和值。对象一旦创建，它的标识绝不会变；你可以把标识理解为对象在内存中的地址。is 运算符比较两个对象的标识；id() 函数返回对象标识的整数表示。

** == 运算符比较两个对象的值（对象中保存的数据），而 is 比较对象的标识。

** 在变量和单例值之间比较时，应该使用 is。目前，最常使用 is检查变量绑定的值是不是 None

 ** is 运算符比 == 速度快，因为它不能重载，所以 Python 不用寻找并调用特殊方法，而是直接比较两个整数 ID。

** 元组的相对不可变性：元组与多数 Python 集合（列表、字典、集，等等）一样，保存的是对象的引用。

　　==>如果引用的元素是可变的，即便元组本身不可变，元素依然可变。也就是说，元组的不可变性其实是指 tuple 数据结构的物理内容（即保存的引用）不可变，与引用的对象无关

　　==> str、bytes 和 array.array 等单一类型序列是扁平的，它们保存的不是引用，而是在连续的内存中保存数据本身（字符、字节和数字）。

 **list：默认用浅复制，==> 不要使用可变类型作为参数的默认值，否则可能引发意想不到的bug，通常使用 None 作为接收可变值的参数的默认值

-----》类/函数 传入可变参数应将可变参数副本传入， 即使用list()或切片方式

list相关示例：

# 引用
a = [0,0,2,3,4,5]
b = a
b.append("c")
print(a)
print(b)

# 浅复制
aa = [0, 0, 2, 3, 4, 5]
bb = list(aa)
bb.append("c")
print(aa)
print(bb)

# 浅复制
aaa = [0, 0, 2, 3, 4, 5]
bbb = aaa[:]
bbb.append("c")
print(aaa)
print(bbb)

# 浅复制
import copy
aaaa = [0, 0, 2, 3, 4, 5]
bbbb = copy.copy(aaaa)
bbbb.append("c")
print(aaaa)
print(bbbb)


# 深复制, 内部存储对象重开存储空间，内存消耗大
# 若是list中确定是不可变内容，则应用浅复制
import copy
aaaaa = [0, 0, 2, 3, 4, 5]
bbbbb = copy.deepcopy(aaaaa)
bbbbb.append("c")
print(aaaaa)
print(bbbbb)

结果如下：==》

 

---------------------------------------

对元组 t 来说，t[:] 不创建副本，而是返回同一个对象的引用。此外，tuple(t) 获得的也是同一个元组的引用。

 

 str、bytes 和 frozenset 实例也有这种行为

 

==============垃圾回收============

正是因为有引用，对象才会在内存中存在。当对象的引用数量归零后，垃圾回收程序会把对象销毁。但是，有时需要引用对象，而不让对象存在的时间超过所需时间。这经常用在缓存中