Python设计模式-惰性计算/延迟计算(Lazy Evaluation)

惰性计算/延迟计算(Lazy Evaluation)

目的：类的某个属性来自于一个复杂的耗时的计算，但并不是每次都会调用。通过lazy evaluation模式，可以使该值只在真正需要读取的时候才进行一次计算

示例

import functools

class lazy_property:
    '''一种 lazy property类装饰器'''
    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_property2(fn):
    '''一种 lazy propety函数装饰器'''
    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 Person:
    def __init__(self, name, occupation):
        self.name = name
        self.occupation = occupation
        self.call_count2 = 0

    # 这个装饰器，使Person.relatives可以当做属性来调用，并且，只有在第一次调用的时候会进行一次计算，调用前并不使用计算资源。从从而达到提高性能的目的。
    @lazy_property
    def relatives(self):
        # Get all relatives, let's assume that it costs much time.
        relatives = "Many relatives."
        return relatives

    @lazy_property2
    def parents(self):
        self.call_count2 += 1
        return "Father and mother"

# 调用
if __name__ == '__main__':
    Jhon = Person('Jhon', 'Coder')

    # 调用 Jhon.relatives之前，relatves函数并没有真正执行
    sorted(Jhon.__dict__.items())
    # 预期输出 [('call_count2', 0), ('name', 'Jhon'), ('occupation', 'Coder')]

    Jhon.relatives
    # 预期输出 'Many relatives.'

    # 调用 Jhon.relatives之后，relatves函数已执行并将结果保存到同名属性中
    sorted(Jhon.__dict__.items())
    # 预期输出  [('call_count2', 0), ..., ('relatives', 'Many relatives.')]

    # 调用 Jhon.parents之后，该函数被执行，并将结果保存到_lazy__parents中
    Jhon.parents
    # 预期输出 'Father and mother'

    sorted(Jhon.__dict__.items())
    # 预期输出 [('_lazy__parents', 'Father and mother'), ('call_count2', 1), ..., ('relatives', 'Many relatives.')]
    # 从 call_count2 == 1 可以看出，parents被调用了一次

    # 再次调用 Jhon.parents，parents函数不会被执行，仅仅是从已有的_lazy__parents中取出结果。
    Jhon.parents
    # 预期输出 'Father and mother'

    sorted(Jhon.__dict__.items())
    Jhon.call_count2
    # 预期输出 1