python惰性计算(Lazily evaluated)

python惰性计算(Lazily evaluated)

这是一种常用的设计模式，利用装饰器将Python类中的方法转变为属性，通常用于计算量大，频繁调用，且不带参数的方法，这样在实例化的时候只计算一次，并保存到类属性中，以后直接拿来用就行

实现代码：

import functools


class Lazy:
    def __init__(self, function):
        self.function = function
        functools.update_wrapper(self, function)

    def __get__(self, obj, type_):
        if obj is None:
            return self
        val = self.function(obj)
        obj.__dict__[self.function.__name__] = val
        return val


def lazy(fn):
    attr = "_lazy__" + fn.__name__

    @property
    def _lazy_property(self):
        if not hasattr(self, attr):
            setattr(self, attr, fn(self))
        return getattr(self, attr)

    return _lazy_property

测试一下：

class Count:
    def __init__(self):
        self.count1 = 0
        self.count2 = 0

    @Lazy
    def fa(self):
        # 每调用一次就加一
        self.count1 += 1
        return 99

    @lazy
    def fb(self):
        # 每调用一次就加一
        self.count2 += 1
        return 999


if __name__ == '__main__':
    c = Count()
    print(c.count1, c.count2)
    c.fa
    c.fb
    print(c.count1, c.count2)
    c.fa
    c.fa
    c.fa
    c.fb
    c.fb
    c.fb
    print(c.count1, c.count2)

输出：

0 0
1 1
1 1

注意：调用的时候不可以带括号，因为它已经不是函数了

参考:
Lazily-evaluated