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

 

对象的标注、引用、别名

Python变量类似于Java中的引用式变量,因此最好把他们理解为附加在对象上的标注。

Python赋值语句应该始终先读右边。

对象在右边创建或获取,再此之后左边的变量才会绑定到对象上,这就像为对象贴上标注。

变量只不过是标注,所以无法阻止为对象贴上多个标注。贴的多个标注,就是别名。 

>>> f1 = {'name':'Li','age':19}
>>> f2 = f1    # f2是f1的别名
>>> f2 is f1
True

每个变量(object)都有标识(identity)、类型(type)和值(value)。

对象一旦创建,它的标识绝不会变。可以把标识理解为对象在内存中的地址。

is运算符比较两个对象的标识,id()函数返回对象标识的整数表示,==运算符比较两个对象的值(对象中保存的数据)。

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

 

元组的相对不可变性

元组的相对不可变性:

元组与多数Python集合(列表、字典、集)一样,保存的是对象的引用。

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

 

copy、deepcopy

浅复制:(复制最外层容器,副本中的元素是源容器中元素的引用)

复制列表最简单的方式:

(1)使用构造方法

(2)使用 [ :]

>>> l1 = [1,2,3,4]
>>> l2 = list(l1)
>>> l3 = l1[:]

深复制:副本不共享内部对象的引用

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)

import copy

bus1 = Bus([1,2,3,'David','Tom'])
bus2 = copy.copy(bus1)
bus3 = copy.deepcopy(bus1)

print(id(bus1),id(bus2),id(bus3))
print(id(bus1.passengers),id(bus2.passengers),id(bus3.passengers))

bus1.drop('David')
bus1.pick(998)

print(bus1.passengers)
print(bus2.passengers)
print(bus3.passengers)
View Code

 

函数参数传递模式

函数参数作为引用时:

Python唯一支持的参数传递模式:共享传参(call by sharing)

共享传参:指函数各个形式参数获得实参中各个引用的副本。(函数内部的形参是实参的副本)

def f(a,b):
    a += b
    return a
    
a = 1
b = 2
c = f(a,b)
>>> print(c)
3
>>> print(a,b)
1,2

# ========

def f(a,b):
    a += b
    return a
    
a = [1,2]
b = [3,4]
c = f(a,b)
>>> print(c)
[1, 2, 3, 4]
>>> print(a,b)
[1, 2, 3, 4] [3, 4]

避免使用可变类型作为参数的默认值

bus_team = ['Sue','David','Pat','Maria']
bus = Bus(bus_team)
bus.drop('David')
bus.drop('Pat')
>>> bus_team
['Sue','Maria']

在类中直接把参数赋值给实例变量等于为参数对象创建别名。

class Bus:
    def __init__(self,bus_team):
        if bus_team is None:
            self.bus_passengers = []
        else:
            self.bus_passengers = bus_team

# =============

class Bus:
    def __init__(self,bus_team):
        if bus_team is None:
            self.bus_passengers = []
        else:
            self.bus_passengers = list(bus_team)

 

垃圾回收机制

del和垃圾回收:

del语句删除名称,而不是对象。

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

在Cpython中,垃圾回收使用的主要算法是引用计数。实际上,每个对象都会统计有多少引用指向自己。

当引用计数归零时,对象立即就被销毁。Cpython会在对象上调用__del__方法,然后释放分配给对象的内存。

>>> import weakref 
>>> s1 = {1,2,3}
>>> s2 = s1
>>> ender = weakref.finalize(s1,bye)   # 注册一个回调函数
>>> ender.alive
True
>>> del s1
>>> ender.alive
True
>>> s2 = '123'
Gone with the wind
>>> ender.alive
False

弱引用:

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

弱引用不会增加对象的引用数量。

引用的目标对象称为所指对象(referent),弱引用不会妨碍所指对象被当作垃圾回收。

WeakValueDictionary 类实现的是一种可变映射,里面的值是对象的弱引用。

被引用的对象在程序中的其他地方被当作垃圾回收后,对应的键会自动从WeakValueDictionary中删除。

class Cheese:
    def __init__(self,kind):
        self.kind = kind

>>> import weakref
>>> stock = weakref.WeakValueDictionary()
>>> catalog = [Cheese('Red Leicester'),Cheese('Tilsit'),Cheese('Parmesan')]
>>> for cheese in catalog:
            stock[chess.kind] = cheese

>>> sorted(stock.keys())
['Parmesan','Red Leicester','Tilsit']
>>> del catalog
>>> sorted(stock.keys())
['Parmesan']
>>> del cheese
>>> sorted(stock.keys())
[]

▲ for循环中的变量cheese是全局变量,除非显式删除,否则不会消失。

weakref 模块还提供了WeakSet 类,如果一个类需要知道所有实例,一种好的方案是创建一个WeakSet 保存实例引用。

常规Set实例永远也不会被垃圾回收,因为类中有实例的强引用。而类存在的时间与Python进程一样长,除非显式删除类。

弱引用的局限:

基本的list和dict实例不能作为所指对象,但是他们的子类可以。set实例和用户自定义类型可以作为所指对象。

同时int和tuple实例不能作为弱引用的目标,甚至它们的子类也不行。

class Mylist(list):
    ...

a_list = Mylist(range(10))
wref_to_a_list = weakref.ref(a_list)

  

 

posted @ 2019-07-17 16:05  5_FireFly  阅读(191)  评论(0编辑  收藏  举报
web
counter