属性的代理访问

实现某个实例的属性访问代理到内部另一个实例中去，目的可能是作为继承的一个替代方法或者实现代理模式。

最简单的代理

class A(object):
    def spam(self, x):
        print('A.spam')
    def foo(self):
        print('A.foo')

# 简单的代理
class AProxy(object):

    def __init__(self):
        self._a = A()
    
    def spam(self,x):
        print('B1.spam')
        return self._a.spam(x)
    
    def foo(self):
        print('B1.foo')
        return self._a.foo()
    
    def bar(self):
        print('B1.bar')

b1 = AProxy()
b1.spam(1)
b1.foo()
b1.bar()

输出结果：

B1.spam
A.spam
B1.foo
A.foo
B1.bar

这里AProxy可以认为是A的代理，但是这个代理不方便，必须提前知道A有哪些方法。

使用 __getattr__实现半透明属性代理

class A(object):
    def spam(self, x):
        print('A.spam')
    def foo(self):
        print('A.foo')
# 通用的代理
class AProxy(object):
    def __init__(self):
        self._a = A()
    
    def bar(self):
        print('AProxy.bar')
    # 仅当AProxy没有定义属性时才会访问__getattr__
    def __getattr__(self, name):
        print('AProxy.__getattr__')
        return getattr(self._a, name)

b2 = AProxy()
b2.spam(1)
b2.foo()
b2.bar()
# b2.test() # 'A' object has no attribute 'test'

基本就明白__getattr__定义属性不存在时应该从哪里找，看官网文档：

Called when the default attribute access fails with an AttributeError (either __getattribute__()raises an AttributeError because name is not an instance attribute or an attribute in the class tree for self; or __get__() of a name property raises AttributeError). This method should either return the (computed) attribute value or raise an AttributeError exception.
但是这种属性代理还存在问题，就是通过代理可以访问被代理者的属性，但是无法给被代理者添加属性，无法做到完全透明的代理。

透明属性代理

要想给类添加属性，刚好用到上一节提到的__setattr__，给类设置属性。

# 实现透明代理模式
# __getattr__() 实际是一个后备方法，
# 只有在属性不存在时才会调用。 
# 因此，如果代理类实例本身有这个属性的话，那么不会触发这个方法的。 
# 另外，__setattr__() 和 __delattr__() 需要额外的魔法来区分代理实例和被代理实例 _obj 的属性。 
# 一个通常的约定是只代理那些不以下划线 _ 开头的属性(代理类只暴露被代理类的公共属性)。

class Spam:
    def __init__(self, x):
        self.x = x
    
    def bar(self, y):
        print('Spam.bar', self.x, y)

class SpamProxy(object):

    def __init__(self):
        self._obj = Spam(2)
    
    def __getattr__(self, name):
        print('SpamProxy.__getattr__')
        return getattr(self._obj, name)
    
    def __setattr__(self, name ,value):
        print('SpamProxy.__setattr__', name, value)
        if name.startswith('_'):
            print('super().__setattr__', name, value)
            super().__setattr__(name, value)
        else:
            print('Spam.__setattr__', name, value)
            setattr(self._obj, name, value)
    
    def __delattr__(self, name):
        print('SpamProxy.__delattr__')
        if name.startswith('_'):
            super().__delattr__(name)
        else:
            print('SpamProxy', name)
            delattr(self._obj, name)

p = SpamProxy()
print('---1---')
p.y = 2
print('p.y = ',p.y)
print('---2---')
p.bar(3)
print('------3------')
p._y = 3
print('p._y = ', p._y)
print(p.__dict__)

输出结果：

SpamProxy.setattr _obj <main.Spam object at 0x7ff10a476e48>
super().setattr _obj <main.Spam object at 0x7ff10a476e48>
---1---
SpamProxy.setattr y 2
Spam.setattr y 2
SpamProxy.getattr
p.y = 2
---2---
SpamProxy.getattr
Spam.bar 2 3
------3------
SpamProxy.setattr _y 3
super().setattr _y 3
p._y = 3
{'_obj': <main.Spam object at 0x7ff10a476e48>, '_y': 3}

最需要理解的是SpamProxy的__init__里定义self._obj = Spam()时，也调用了__setattr__，这也是__setattr__使用时常特别需要处理的问题，否则容易出现循环调用__getattr__问题。

对透明属性代理的简单改进

# 实现透明代理模式
# __getattr__() 实际是一个后备方法，
# 只有在属性不存在时才会调用。 
# 因此，如果代理类实例本身有这个属性的话，那么不会触发这个方法的。 
# 另外，__setattr__() 和 __delattr__() 需要额外的魔法来区分代理实例和被代理实例 _obj 的属性。 
# 一个通常的约定是只代理那些不以下划线 _ 开头的属性(代理类只暴露被代理类的公共属性)。

class Spam:
    def __init__(self, x):
        self.x = x

    def bar(self, y):
        print('Spam.bar', self.x, y)

class SpamProxy(object):

    def __init__(self, obj):
        self._obj = obj
    
    def __getattr__(self, name):
        print('SpamProxy.__getattr__')
        return getattr(self._obj, name)
    
    def __setattr__(self, name ,value):
        print('SpamProxy.__setattr__', name, value)
        if name.startswith('_'):
            print('super().__setattr__', name, value)
            super().__setattr__(name, value)
        else:
            print('Spam.__setattr__', name, value)
            setattr(self._obj, name, value)
    
    def __delattr__(self, name):
        print('SpamProxy.__delattr__')
        if name.startswith('_'):
            super().__delattr__(name)
        else:
            print('SpamProxy', name)
            delattr(self._obj, name)
s = Spam(2)
p = SpamProxy(s)

这种调用方式就更加合理，但是还有一个问题能不能通过Spam创建代理SpamProxy呢？如果Spam本身有又管理许多动态创建的对象，那么SpamProxy能不能区别访问Spam管理的对象，尝试一下。