代理模式

为其他对象提供一种代理以控制对这个对象的访问。简单的说就是自己不想去干的事情交给代理去干

代理类型：

远程代理：实际存在于不同地址空间的对象在本地的代理者
虚拟代理：用于懒初始化，将一个大计算量对象的创建延迟到真正需要的时候进行。
保护/防护代理：控制对敏感资源对象的访问
引用代理：在对象被访问时执行额外的动作。

其中虚拟代理非常有用

 

 

class LazyProperty:

    def __init__(self, method):
        self.method = method
        self.method_name = method.__name__
        # print('function overriden: {}'.format(self.method))
        # print("function's name: {}".format(self.method_name))

    def __get__(self, obj, cls):
        if not obj:
            return None
        value = self.method(obj)
        # print('value {}'.format(value))
        setattr(obj, self.method_name, value)
        return value


class Test:

    def __init__(self):
        self.x = 'foo'
        self.y = 'bar'
        self._resource = None

    @LazyProperty
    def resource(self):
        print('initializing self._resource which is: {}'.format(self._resource))
        self._resource = tuple(range(5))    # 假设这里的代价大
      return self._resource

def main():
    t = Test()
    print(t.x)
    print(t.y)
    # 做更多的事情。。。
    print(t.resource)
    print(t.resource)

if __name__ == '__main__':
    main()

# _resource变量时机不是在t创建时初始化的，而是在我们首次使用t.resource时

# 第二次使用t.rescourse时，并没有再次初始化变量。

 

 

 

在OOP中有两种基本的、不同类型的懒初始化

在实例级：这意味着会一个对象的特性进行懒初始化，但该特性有一个对象作用域。同一个类的每个实例都有自己的特性副本

在类级或模块级：在这种情况下，我们不希望每个实例都有一个不用的特性副本，而是所有实例共享同一个特性，而特性是懒初始化的。