python对象属性惰性取值

python面向对象进阶

在知乎上面看到这个如何让python对象属性具有惰性求值的能力，认真学习了一番，记录一下。

__setattr__、__getattr__、__delattr__

class Computer(object):
    def __init__(self, brand, type):
        self.brand = brand
        self.type = type

    # def __getattribute__(self, item):
    #     print("----> reference getattribute begin")
    #     super(Computer, self).__getattribute__(item)

    def __getattr__(self, item):
        print("----> reference getattr begin")
        print("item: {0}".format(item))
        if item in self.__dict__:
            return self.__dict__[item]
        else:
            raise Exception("no attr {0}".format(item))

    def __setattr__(self, key, value):
        print("----> reference setattr begin")
        print("***key: {0}, value: {1}***".format(key, value))
        self.__dict__[key] = value


    def __delattr__(self, item):
        print("----> reference delattr begin")
        self.__dict__.pop(item)
        print("----> delattr end")

pc_1 = Computer('thinkpad', "i7")
# print(pc_1.__dict__)
print(pc_1.brand)
# print(pc_1.bran)
pc_1.size = "15.6"
print(pc_1.size)
# 实例化执行init方法，使用点号赋值时会调用__setattr__方法, 不重写这个方法会默认调用父类：父类会执行类似self.__dict__[key] = value
# pc_1.brand 会先直接执行__getattribute__，如果__getattribute__找不到而当前对象有__getattr__方法会去执行__getattr__去找,找不到就返回了
# pc_1.bran, 会首先执行__getattribute__, 如果__getattribute__找不到而当前对象有__getattr__方法会去执行__getattr__去找,找不到就返回了
# 当__getattribute__与__getattr__同时存在,只会执行__getattrbute__,除非__getattribute__在执行过程中抛出异常AttributeError, 也就是说__getattr__只有在使用点调用属性且属性不存在的时候才会触发

__set__、__get__、__del__

# 描述符Str
class Str:
    def __get__(self, instance, owner):
        print('Str调用')

    def __set__(self, instance, value):
        print('Str设置...')

    def __delete__(self, instance):
        print('Str删除...')


class People(object):
    name = Str()

    def __init__(self, name, age):  # name被Str类代理
        self.name = name
        self.age = age


p1 = People('tony', 18)

# 如果描述符是一个数据描述符(即有__get__又有__set__),那么p1.name的调用与赋值都是触发描述符的操作,于p1本身无关了,相当于覆盖了实例的属性
p1.name = 'tonyj'
print(p1.name)
# 实例的属性字典中没有name,因为name是一个数据描述符,优先级高于实例属性,查看/赋值/删除都是跟描述符有关,与实例无关了
print(p1.__dict__)
del p1.name

利用描述符让类的属性具有惰性求值：

class lazyproperty(object):
    def __init__(self, fun):
        print("1111111")
        self.fun = fun

    def __get__(self, instance, owner):
        print("instance : {0}, owner: {1}".format(instance, owner))
        if instance is None:
            return self
        value = self.fun(instance)
        print("func: {0}, funcname: {1}".format(self.fun, self.fun.__name__))
        setattr(instance, self.fun.__name__, value)
        return value

class Circle:
    area = 222
    def __init__(self, radius):
        self.radius = radius

    @lazyproperty
    def area(self):
        print('Computing area')
        return 3.1415 * self.radius ** 2

c = Circle(5)
print(c.__dict__)
print(c.area)
print(c.__dict__)
print(c.area)

# 个人分析： c.area语法首先会去对象属性里去查找，有则返回没有则继续，因为area已经被装饰器装饰，
# 其实c.area是调用c.lazyproperty(area)，又因为lazyproperty是一个类，这时lazyproperty就相当于
# 对象c的一个代理类，这时会触发代理类的__get__方法__get__(self, instance, owner)
# 这里instance就是被代理类的实例，owner就是被代理的类，这里__get__里代码逻辑就是 这里
# value = self.func(instance)执行原函数内容，然后给instance设置值
# setattr(instance, self.fun.__name__, value)，这样之后调用c.area时对象c的属性里就已经存在area属性了