读书笔记:《流畅的Python》第8章 对象引用、可变性、垃圾回收

# 第八章 对象引用、可变性、垃圾回收

"""
对象名称和对象有区别：
    变量是标注，而不是盒子
内容提要：
    1.对象标识、值、别名
    2.元组是不可变的，但其中的值可以改变
    3.深浅复制
    4.引用和函数参数
        可变的默认值参数引起的问题
        如何安全地处理函数的调用者传入的可变参数
    5.垃圾回收
        del命令
        使用弱引用记住对象，而无需对象本身存在
"""

# 8.1变量不是盒子
"""Python中的变量类似于Java中的引用式变量
最好把他们理解为附加在对象上的标注
所以可以给一个对象贴上多个标注,这些标注,就是别名"""

# 例 8-1 变量a,b引用同一个列表,而不是列表的副本
"""a = [1,2,3]
b = a
a.append(4)
print(a)  # [1, 2, 3, 4]
print(b)  # [1, 2, 3, 4]"""

# 例 8-2 创建对象之后,才会把变量分配给对象
"""class Gizmo:
    def __init__(self):
        print('Gizmo id:%d'%id(self))
x = Gizmo()  # Gizmo id:1585308311504
# y = Gizmo()*10  # *之前会创建一个Gizmo对象
print(dir()) """

# 8.2标识/相等性/别名
"""
每个变量都有标识/类型/值
对象一旦创建,它的标识就不会改变,可以把标识理解为对象在内存中的地址
is运算符比较的是对象的标识
id()函数返回对象标识的整数表示
"""

# 例 8-3 charles 和 lewis指代同一个对象
"""charles = {'name' : 'charles L.Dodgson','born':1832}
lewis = charles  # lewis就是一个别名
print(charles is lewis) # True
print(id(lewis), id(charles))  # 2100165622272 2100165622272
lewis['balance'] = 950
print(charles)  # {'name': 'charles L.Dodgson', 'born': 1832, 'balance': 950}

# 例 8-4 alex 与charles 比较的结果相等,但是alex不是charles
alex = {'name': 'charles L.Dodgson', 'born': 1832, 'balance': 950}  # 内容一样
print(alex == charles)  # True
print(alex is not charles)  # True"""

# 8.2.1 == 和 is 的区别
"""
== 比较两个对象的值
is 比较两个对象的标识
最常使用is检查变量绑定的值是不是None
    x is None
    x is not None
    """

"""a = 1
b = a
print(a is b)
b = 1
print(a is b)  # 注意此处a,b是同一个对象 是因为python对-5 ~ 255?的整数所做的优化 不新建对象
print(a == b)

c = 2000
d = 2000
print(c is d) #pycharm True  但Terminal python3.9 结果是False  还有一些简单字符串也有这个特性
"""

# 8.2.2元组的相对不可变性
"""
元组和多数python集合(列表.字典.集合等等)一样
    保存的是对象的引用
str/bytes/array.array等扁平序列
    保存的是数据本身

如果元组引用的元素是可变的,即便元组本身不可变,元素依然可变
"""

# 例 8-5 元组的值会随着引用的可变对象的变化而改变,元组中不可变的是对象的标识
"""t1 = (1,2,[30,40])
t2 = (1,2,[30,40])
print(t1 is t2)  # False
print(t1 == t2)  # True
print(id(t1[-1]))  # 2464676277312
t1[-1].append(99)
print(t1)
print(id(t1[-1]))  # 2761212980288
print(t1 == t2)  # False"""

# 8.3 默认做浅复制
# 使用内置的类型构造方法浅复制
# l1 = [3,[55,44],(7,8,9)]
# l2 = list(l1)
# print(l2)
# print(l2 == l1)
# print(l2 is l1)
"""
>>>[3, [55, 44], (7, 8, 9)]
>>>True
>>>False"""

# 还可以使用[:]来做浅复制

# 例 8-6 为一个包含另一个列表的列表做浅复制
"""l1 = [3,[55,44],(7,8,9)]
l2 = list(l1)
l1.append(100)
l1[1].remove(55)
print('l1:',l1)
print('l2:',l2)
l2[1] += [33,22]
l2[2] += (10,11)
print('l1:',l1)
print('l2:',l2)"""

# 例8-8校车乘客在途中上车下车
"""class Bus:
    def __init__(self,passengers = None):
        if passengers is None:
            self.passengers = []
        else:
            self.passengers = list(passengers)
    def pick(self,name):
        self.passengers.append(name)
    def drop(self,name):
        self.passengers.remove(name)
if __name__ == '__main__':
    import copy
    bus1 = Bus(['Alice','Bill','Claire','David'])
    bus2 = copy.copy(bus1)
    bus3 = copy.deepcopy(bus1)
    print(id(bus1), id(bus2), id(bus3),sep='\n')
    bus1.drop('Bill')
    print(bus2.passengers)
    print(id(bus1.passengers))
    print(id(bus2.passengers))
    print(id(bus3.passengers))
    print(bus3.passengers)"""

"""
1583367671760
1583367671568
1583367670608
['Alice', 'Claire', 'David']
1583367678080
1583367678080
1583367657856
['Alice', 'Bill', 'Claire', 'David']
bus2 和 bus1 的passengers是同一个对象
但是bus3是作的深复制,所以不受影响"""

# 例8-10 循环引用
"""a = [10,20]
b = [a,30]
a.append(b)
print(a)
# >>>[10, 20, [[...], 30]]

from copy import deepcopy
c = deepcopy(a)
print(c)
"""

# 8.4函数的参数作为引用时
"""
Python的参数传递方式:共享传参(call by sharing)
    共享传参:函数的各个形式参数获得实参中各个引用的副本
            也就是说,函数内部的形参是实参的别名
            结果是函数可能会修改作为参数传入的可变对象
"""
# 例 8-11 函数可能会修改接收到的任何可变对象
"""def f(a,b):
    a += b
    return a

x = 1
y = 2
print(f(x,y))  # 3
print(x,y)  # 1 2

a = [1,2]
b = [3,4]
print(f(a,b))  # [1, 2, 3, 4]
print(a,b) # [1, 2, 3, 4] [3, 4]  a被修改了

t = (10,20)
u = (30,40)
print(f(t,u))  # (10, 20, 30, 40)
print(t,u)  # (10, 20) (30, 40)
"""

# 8.4.1不要使用可变类型作为参数的默认值
"""class HaunteBus:
    '''备受幽林折磨的校车'''
    def __init__(self,passengers = []):  # 如果没有传入passengers参数,使用默认绑定的列表对象
        self.passengers = passengers  # self.passengers是passengers的一个别名
    def pick(self,name):
        self.passengers.append(name)
    def drop(self,name):
        self.passengers.remove(name)

bus1 = HaunteBus(['Alice','Bill'])
print(bus1.passengers)
bus1.pick('Charles')
bus1.drop('Alice')
print(bus1.passengers)

bus2 = HaunteBus()
bus2.pick('Carrie')
print(bus2.passengers)

bus3 = HaunteBus()
print(bus3.passengers)  # ['Carrie']
bus3.pick('Dave')
print(bus2.passengers)  # ['Carrie', 'Dave']

print(bus2.passengers is bus3.passengers)  # True
print(bus1.passengers)

print(dir(HaunteBus.__init__))
print(dir(HaunteBus.__init__.__defaults__))
"""

# 8.4.2 防御可变参数

# 例 8-14,8-15
"""class TwilightBus:
    def __init__(self, passengers=None):
        if passengers is None:
            self.passengers = []
        else:
            self.passengers = passengers  # 此处把self.passengers变成passengers的一个别名

    def pick(self, name):
        self.passengers.append(name)
    def drop(self, name):
        self.passengers.remove(name)
# 从TwilightBus下车后乘客消失了

basketball_team = ['Sue','Tina','Maya','Diana','Pat']
bus = TwilightBus(basketball_team)
bus.drop('Sue')
bus.drop('Pat')
print(basketball_team)  # ['Tina', 'Maya', 'Diana']basketball_team被修改了

# TwilightBus违反了设计接口的最佳实践,"最小惊讶原则"
# 解决的方法是 校车维护自己的乘客列表 self.passengers = list(passengers)
"""

# 8.5 del和垃圾回收
"""
del语句删除名称,而不是对象
当删除的变量保存的是对象的最后一个引用或者无法得到对象时,对象会被当做垃圾回收
重新绑定也可能导致对象的引用数量归零导致对象被销毁
cpython中垃圾回收算法:引用计数"""

# 例 8-16没有指向对象的引用时,监视对象生命结束的情形
"""import weakref
s1= {1,2,3}
s2 = s1
def bye(): # 这个函数一定不能是被销毁对象的绑定方法,否则会有一个指向对象的引用
    print('Gone  with the wind...')
ender = weakref.finalize(s1,bye)  # 调用finalize前,.alive属性为True
print(ender.alive)
del s1  # 删除对对象的引用
print(ender.alive)
s2 = 'spam'  # 重新绑定s2,让{1,2,3}无法获取,对象被销毁,调用bye回调.ender.alive结果为False
print(ender.alive)
"""

# 8.6 弱引用
"""
正是因为有引用,对象才会在内存中存在
但是有时需要引用对象,而不让对象存在的时间超过所需时间,这经常用在缓存中
弱引用不会增加对象的引用数量
引用的目标对象称为所指对象
弱引用不会妨碍所指对象被当做垃圾回收
"""

# 例8-17 弱引用是可调用的对象,返回被引用的对象,如果所指对象不存在了,返回None
"""import weakref
a_set = {0,1}
wref = weakref.ref(a_set) # 创建弱引用对象
print(wref)  # <weakref at 0x0000019575AD9E00; to 'set' at 0x0000019575B362E0>

print(wref())  # {0, 1}

a_set = {2,3,4}
print(wref()) # None"""

# 8.6.1 WeakValueDictionary简介
"""WeakValueDictionary类实现的是一种可变的映射,里面的值是对象的弱引用
被引用的对象在其他地方被当做垃圾回收以后,对应的键会自动从WeakValueDictionary中删除
WeakValueDictionary经常用于缓存"""
# weakreference.py

# 8.6.2弱引用的局限
"""
1.不是每个python对象都可以作为弱引用的目标
    基本的list和dict实例不能作为所指对象
    但是他们的子类可以轻松地解决这个问题
2.set实例可以作为所指对象
3.int和tuple实例不能作为所指对象,甚至他们的子类也不行"""

import weakref
class Mylist(list):
    '''list的子类,实例可以作为弱引用的对象'''
a_list = Mylist(range(10))
# a_list可以作为弱引用的目标
wref_to_a_list = weakref.ref(a_list)

# 8.7 Python对不可变类型施加的把戏
# 对于元组t来说,t[:]和tuple(t)返回的都是同一个元组的引用
# 例 8-20 使用另一个元组构建元组,得到的其实是同一个元组

"""t1 = (1,2,3)
t2 = tuple(t1)
print(t2 is t1)  # True
t3 = t1[:]
print(t3 is t1)  # True"""

# str/byets/frozenset实例也有这种行为
# 例 8-21 字符串字面量可能会创建共享对象
t1 = (1,2,3)
t3 = (1,2,3)
print(t1 is t3)  # pycharm True
s1 = 'abc'
s2 = 'abc'
print(s1 is s2)  # True

# 这是cpython的优化措施,称为'驻留',这种情况也适用于一些整数,有的地方也称为'小数锯池'.主要是为了节省内存

# 本章小结
"""1.对象都有标识/类型/值,只有对象的值会不时变化
2.变量保存的是引用
3.简单的赋值,不创建副本
    对于+=,*=等增量赋值来说,如果左边的变量绑定的是不可变对象,会创建新对象
    否则,会就地修改
4.函数的参数是以别名的形式传递
    使用可变类型作为函数参数的默认值有危险
5.del 只删除引用,而不真正销毁对象,对象只有引用为0时才会被垃圾回收
6.弱引用"""

weakreference.py

# 若引用模块weakref的应用

# 实现一个简单的类,表示各种奶酪
# 例8-18 cheese有个kind属性和标准的字符串表示形式
class Cheese:
    def __init__(self,kind):
        self.kind = kind

    def __repr__(self):
        return 'Cheese(%r)'%self.kind

"""
在catalog中的各种奶酪载入WeakValueDictionary实现的栈stock中
删除catalog后,stock中只剩下一种奶酪了"""

# 例 8-19 顾客:你们店里到底有没有奶酪
import weakref
stock = weakref.WeakValueDictionary()
catalog = [Cheese('Red Leicester'),Cheese('Tilsit'),
           Cheese('Brie'),Cheese('Parmesan')]

for cheese in catalog:
    # stock把奶酪的名称映射到catalog中Cheese实例的弱引用上
    stock[cheese.kind] = cheese

print(sorted(stock.keys()))  # stock的内容是完整的
# >>>['Brie', 'Parmesan', 'Red Leicester', 'Tilsit']
del catalog  # 删除catalog后
print(sorted(stock.keys())) # stock中的大部分奶酪不见了，为什么不是全部呢？
# for循环中的临时变量cheese变量引用了Parmesan所以Parmesan会被保留
# >>>['Parmesan']
del cheese  # 显式删除cheese
print(sorted(stock.keys()))
# >>>[]

"""
与WeakValueDictionary对应的是WeakKeyDictionary
WeakKeyDictionary的键是弱引用
一些可能的应用:
    可以为应用中其他部分拥有的对象附加数据
    这样就无需为对象添加属性
    这对覆盖属性访问权限的对象尤其有用
WeakSet类:
    保存元素弱引用的集合类,元素没有强引用时,集合会把他们删除"""