python嵌套属性封装

Question

我对 python 中的封装嵌套属性有一些疑问。让我们假设几个类： 这里我们有一个主类（DataWrapper），其中包括另外两个类：InnerWrapper1 和 InnerWrapper2。两个内部包装器都包含两个属性。

class DataWrapper(object):     
    @property
    def inner_wrapper1(self): 
        return self.__inner_wrapper1
    @inner_wrapper1.setter
    def inner_wrapper1(self, value): 
        self.__inner_wrapper1 = value

    @property
    def inner_wrapper2(self): 
        return self.__inner_wrapper2
    @inner_wrapper2.setter
    def inner_wrapper2(self, value): 
        self.__inner_wrapper2 = value

class InnerWrapper1(object):
    @property
    def property1(self): 
        return self.__property1
    @property1.setter
    def property1(self, value): 
        self.__property1 = value

    @property
    def property2(self): 
        return self.__property2
    @property2.setter
    def property2(self, value): 
        self.__property2 = value

class InnerWrapper2(object):
    @property
    def property3(self): 
        return self.__property3
    @property3.setter
    def property3(self, value): 
        self.__property3 = value

    @property
    def property4(self): 
        return self.__property4
    @property4.setter
    def property4(self, value): 
        self.__property4 = value

是否可以以某种方式覆盖 getattr 和 setattr 方法以实现以下封装？我想要实现的是从顶级类 DataWrapper 访问那些嵌套属性。

data_wrapper = DataWrapper()
data_wrapper.property1 = "abc"
...
var = data_wrapper.property2
...

我想到的第一件事是在 getattr 中执行 hasattr，但这给出了最大的递归深度...

这是一个完整的代码：

class DataWrapper(object):

    def __init__(self):
            self.inner_wrapper1 = InnerWrapper1()
            self.inner_wrapper2 = InnerWrapper2()

    @property
    def inner_wrapper1(self):
            return self.__inner_wrapper1
    @inner_wrapper1.setter
    def inner_wrapper1(self, value):
            self.__inner_wrapper1 = value

    @property
    def inner_wrapper2(self):
            return self.__inner_wrapper2
    @inner_wrapper2.setter
    def inner_wrapper2(self, value):
            self.__inner_wrapper2 = value

    def __setattr__(self, attribute, value):
            #if attribute in {'innerwrapper1', 'innerwrapper2'}:
            if attribute in ['inner_wrapper1', 'inner_wrapper2']:
                    return super(DataWrapper, self).__setattr__(attribute, value)
            if hasattr(self.inner_wrapper1, attribute):
                return setattr(self.inner_wrapper1, attribute, value)
            elif hasattr(self.inner_wrapper2, attribute):
                return setattr(self.inner_wrapper2, attribute, value)



    def __getattr__(self, attribute):
            try:
                    return getattr(self.inner_wrapper1, attribute)
            except AttributeError: pass

            try:
                    return getattr(self.inner_wrapper2, attribute)
            except AttributeError: pass

class InnerWrapper1(object):
    @property
    def property1(self):
            return self.__property1
    @property1.setter
    def property1(self, value):
            self.__property1 = value

    @property
    def property2(self):
            return self.__property2
    @property2.setter
    def property2(self, value):
            self.__property2 = value

class InnerWrapper2(object):
    @property
    def property3(self):
            return self.__property3
    @property3.setter
    def property3(self, value):
            self.__property3 = value

    @property
    def property4(self):
            return self.__property4
    @property4.setter
    def property4(self, value):
            self.__property4 = value

def main():
    data_wrapper = DataWrapper()
    data_wrapper.property1 = "abc"

if __name__ == "__main__":
    main()

Answer 1

您收到无限递归错误，因为您忘记在您的 __init__ 方法中设置 inner_wrapper1 和 inner_wrapper2 属性。

当你这样做时：

self.inner_wrapper1 = InnerWrapper()

Python也会使用你的__setattr__ 方法。然后尝试使用尚不存在的self.inner_wrapper1，因此调用__getattr__，尝试使用尚不存在的self.inner_wrapper1，然后您进入无限递归循环。

在__setattr__将属性设置为超类：

def __setattr__(self, attribute, value):
    if attribute in {'innerwrapper1', 'innerwrapper2'}:
        return super(DataWrapper, self).__setattr__(attribute, value)
    if hasattr(self.inner_wrapper1, attribute):
        return setattr(self.inner_wrapper1, attribute, value)
    elif hasattr(self.inner_wrapper2, attribute):
        return setattr(self.inner_wrapper2, attribute, value)

如果您对“私有”属性使用单个前导下划线（因此 _innerwrapper1 和 _innerwrapper2），您可以进行测试：

def __setattr__(self, attribute, value):
    if attribute[0] == '_':  # private attribute
        return super(DataWrapper, self).__setattr__(attribute, value)

因此您不必对一整套名称进行硬编码。

由于您更新的完整脚本使用__inner_wrapper1 和__inner_wrapper2 作为实际的属性名称，并且您正在使用属性，因此您必须调整您的__setattr__ 测试以查找那些名字。因为您使用的是双下划线名称，所以您需要针对 name mangling of such attributes 进行调整：

def __setattr__(self, attribute, value):
    if attribute in {
            'inner_wrapper1', 'inner_wrapper2',
            '_DataWrapper__inner_wrapper1', '_DataWrapper__inner_wrapper2'}:
        return super(DataWrapper, self).__setattr__(attribute, value)

除非您要继承 DataWrapper 并且必须保护您的属性不被意外覆盖，否则我会完全避免使用双下划线名称。在 Pythonic 代码中，您不必担心其他代码访问属性，没有真正私有属性的概念。

在这里使用属性也是大材小用；属性不会给你买封装，在 Python 中你只会使用那些来简化 API（用属性访问替换方法调用）。

请注意，hasattr() 测试 InnerWrapper* property* 属性将失败，因为您没有默认值：

>>> inner = InnerWrapper1()
>>> hasattr(inner, 'property1')
False

hasattr() 不测试属性，它只是尝试访问一个属性，如果引发 any 异常，它会返回False：

>>> inner = InnerWrapper1()
>>> hasattr(inner, 'property1')
False
>>> inner.property1
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<string>", line 43, in property1
AttributeError: 'InnerWrapper1' object has no attribute '_InnerWrapper1__property1'
>>> inner.property1 = 'foo'
>>> inner.property1
'foo'
>>> hasattr(inner, 'property1')
True

通过删除所有@property 对象，您可以大大简化这一过程：

class DataWrapper(object):
    def __init__(self):
        self._inner_wrapper1 = InnerWrapper1()
        self._inner_wrapper2 = InnerWrapper2()

    def __setattr__(self, attribute, value):
        if attribute[0] == '_':
            return super(DataWrapper, self).__setattr__(attribute, value)
        if hasattr(self._inner_wrapper1, attribute):
            return setattr(self._inner_wrapper1, attribute, value)
        elif hasattr(self._inner_wrapper2, attribute):
            return setattr(self._inner_wrapper2, attribute, value)

    def __getattr__(self, attribute):
        try:
            return getattr(self._inner_wrapper1, attribute)
        except AttributeError: pass
        return getattr(self._inner_wrapper2, attribute)

class InnerWrapper1(object):
    property1 = None
    property2 = None

class InnerWrapper2(object):
    property3 = None 
    property4 = None